EitherTSupport - Scalaz

EitherTSupport

import scalaz._
import Scalaz._
import effectie.scalaz.Effectful._
import effectie.scalaz._
import effectie.scalaz.EitherTSupport._
trait Something[F[_]] {
def foo(a: Int): F[String \/ Int]
def bar(a: String \/ Int): F[String \/ Int]
}
object Something {
def apply[F[_]: Something]: Something[F] =
implicitly[Something[F]]
implicit def something[F[_]: EffectConstructor: Monad]: Something[F] =
new SomethingF[F]
final class SomethingF[F[_]: EffectConstructor: Monad]
extends Something[F] {
def foo(a: Int): F[String \/ Int] = (for {
x <- eitherTRightPure(a) // == EitherT(pureOf(a).map(_.right[String]))
y <- eitherTRight(x + 10) // == EitherT(effectOf(x + 10).map(_.right[String]))
y2 <- if (y > 100)
eitherTLeft[Int]("Error - Bigger than 100")
else
eitherTRightPure[String](y)
// โ†‘ if (y > 100)
// EitherT(effectOf("Error - Bigger than 100").map(_.left[Int]))
// else
// EitherT(pureOf(y).map(_.right[String]))
z <- eitherTRightF[String](effectOf(y2 + 100)) // == EitherT(effectOf(y + 100).map(_.right))
} yield z).run
def bar(a: String \/ Int): F[String \/ Int] = (for {
x <- eitherTOfPure(a) // == EitherT(pureOf(a: String \/ Int))
y <- eitherTOf((x + 999).right[String]) // == EitherT(effectOf((x + 999).right[String]))
} yield y).run
}
}
import scalaz.effect._
Something[IO].foo(1).unsafePerformIO()
// res1: String \/ Int = \/-(111)
Something[IO].foo(10).unsafePerformIO()
// res2: String \/ Int = \/-(120)
Something[IO].bar(1.right[String]).unsafePerformIO()
// res3: String \/ Int = \/-(1000)
Something[IO].bar("No number".left[Int]).unsafePerformIO()
// res4: String \/ Int = -\/("No number")