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 {

sshark

package org.teckhooi.concurrent

import cats.effect.{IO, IOApp}
import cats.implicits.catsSyntaxFlatMapOps

object ParTraverseApp extends IOApp.Simple {
  override def run: IO[Unit] = {
    def parTraverse[A, B](as: List[A])(f: A => IO[B]): IO[List[B]] =
      as.map(a => f(a).start)
        .foldLeft(IO.pure(List.empty[B]))((ioList, ioFibre) =>

sshark

import java.util.*;

public class ListMapDeepCopy {
    static <A, B> void deepCopy(List<Map<A,B>> target, List<Map<A,B>> source ) {
        target.clear();
        source.forEach(m -> target.add(new HashMap<>(m)));
    }

    public static void main(String[] args) {
        Map<String, Integer> foobar1 = new HashMap<>();

sshark

package org.teckhooi.fp.dojo2.fpis.iostream

import org.teckhooi.fp.dojo2.fpis.iostream.Process.{Await, Emit, Halt}

sealed trait Process[I, O] {

  import Process._

  def apply(s: LazyList[I]): LazyList[O] = this match {
    case Halt()           => LazyList()