justinhj

type Species = 'hobbit' | 'orc' | 'elf' | 'man';

interface MiddleEarthDenizen {
    name:  string
    species: Species
}

interface Hobbit extends Omit<MiddleEarthDenizen, 'species'> {
    burrow: string
    species: 'hobbit'

justinhj

#include <iostream>
#include <vector>
#include <ranges>
#include <algorithm>

using namespace std;

class Solution {
public:
    string m2(string num1, int multiplier, int zeros) {

justinhj

Follow these instructions after you have Rustup, Scoopy and cmder installed.

https://jrhawley.ca/2020/05/25/rust-toolchain-windows

One extra bit of info is to set the path in cmder follow these instructions

https://jonathansoma.com/lede/foundations-2019/terminal/adding-to-your-path-cmder-win/

Find msys in the scoop folder and add the path, mine was here...

justinhj

Found 546487 words in the book
Words with the most uncommon occurence in the English words found on the web
See https://www.kaggle.com/rtatman/english-word-frequency

sibilance (12720)
hubristic (12760)
hellishly (12784)
jerkily (12785)
antimissile (12799)
mildews (12801)

justinhj

package org.justinhj

object Scala2WriterTWithCats extends App  {

  // Implement WriterT using Cats implementation of Monad and Monoids

  import cats.{Monad, Monoid}

  case class WriterT[F[_]: Monad,W,A](val wrapped: F[(W,A)])

justinhj

object WriterTest extends App {

  trait Semigroup[A]:
    def combine(al: A, ar: A): A

  object Semigroup:
    def apply[A](using s: Semigroup[A]) = s

  trait Monoid[A] extends Semigroup[A]:
    def zero: A

justinhj

package org.justinhj

object WriterTOldSchool extends App  {

  import cats.{Monad, Monoid}

  case class WriterT[F[_]: Monad,W,A](val wrapped: F[(W,A)])

  implicit def writerTMonad[F[_]: Monad,W: Monoid] = new Monad[WriterT[F,W,?]] {

justinhj

// Macro that crashes the compiler

import scala.quoted._

def takeOptionImpl[T](o: Expr[Option[T]], default: Expr[T])(using Quotes, Type[T]): Expr[T] = '{
 $o match {
   case Some(t1) => t1
   case None: Option[T] => $default
 }
}

justinhj

object Temp {
  final case class Person(name: String, age: Int)

  case class Person2(p: Person)

  val personLayer = ZLayer.succeed(Person("Nero", 4))
  val ageLayer    = personLayer.project(_.age)
  val person2Layer = ZLayer.succeed(Person2(Person("Nero2", 8)))

  val p = (for (

justinhj

def play(gridStr: String): String = {
    val grid = convertStringToGrid(gridStr)

    val newG = grid.zipWithIndex.map {
      case (row, x) =>
        row.zipWithIndex.map {
          case (col, y) => {
            val count = countNeighbours(grid, x, y)
            if(count == 2 || count == 3)
              true