深圳scala-meetup-20180902（3）- Using heterogeneous Monads in for-comprehension with Monad Transformer

scala中的Option类型是个很好用的数据结构，用None来替代java的null可以大大降低代码的复杂性，它还是一个更容易解释的状态表达形式，比如在读取数据时我们用Some(Row)来代表读取的数据行Row，用None来代表没有读到任何数据，免去了null判断。由此我们可以对数据库操作的结果有一种很直观的理解。同样，我们又可以用Either的Right(Row)来代表成功运算获取了结果Row，用Left(Err)代表运算产生了异常Err。对于数据库编程我还是选择了Task[Either[E,Option[A]]]这种类型作为数据库操作运算的统一类型。可以看到这是一个复合类型：首先Task是一个non-blocking的运算结果类型，Either[E,Option[A]]则同时可以处理发生异常、获取运算结果、无法获取结果几种状态。我觉着这样已经足够代表数据库操作状态了。

在Task[Either[E,Option[A]]]这个复合类型中的组成类型Option[A],Either[E,A]实际上是包嵌A类型元素的不同管道，各自可以独立支持Monadic编程，如下：

object session2 extends App {
  val value: Option[Int] = Some()
  def add(a: Int, b: Int): Option[Int] = Some(a+b)

  val p = for {
    a <- value
    b <- add(a, )
    _ <- None
    c <- add(a,b)
  } yield a

  println(p)      // None

}

object session21 extends App {
  val value: Either[String,Int] = Right()
  def add(a: Int, b: Int): Either[String,Int] = Right(a+b)

  val p = for {
    a <- value
    b <- add(a, )
    _ <- Left("oh no ...")
    c <- add(a,b)
  } yield c

  println(p)     //Left("oh no ...")

如果我们把这两个类型在for-comprehension里结合使用：

object session22 extends App {
  val ovalue: Option[Int] = Some()
  val evalue: Either[String,Int] = Right()

  val p = for {
    a <- ovalue
    b <- evalue
    c = a * b
  } yield c

  println(p)

}

Error:(, ) type mismatch;
 found   : scala.util.Either[String,Int]
 required: Option[?]
    b <- evalue

无法通过编译！当然，这是因为Option,Either是不同的Monad。如果我们把这两个Monad结合形成一个复合的类型，那么用for-comprehension应该没什么问题，如下：

object session23 extends App {
  def combined(int i): Task[Either[String,Option[Int]] = ???
  val p = for {
    a <- combined()
    b <- combined()
    c = a * b
  } yield c

  println(p)  //Task(Right(5))

}

我们可能需要通过函数组合来构建这个复合类型。通过证明，Functor是可以实现函数组合的，如下：

object session4 extends App {
  def composeFunctor[M[_],N[_]](fa: Functor[M], fb: Functor[N]
                    ): Functor[({type mn[x] = M[N[x]]})#mn] =
    new Functor[({type mn[x] = M[N[x]]})#mn] {
      def map[A, B](fab: M[N[A]])(f: A => B): M[N[B]] =

        fa.map(fab)(n => fb.map(n)(f))
    }
  val optionInList = List(Some(""),Some(""),Some(""))
  val optionInListFunctor = composeFunctor(Functor[List],Functor[Option])

  val strlen: String => Int = _.length
  println(optionInListFunctor.map(optionInList)(strlen))

}

//List(Some(1), Some(2), Some(3))

以上代码证明Functor[M]可以通过函数组合和Functor[N]形成Functor[M[N]]。好像这正是我们需要对两个Monad要做的。遗憾的是Monad是不支持函数组合的，如下：

  def composeMonad[M[_],N[_]](ma: Monad[M], mb: Monad[N]
                   ): Monad[({type mn[x] = M[N[x]]})#mn] =
     new Monad[({type mn[x] = M[N[x]]})#mn] {
       def pure[A](a: => A) = ma.point(mb.pure(a))
        def bind[A,B](mab: M[N[A]])(f: A => M[N[B]]): M[N[B]] =
           ??? ...
  }

因为我们无法实现组合后的Monad特质函数bind，所以这条路走不通了。不过cats函数组件库提供了OptionT,EitherT这两个Monad Transformer，它们的类型款式如下：

final case class OptionT[F[_], A](value: F[Option[A]]) {...}
inal case class EitherT[F[_], A, B](value: F[Either[A, B]]) {...}

//包嵌类型
OptionT[Task,A] => Task[Option[A]]
EitherT[Task,A,B] => Task[Either[A,B]]

//多层套嵌
Task[Either[E,Option[A]]] => OptionT[EitherT[Task,E,A],A]

Monad Transformer包嵌的类型正是我们需要的类型，我们可以用Task来代表F[_]。实际上EitherT也可以被视为一种F[_]，所以从OptionT[EitherT[Task,E,A],A]可以得到Task[Either[E,Option[A]]]。注意复合型Monad Transformer的组成是由内向外反向的：Option[A]是最内的元素，那么在合成时就摆在最外。下面我们就用type定义简化整个描述：

  type DBOError[A] = EitherT[Task,String,A]
  type DBOResult[A] = OptionT[DBOError,A]

这样表示就清楚多了，这个DBOResult[A]就是我们需要对付的类型。剩下来的工作就是需要提供一些类型转换函数，分别把A,Option[A],Either[String,A],Task[A]都转换成DBOResult[A]：

  def valueToDBOResult[A](a: A) : DBOResult[A] =
    Applicative[DBOResult].pure(a)
  def optionToDBOResult[A](o: Option[A]): DBOResult[A] =
    OptionT(o.pure[DBOError])
  def eitherToDBOResult[A](e: Either[String,A]): DBOResult[A] = {
    val error: DBOError[A] = EitherT.fromEither[Task](e)
    OptionT.liftF(error)
  }
  def taskToDBOResult[A](task: Task[A]): DBOResult[A] = {
    val error: DBOError[A] = EitherT.liftF[Task,String,A](task)
    OptionT.liftF(error)
  }

都是些纯纯的帮助函数，一次定义了可以永久使用。下面就是一个具体应用的例子：

object session41 extends App {
  type DBOError[A] = EitherT[Task,String,A]
  type DBOResult[A] = OptionT[DBOError,A]

  def valueToDBOResult[A](a: A) : DBOResult[A] =
    Applicative[DBOResult].pure(a)
  def optionToDBOResult[A](o: Option[A]): DBOResult[A] =
    OptionT(o.pure[DBOError])
  def eitherToDBOResult[A](e: Either[String,A]): DBOResult[A] = {
    val error: DBOError[A] = EitherT.fromEither[Task](e)
    OptionT.liftF(error)
  }
  def taskToDBOResult[A](task: Task[A]): DBOResult[A] = {
    val error: DBOError[A] = EitherT.liftF[Task,String,A](task)
    OptionT.liftF(error)
  }

  def task[T](t: T): Task[T] = Task.delay(t)
  def add(a: Int, b: Int): Task[Int] = Task.delay(a + b)

  val calc: DBOResult[Int] = for {
    a <- valueToDBOResult()
    b <- optionToDBOResult(Some())  //None: Option[Int])
    c <- eitherToDBOResult(Left[String,Int]("oh my good ..."))
    d <- taskToDBOResult(add(b,c))
  } yield d

  val sum: Task[Either[String,Option[Int]]] = calc.value.value

  import monix.execution.Scheduler.Implicits.global
  import scala.util._
  sum.runOnComplete {
    case Success(s) => println(s"DBOResult sum=$s")
    case Failure(exception) => println(exception.getMessage)
  }

}

//DBOResult sum=Left(oh my good ...)

从这段代码的运算结果可以确定：复合Monad Transformer的效果是它的组成Monad效果的叠加。在上面这个例子里我们分别可以用None,Left来中断运算，产生break一样的效果。