sshark

8.....4..72......9..4.........1.7..23.5...9...4...........8..7..17...............
.........8......2..7............53...1..7...6..32...8..6.5....9..4....3......9...
12..4......5..9.1...9...5.........7.7...52.9..3......2.9.6.......................
...57..3.1......2.7...234......8...4..7..4...49..................................
...1523........92..........1....47.8.......6............9...5.6.4.9.7............
1.........3..2...8..96..5....53..9...1..8...26....4...3......1...................
....................4.6..21.18......3..1.2..6......81.52..7.9...................2
...92......68.....19.......23..4.1....1...7....8.3........8..91..................
.6.5.4.3.1...9...8.........9...5...6...........................4...8...1.5.2.3.4.
7.....4...2..7..8...3..8......5..3...6..2..9...1.97..6...3.......................

sshark

package pnorvig.ipynb;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.stream.IntStream;

sshark

trait Functor[F[_]]:
  def map[A, B](fa: F[A])(f: A => B): F[B]

trait Monad[F[_]] extends Functor[F]:
  def unit[A](a: A): F[A]
  def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
  def map[A, B](fa: F[A])(f: A => B): F[B] = flatMap(fa)(x => unit(f(x)))

object Monad:
  def apply[F[_]](using ev: Monad[F]): Monad[F] = ev

sshark

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.*

def delay(delay: Long)(id: String) = Future {
  Thread.sleep(delay)
  println(s"$id done")
  id
}

def fast(id: String) = delay(500)(id)

sshark

//import cats.Applicative
//import cats.implicits.*

/*
def sequence[A, F[_], G[_]](fga: F[G[A]])(using Traverse[F], Applicative[G]): G[F[A]] =
  traverse(fga)(identity)

trait Traverse[F[_]]:
  def traverse[A, B, G[_]](fa: F[A])(f: A => G[B])(using Applicative[G]): G[F[B]]
*/  

sshark

package th.lim.dojo3.concurrent

import cats.effect.std.{Console, Random, SecureRandom}
import cats.effect.{IO, IOApp}
import cats.syntax.all.{toFlatMapOps, toFunctorOps}
import cats.{FlatMap, Functor}

/** An example of using Random[F] in additional to
  * https://typelevel.org/cats-effect/docs/std/random#using-random
  */

sshark

package org.teckhooi;

import java.time.Duration;
import java.util.LinkedList;
import java.util.Optional;
import java.util.Queue;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

sshark

package th.lim;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/** 
 * Suppose we have the following code:
 * 
 * class Foo {
 *   void first() {...}

sshark

/** This is a summary of this website
  * https://www.foxhound.systems/blog/final-tagless/ with the example written in
  * Scala.
  *
  * This is an example of tagged initial encoding. It is tagged because
  * SqlExprResult is used to streamlined the returned values. It is initial
  * encoding because eval has to perform pattern matching.
  *
  * Use GADT (Generalized Algebraic Data Type) to make it tag-less initial
  * encoding.

sshark

package org.teckhooi.dojo3.concurrent

import cats.effect.{IO, IOApp}

import scala.concurrent.duration.*

object CancellableTask extends IOApp.Simple {
  def task(i: Int, d: Duration): IO[Unit] = IO.sleep(d) *> IO.println(s"Task $i completed")

  override def run: IO[Unit] = for {