不同的单子用于理解

Question

我有以下代码


def processInfoAndReturnResponse(input: Input]): EitherT[Future, CustomException, A] = ???

def sendMessage(message: A): monix.eval.Task[Boolean] = ???

def anotherMethod(message: Input): Future[Either[CustomException, Unit]]= ???
def integrate(): Future[Either[GoogleException, A]] = {
(for {
  response <- processInfoAndModelResponse(input)
  _ <- EitherT.liftF[Future, CustomException, A](sendMessage(response).map(_ => response).runToFuture
}yield response).value

到目前为止一切都很好。但是现在，我想从 sendMessage 获取布尔值，然后只有当 sendMessage returns 为真时，我才想调用另一个方法。

我知道它们是不同的单子。请让我知道一种更清晰的方式，我可以如何添加所有三个调用以进行理解。感谢帮助

Answer 1

不幸的是，EitherT 和 Task 是不同的 monad，而 monad 不组合，因此您不能直接将它们用于相同的理解。

您可以将 Task 提升到 EitherT，但在这种情况下，EitherT 的类型参数 F 必须是 Task，在您的情况下是 Future。

所以你必须做两件事：

将任务转化为未来
将未来提升到 EitherT

假设您的另一种方法如下所示：

def anotherMethod(input: Integer): EitherT[Future, Exception, Unit] = EitherT.rightT[Future, Exception](())

因此您的 for-comprehension 可能如下所示：

import cats.implicits._
import scala.concurrent.ExecutionContext.Implicits._

val prog = for {
    //you need to use leftWiden adjust left of either to common type
    response <- processInfoAndReturnResponse(inp).leftWiden[Exception]
    //running task to Future and then lifting to EitherT
    i <- EitherT.liftF[Future, Exception, Integer](sendMessage(response).runToFuture)
    _ <- anotherMethod(i)
} yield ()

//prog is of type EitherT so we have to unwrap it to regular Future with rethrowT
val future: Future[Unit] = prog.rethrowT

要在编辑后回答您的问题，您可以使用 whenA 在 for-comprehension 中有条件地使用效果：

def integrate(): Future[Either[GoogleException, A]] ={
  (for {
    response <- processInfoAndModelResponse(input)
    sendStatus <- EitherT.liftF[Future, CustomException, Boolean](sendMessage(response).runToFuture)
    finalresult <- anotherMethod(input).whenA(sendStatus)
  } yield finalresult).value
}

不同的单子用于理解

Different monads in for comprehension

scala

scala-cats

monad-transformers

monix