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

Tagless Final Summary

I create this gist to summarize my understanding on tagless final that I read in the article A "quick" introduction to Tagless Final.

Tagless

The first word "Tagless" makes reference to the return types that are not tagged or grouped using GADT, ADT or union types, Int | String. Yet. the return types can be "anything".

Final

Initial encoding uses ADT etc. to encode the expressions, Then use an interpretor to evaluate the expressions. On the other hand, final encoding uses functions to model the expression. With functions, tags and interpretors are not required.

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 {