Belikin Roman roman0x58

Fibers

Fibers are an abstraction over sequential computation, similar to threads but at a higher level. There are two ways to think about this model: by example, and abstractly from first principles. We'll start with the example.

(credit here is very much due to Fabio Labella, who's incredible Scala World talk describes these ideas far better than I can)

Callback Sequentialization

Consider the following three functions

Concurrent resource caching for cats

Motivation

cats-effect Resource is extremely handy for managing the lifecycle of stateful resources, for example database or queue connections. It gives a main interface of:

trait Resource[F[_], A] {
  /** - Acquire resource
    * - Run f
 * - guarantee that if acquire ran, release will run, even if `use` is cancelled or `f` fails

Operation	Input	Result	Notes
map	`F[A]` , `A => B`	`F[B]`	Functor
apply	`F[A]` , `F[A => B]`	`F[B]`	Applicative
(fa, fb, ...).mapN	`(F[A], F[B], ...)` , `(A, B, ...) => C`	`F[C]`	Applicative
(fa, fb, ...).tupled	`(F[A], F[B], ...)`	`F[(A, B, ...)]`	Applicative
flatMap	`F[A]` , `A => F[B]`	`F[B]`	Monad
traverse	`F[A]` , `A => G[B]`	`G[F[A]]`	Traversable; `fa.traverse(f)` == `fa.map(f).sequence`; "foreach with effects"
sequence	`F[G[A]]`	`G[F[A]]`	Same as `fga.traverse(identity)`
attempt	`F[A]`	`F[Either[E, A]]`	Given `ApplicativeError[F, E]`

Thread Pools

Thread pools on the JVM should usually be divided into the following three categories:

CPU-bound
Blocking IO
Non-blocking IO polling

Each of these categories has a different optimal configuration and usage pattern.

	// using scala 3.1.0

	import scala.deriving.Mirror

	object Mirrors:

	extension [A <: Product](a: A)(using m: Mirror.ProductOf[A])
	def toTuple: m.MirroredElemTypes = Tuple.fromProductTyped(a)

	extension [T <: Tuple](t: T)

	/*
	scalaVersion := "2.12.7"

	resolvers += Resolver.sonatypeRepo("snapshots")

	libraryDependencies += "co.fs2" %% "fs2-core" % "1.0.1-SNAPSHOT"
	*/
	import cats._
	import cats.implicits._
	import cats.effect._

	package fpmax

	import scala.util.Try
	import scala.io.StdIn.readLine

	object App0 {
	def main: Unit = {
	println("What is your name?")

	val name = readLine()

	import java.io.OutputStream
	import java.util.concurrent.Executors

	import cats.effect.{Async, Effect, IO, Timer}
	import cats.implicits._
	import fs2.async.mutable.Queue
	import fs2.{Chunk, Stream}

	import scala.annotation.tailrec
	import scala.concurrent.{ExecutionContext, SyncVar}

	package teikametrics

	import cats.effect.implicits._
	import cats.effect.{ContextShift, ExitCase, Sync, Timer}
	import cats.syntax.all._

	import scala.concurrent.ExecutionContext
	import scala.concurrent.duration.FiniteDuration

	object JavaFuture {

	license: gpl-3.0
	height: 600
	scrolling: no
	border: no