Gabriel Volpe gvolpe

Understanding Comparative Benchmarks

I'm going to do something that I don't normally do, which is to say I'm going to talk about comparative benchmarks. In general, I try to confine performance discussion to absolute metrics as much as possible, or comparisons to other well-defined neutral reference points. This is precisely why Cats Effect's readme mentions a comparison to a fixed thread pool, rather doing comparisons with other asynchronous runtimes like Akka or ZIO. Comparisons in general devolve very quickly into emotional marketing.

But, just once, today we're going to talk about the emotional marketing. In particular, we're going to look at Cats Effect 3 and ZIO 2. Now, for context, as of this writing ZIO 2 has released their first milestone; they have not released a final 2.0 version. This implies straight off the bat that we're comparing apples to oranges a bit, since Cats Effect 3 has been out and in production for months. However, there has been a post going around which cites various compar

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
    */
 def use[B](f: A =&gt; F[B]): F[B]

Generalized Algebraic Data Types in Scala

Basic GADTs

Here's an ADT which is not a GADT, in Haskell:

data Expr = IntExpr Int | BoolExpr Bool

Laws

A law is a group of two or more expressions which are required to be the same. The expressions will usually involve one or more typed holes ("inputs") which vary.

Some examples:

x.map(id) === x

Preliminaries

type Void <: Nothing
type ¬[-A] = A => Void
type ¬¬[+A] = ¬[¬[A]]
type ⋁[+A, +B] = Either[A, B]
type ⋀[+A, +B] = Tuple2[A, B]

	object RaceN {
	import cats.implicits._
	import cats.effect._
	import cats.effect.concurrent._
	import cats.data.NonEmptyList

	// Use with atleast 3, otherwise you should prefer Concurrent.race
	def raceN[F[_]: Concurrent, A](x1: F[A], x2: F[A], x3: F[A], xs: F[A]*): F[Either[NonEmptyList[Throwable], A]] = {
	for {
	deferred <- Deferred[F, A]

	package org.bykn.refmap

	import cats.data.State
	import cats.effect.Sync
	import cats.effect.concurrent.Ref
	import java.util.concurrent.ConcurrentHashMap

	import cats.implicits._

	/**

	-- This illustrates (most of) a new(?) encoding of ad-hoc polymorphism using
	-- dependent types and implicits.
	--
	-- Benefits of this approach:
	-- • can have multiple “ambiguous” instances without requiring things like
	-- Haskell’s newtypes to distinguish them;
	-- • can disambiguate instances with minimal information, rather than having to
	-- know some arbitrary instance name as you would with a system like Scala’s
	-- implicits;
	-- • implementers don’t need to know/provide the full family of instances – they

	import cats.data.Kleisli
	import cats.effect.{ Concurrent, Sync }
	import cats.effect.concurrent.MVar
	import cats.implicits._
	import cats.{ Applicative, Functor, Monad }

	// Let's start with our dsl

	// First we need to interact with a console
	trait Console[F[_]] {

	package quantified

	import cats.Monad

	import scala.language.implicitConversions

	/** C[_] constraint applied to type F[_, _] quantified in first parameter */
	final class Quant[+C[_[_]], F[_, _]] private (private val erased: C[F[Any, ?]]) extends AnyVal {
	type State = Defined