Gabriel Volpe gvolpe

cats-effect

The cats-effect project defines a purely functional effect type (IO[A]), and associated typeclasses defining its behaviour. The ones we care about for this example are:

trait Sync[F[_]] extends MonadError[F, Throwable] {
   def delay[A](a: => A): F[A]
   ...
}

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

Optics By Example Cheat Sheets

The following are appendices from Optics By Example, a comprehensive guide to optics from beginner to advanced! If you like the content below, there's plenty more where that came from; pick up the book!

Operators
Composition Guide
Substitution Guide
Optical Constarints and Types

Operator Cheat Sheet

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

	package quantified

	import cats.Monad

	import scala.language.implicitConversions

	/**
	* C[_] constraint applied to type F[_, _] quantified in first parameter, i.e.
	*
	* {{{


	// This is the traditional encoding, using abstract type members
	// to encode existentials
	object AbstractExistentials {
	trait E {
	type X
	val x: X
	def f(p: X): String
	}

	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[_]] {

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