结合EitherT和未来

Question

我有一个对不同后端系统进行大量调用的应用程序，并希望使用for-comprehensions来简化后端系统的流程。

我希望将AoseT（scalaz）和Future（scala 2.10）结合起来，这样我就可以捕获第一个潜在的错误（这是未来或后端系统问题），并向最终用户返回适当的消息。我已经快速浏览了一个 scalaz 验证，但捕获第一个错误（并非所有错误）的建议是使用 EitherT。

我首先在REPL中尝试一个简单的示例，但是我收到以下错误

错误：找不到参数F:scalaz.Functor[scala.concurrent.Future]的隐式值

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

type EitherFuture[+A] = EitherT[Future, String, A]

def method1Success : EitherFuture[Int] = {
  println("method 1 success")
  EitherT {
    Future {
      1.right
    }
  }
}

def method2Failure : EitherFuture[Int] = {
  println("method 2 failure")
  EitherT {
    Future {
      "fail".left
    }
  }
}

val m1 = method1Success

// problem
m1.isRight

// problem
def methodChain1 = {
  for {
    a <- method1Success
    b <- method2Failure
  } yield b
}

我仍然是scala和scalaz的新手，所以任何指针都很好。

**更新**

通过包含基于@stew建议的scaraz-contrib，我现在有了一个更新版本，它显示了EitherT和Future的组合，显示了不同的简单用例后端成功、后端失败和未来失败

import scala.concurrent._
import scalaz._
import Scalaz._
import ExecutionContext.Implicits.global
import scalaz.contrib._
import scalaz.contrib.std._
import scala.concurrent.duration._

type EitherFuture[+A] = EitherT[Future, String, A]

// various methods that mimic success or different failures
def methodBackendSuccess : EitherFuture[Int] = {
  println("method backend success")
  EitherT {
    Future {1.right}
  }
}

def methodBackendFailure : EitherFuture[Int] = {
  println("method backend failure")
  EitherT {
    Future { "fail".left}
  }
}

def methodFutureFailure : EitherFuture[Int]  = {
  println("method future failure")
  EitherT {
    Future.failed(new Exception("future failed"))
  }
}

// different combinations for for-comprehensions
def methodChainBackendSuccess = {
  for {
    a <- methodBackendSuccess
    b <- methodBackendSuccess
    c <- methodBackendSuccess
  } yield c
}

def methodChainBackendFailure = {
  for {
    a <- methodBackendSuccess
    b <- methodBackendFailure
    c <- methodBackendSuccess
  } yield c
}

def methodChainFutureFailure = {
  for {
    a <- methodBackendSuccess
    b <- methodFutureFailure
    c <- methodBackendSuccess
  } yield c
}

// process results for different chain methods
def processOutcome(chainMethod: => EitherFuture[Int]):Int = try {
    val x = Await.result(chainMethod.run, 30 seconds) 
    x.toEither match {                             
      case Left(l) => {
        println("Backend failure <" + l + ">")
        -1 
      }
      case Right(r) => {
        println("Backend success <" + r + ">") 
        r
      }
    }
  } catch {
    case e: Exception => {
      println("Future error <" + e.getMessage + ">" )
      -99
  }
}

// run tests
val backendSuccess = processOutcome(methodChainBackendSuccess)
val backendFailure = processOutcome(methodChainBackendFailure)
val futureFailure = processOutcome(methodChainFutureFailure)

Answer 1

查看在以下任一项上定义的< code>isRight的签名:

def isRight(implicit F: Functor[F]): F[Boolean]

它需要一个用你的EitherT的类型参数参数化的函子，在你的例子中是Future。Scalaz没有为Future类型提供隐式函子，您需要按照这个模型编写自己的:

http://scalaz.github.io/scalaz/scalaz-2.9.0-1-6.0/doc.sxr/scalaz/Functor.scala.html

请注意每个支持类型的所有隐式def。

Answer 2

您需要导入或为 Future 提供一个 Functor 实例。我建议使用 scalaz-contrib 项目中的那个。-contrib是一个单独的项目，由在scalaz上工作的人工作。Future实例位于此包中，而不是scalaz-core，因为目前scalaz-core保持scala 2.9和2.10之间的兼容性。