Scala：具有不同上下文和依赖关系的ReaderT组合

Question

返回不同ReaderT的s3f1和s3f2函数的示例：

type FailFast[A] = Either[List[String], A]
trait Service1 { def s1f:Option[Int] = Some(10) }
trait Service2 { def s2f:FailFast[Int] = Right(20) }

import cats.instances.option._

def s3f1: ReaderT[Option, Service1, Int] =
  for {
    r1 <- ReaderT((_: Service1).s1f)
  } yield r1 + 1

import cats.syntax.applicative._
import cats.instances.either._

type ReaderService2FF[A] = ReaderT[FailFast, Service2, A]

def s3f2: ReaderService2FF[Int] =
  for {
    r1 <- ReaderT((_: Service2).s2f)
    r2 <- 2.pure[ReaderService2FF]
  } yield r1 + r2

我尝试编写这两个函数，返回具有不同F[_]上下文和依赖关系的读者：ReaderT[Option, Service1, Int]和ReaderT[FailFast, Service2, Int]

我必须以某种方式结合F[_]上下文，这意味着将FailFast与Option结合起来。我认为，将它与FailFast[Option]结合起来是有意义的：

type Env = (Service1, Service2)
type FFOption[A] = FailFast[Option[A]]
type ReaderEnvFF[A] = ReaderT[FFOption, Env, A]

如何撰写s3f1和s3f2：

def c: ReaderEnvFF[Int] =
  for {
    r1 <- //s3f1
    r2 <- //s3f2
  } yield r1 + r2

Answer 1

既然你试图在FailFast中组成monad Option和FFOption，你应该再使用一个monad变换器，所以FFOption[A]应该是OptionT[FailFast, A]而不仅仅是FailFast[Option[A]]。

import cats.instances.option._
import cats.instances.either._
import cats.syntax.applicative._
import cats.syntax.either._
import cats.syntax.option._

type Env = (Service1, Service2)
type FFOption[A] = OptionT[FailFast, A]
type ReaderEnvFF[A] = ReaderT[FFOption, Env, A]

def c: ReaderEnvFF[Int] =
  for {
    r1 <- ReaderT[FFOption, Env, Int](p => OptionT(Either.right(s3f1.run(p._1))))     
    r2 <- ReaderT[FFOption, Env, Int](p => OptionT(s3f2.run(p._2).map(_.some)))                          
  } yield r1 + r2

这可以用local和mapF重写：

def c: ReaderEnvFF[Int] =
  for {
    r1 <- s3f1.local[Env](_._1).mapF[FFOption, Int](opt => OptionT(opt.asRight))
    r2 <- s3f2.local[Env](_._2).mapF[FFOption, Int](ff => OptionT(ff.map(_.some)))                      
  } yield r1 + r2