The Either effect is similar to the Option effect but adds the possibility to specify why a computation stopped:

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

   * Stack declaration
  type S = Fx.fx1[Either[String, *]]

  // compute with this stack
  val map: Map[String, Int] =
    Map("key1" -> 10, "key2" -> 20)

  // get 2 keys from the map and add the corresponding values
  def addKeys(key1: String, key2: String): Eff[S, Int] = for {
    a <- optionEither(map.get(key1), s"'$key1' not found")
    b <- optionEither(map.get(key2), s"'$key2' not found")
  } yield a + b

  (addKeys("key1", "key2").runEither.run, addKeys("key1", "missing").runEither.run)

> (Right(30),Left('missing' not found))

Note: the * syntax comes from the kind-projector project and allows us to avoid type lambdas.

A catchLeft method can also be used to intercept an error and possibly recover from it:

  case class TooBig(value: Int)
  type E = Fx.fx1[Either[TooBig, *]]

  val i = 7

  val value: Eff[E, Int] =
    if (i > 5) left[E, TooBig, Int](TooBig(i))
    else       right[E, TooBig, Int](i)

  val action: Eff[E, Int] = catchLeft[E, TooBig, Int](value) { case TooBig(k) =>
    if (k < 10) right[E, TooBig, Int](k)
    else        left[E, TooBig, Int](TooBig(k))

  action.runEither.run ==== Right(7)

Note: the type annotations on left and right can be avoided by adding an implicit declaration in scope. You can learn more about this in the Implicits section.