Arnau Abella monadplus

Daniel Spiewak on gitter

Think about the closing action of a bracket. I'll use IO and Resource here as the archetypical examples, but Stream is also a very good exemplar, and obviously all of the cats-effect implementors have IO-like semantics in this regard.

So the closing action of a bracket with IO will be sequenced after the result is produced (or an error, or cancelation). Thus, imagine a chain like fa1 *> fa2 *> fa3. If fa1 is created by bracket, then the finalizer will be sequenced before fa2. Thus, associating to the left over bind.

About JMH (Java Harness)

Samples and more documentation on: https://github.com/ktoso/sbt-jmh/tree/master/plugin/src/sbt-test/sbt-jmh/run/src/main/scala/org/openjdk/jmh/samples

To benchmark a method add the annotation. You can have multiple benchmark methods within the same class.

class Foo {
   @Benchmark

Join and Cancel on a fiber

When dealing with fibers you must be very careful not to cancel before joining, otherwise the join will leak.

Look at the following example:

for {
 fiber &lt;- IO.sleep(2.seconds).start

	trait Ops[A] {
	def typeClassInstance: Show[A]
	def self: A
	def show: String = typeClassInstance.show(self)
	}

	trait ToShowOps {
	implicit def toShow[A](target: A)(implicit tc: Show[A]): Ops[A] = new Ops[A] {
	val self = target
	val typeClassInstance = tc

	package trampoline

	import scala.annotation.tailrec

	/**
	* Trampoline is a way to make non-tail recursive functions stack-safe
	*
	* Author: Rúnar Bjarnason
	* Source: http://blog.higher-order.com/assets/trampolines.pdf
	*/

	import shapeless._
	import scala.annotation.implicitNotFound

	trait DeepFn1[T] {
	type Out
	def apply(t: T): Out
	}

	@implicitNotFound("Implicit not found: Last[${L}]. ${L} is empty, so there is no last element.")
	trait Last[L] extends DeepFn1[L]

	abstract class Semaphore[F[_]] {

	/**
	* Returns the number of permits currently available. Always non-negative.
	*
	* May be out of date the instant after it is retrieved.
	* Use `[[tryAcquire]]` or `[[tryAcquireN]]` if you wish to attempt an
	* acquire, returning immediately if the current count is not high enough
	* to satisfy the request.
	*/

	package exercises

	import cats._, cats.data._, cats.implicits._
	import cats.effect._, cats.effect.implicits._, cats.effect.concurrent._
	import fs2._

	import scala.concurrent.duration._
	import scala.util._
	import java.util.concurrent.atomic._
	import scala.concurrent._

	Daniel Spiewak (2019-05-21)(https://gitter.im/typelevel/cats-effect?at=5ce427229404bf2aed85b08b):

	Actors elevate the message and the message handlers to "first-class" status in the abstraction
	But messages and handlers are almost never the hard things about a system.
	The hard thing to understand and control is always the data flow, but actors make this actively
	worse because the emergent properties become incredibly difficult to trace and reason about.

	Actors are, to me, a failed abstraction in every case except when you're literally
	designing a system which… sends messages. So a telecom. Applying them to a broader class
	of things was a really neat idea, but frankly one which doesn't carry its weight in practice.

	GC1 is not the default GC in java_1.8
	You can check it at:
	`$ java -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -version`

	To set G1GC:
	$ java -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -XX:+UseG1GC -version