TH Lim 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.

	enum Json:
	case IntJson(value: Int) extends Json
	case StringJson(value: String) extends Json

	import Json.StringJson
	import Json.IntJson

	case class AsJson(json: Json)

	trait Encoder[A]:

	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.......................

	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;

	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

	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)

	//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]]
	*/

	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
	*/

	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;

	package th.lim;

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

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