Installation

You add eff as an sbt dependency:

libraryDependencies += "org.atnos" %% "eff" % "7.0.1"

// to write types like Reader[String, *]
libraryDependencies ++= {
  if (scalaBinaryVersion.value == "3") {
    Nil
  } else {
    Seq(compilerPlugin("org.typelevel" %% "kind-projector" % "0.13.3" cross CrossVersion.full))
  }
}

scalacOptions ++= {
  if (scalaBinaryVersion.value == "3") {
    Seq("-Ykind-projector")
  } else {
    Nil
  }
}

To get types like Reader[String, *] (with more than one type parameter) correctly inferred, you’ll have to use the following compiler option

scalacOptions ++= {
  if (scalaBinaryVersion.value == "2.12") {
    Seq("-Ypartial-unification")
  } else {
    Nil
  }
}

Additional dependencies

This table lists the other available eff modules:

Name	Functionality
`eff-scalaz`	if you want to use Scalaz as a library for functional programming. This gives you a `Scalaz` `Monad` instance for `Eff` and a Scalaz’s `\/` effect
`eff-monix`	to use Monix’s `Task` effect
`eff-cats-effect`	to use cats’s `IO` effect
`eff-twitter`	to use Twitter’s `Future` effect
`eff-doobie`	to use Doobie’s `ConnectionIO` effect

Imports

Main types

The main eff types: Eff, Member, Fx are accessible in the org.atnos.eff package:

import org.atnos.eff._

Many other effects are also available Out of the box.

Creating effects

The functions used to create effects are grouped under different objects named after the effect type. For example if you want to create the Eval effect you need to import:

import org.atnos.eff.eval._

You can also import most of the effects at once with:

import org.atnos.eff.all._

The only effects not included in the previous import are:

the Error effect. This effect requires a type parameter representing the “failure” type and must be provided by the user of the library
the Future effect. This effect shares some operations like runAsync with other “async” effects like monix’s TaskEffect and the import could clash with import org.atnos.eff.addon.monix.task._

Interpreting effects

Interpreting effects usually requires some syntax to “run” a given effect. For example to “run” the Option effect you will import:

// to create the effect
import org.atnos.eff.option._

// to access the runOption method
import org.atnos.eff.syntax.option._

fromOption(Option(1)).runOption

You can also access all the syntax imports at once with:

import org.atnos.eff.syntax.all._

Intellij support

Intellij error highlighting doesn’t support implicit-directed type inference yet, check https://youtrack.jetbrains.com/issue/SCL-11140 or https://youtrack.jetbrains.com/issue/SCL-10753 for progress.

With Scalaz

If you use Scalaz as your functional programming library you might need additional imports in order to use some creation methods specific to Scalaz. For example:

import org.atnos.eff.addon.scalaz.either._

fromDisjunction(\/-(1))

There is also an all object importing all those methods at once:

import org.atnos.eff.addon.scalaz.all._

fromDisjunction(\/-(1))

And you can already guess, there are some syntax imports following the same pattern:

import org.atnos.eff.addon.scalaz.either._
import org.atnos.eff.addon.scalaz.syntax.either._

fromDisjunction(\/-(1)).runDisjunction