Question

我正在尝试编写下面的验证函数，以便在遇到第一个错误后停止验证。 three的返回类型与其他函数不同。我使用哪个monad变换器来编译这段代码？

import scalaz._
import Scalaz._
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global


def one(a : String): Disjunction[Int, String] =
  a == "one" match {
    case true => \/-("one")
    case false => -\/(2)
  }

def two(a : String): Disjunction[Int, String] =
  a == "two" match {
    case true => \/-("two")
    case false => -\/(3)
  }

def three(a : String): Future[Disjunction[Int, String]] =
  Future (a == "three") map {
    case true => \/-("three")
    case false => -\/(4)
  }

def validate(a : String) = for {
  e1 <- one(a)
  e2 <- two(a)
  e3 <- EitherT(three(a))
} yield (e1 |+| e2 |+| e3)

编译错误：

Error:(27, 7) type mismatch;
 found   : scalaz.EitherT[scala.concurrent.Future,Int,String]
 required: scalaz.\/[?,?]
  e3 <- EitherT(three(a))
     ^
Error:(66, 7) type mismatch;
 found   : scalaz.EitherT[scala.concurrent.Future,Int,String]
 required: scalaz.\/[?,?]
  e3 <- EitherT(three(a))
     ^

Answer 1

在这种情况下，您可以采取两种通用方法。第一个是让你的所有方法返回你知道你将要使用的堆栈（在这种情况下是EitherT[Future, Int, ?]），或者你可以让每个单独的方法返回最准确地捕获它自己的效果的类型，然后在撰写时提高你得到的值。

如果您确切知道该用法的用途，第一种方法可以使语法在语法上更方便，但后一种方法更灵活，在我看来通常是更好的选择。在你的情况下，它看起来像这样：

import scalaz._, Scalaz._
import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

def one(a: String): Disjunction[Int, String] = (a == "one").either("one").or(2)
def two(a: String): Disjunction[Int, String] = (a == "two").either("two").or(3)

def three(a: String): EitherT[Future, Int, String] = EitherT(
  Future(a == "three").map(_.either("three").or(4))
)

def validate(a: String) = for {
  e1 <- EitherT.fromDisjunction[Future](one(a))
  e2 <- EitherT.fromDisjunction[Future](two(a))
  e3 <- three(a)
} yield (e1 |+| e2 |+| e3)

然后：

scala> validate("one").run.foreach(println)
-\/(3)

scala> validate("x").run.foreach(println)
-\/(2)

如果出于某种原因，您想要在Future - 理解中使用普通的for，则可以使用EitherT[Future, String, A]将其提升到.liftM[EitherT[?[_], String, ?]]。

（请注意，此方法可能不是非常有用，因为它永远不会成功（字符串不能等于"one"，"two"和{ {1}}同时），但至少组成成功。）

关于如何更普遍地选择monad变换器堆栈：您只需将类型内部转出，以便"three"变为Future[Disjunction[Int, ?]]等。在这种情况下，EitherT[Future, Int, ?]不会有一个monad变换器（它不可穿越而且无法阻塞地实现Future），所以你知道它必须在内部进行。无论如何。

Answer 2

没有什么可以添加到Travis＆＃39;回答（像往常一样），但是如果您在Play中使用它！应用程序，也许https://github.com/Kanaka-io/play-monadic-actions可以提供一些帮助。

使用哪种Monad变压器？

2 个答案: