gvolpe

import java.util.concurrent.CompletionStage

import cats.effect.Async
import cats.syntax.flatMap._

case object EmptyValue extends Throwable

def to[F[_], A](fa: F[CompletionStage[A]])(implicit F: Async[F]): F[A] = {
  fa.flatMap { f =>
    F.async[A] { cb =>

gvolpe

import cats.MonadError
import cats.effect.IO
import cats.effect.concurrent.Deferred
import cats.instances.list._
import cats.instances.string._
import cats.kernel.Monoid
import cats.syntax.all._

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration._

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

gvolpe

Revisiting Tagless Final Interpreters

Tageless Final interpreters are an alternative to the traditional Algebraic Data Type (and generalized ADT) based implementation of the interpreter pattern. This document presents the Tageless Final approach with Scala, and shows how Dotty with it's recently added implicits functions makes the approach even more appealing. All examples are direct translations of their Haskell version presented in the Typed Tagless Final Interpreters: Lecture Notes (section 2).

The interpreter pattern has recently received a lot of attention in the Scala community. A lot of efforts have been invested in trying to address the biggest shortcomings of ADT/GADT based solutions: extensibility. One can first look at cats' Inject typeclass for an implementation of [Data Type à la Carte](http://www.cs.ru.nl/~W.Swierstra/Publications/DataTypesA

gvolpe

def blocking[F[_], A](fa: F[A])(implicit F: Async[F], timer: Timer[F]): F[A] =
    F.bracket(Async.shift(blockingPool))(_ => ....)(_ => timer.shift)

gvolpe

import cats.Monad
import cats.effect.{IO, Sync}
import cats.syntax.flatMap._
import cats.syntax.functor._

trait Command[F[_]] {
  def getStrLn: F[String]
  def putStrLn(string: String): F[Unit]
}

gvolpe

import cats.effect._
import cats.syntax.apply._
import fs2._
import scala.util.Random

val ioa: IO[Option[Int]] = IO(Random.nextInt(100)).flatMap { n =>
  if (n % 2 == 0) IO(println(s"$n")) *> IO.pure(Some(n))
  else IO(println(s"ERROR >> $n")) *> IO.raiseError(new Exception(s"Error $n"))
}

gvolpe

import cats.MonadError
import cats.effect.{IO, LiftIO}
import cats.syntax.all._
import com.olegpy.meow.hierarchy._

sealed trait CustomError extends Throwable
case class ErrorOne(msg: String) extends CustomError
case class ErrorTwo(id: Int) extends CustomError

trait UsersAlgebra[F[_]] {

gvolpe

 import cats.effect.{ExitCode, IO, IOApp, Timer}
import cats.syntax.apply._
import cats.syntax.functor._

import scala.concurrent.duration._

object scheduler extends IOApp {

  def repeatAtFixedRate(period: FiniteDuration, task: IO[Unit])

gvolpe

Explaining Miles's Magic

Miles Sabin recently opened a pull request fixing the infamous SI-2712. First off, this is remarkable and, if merged, will make everyone's life enormously easier. This is a bug that a lot of people hit often without even realizing it, and they just assume that either they did something wrong or the compiler is broken in some weird way. It is especially common for users of scalaz or cats.

But that's not what I wanted to write about. What I want to write about is the exact semantics of Miles's fix, because it does impose some very specific assumptions about the way that type constructors work, and understanding those assumptions is the key to getting the most of it his fix.

For starters, here is the sort of thing that SI-2712 affects:

def foo[F[_], A](fa: F[A]): String = fa.toString