Gabriel Volpe gvolpe

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]

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

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

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

	/**

	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]