如何从几个未来[\ / [Throwable，T]]获得未来[\ / [Throwable，T]]

Question

Assuming I have several methods to return \\/[Throwable, String] . The right value Int is what I want and the left value accumulates errors.

import scalaz._
import Scalaz._
type ErrorOr[T] = \/[Throwable, T]

def init(a: Int): ErrorOr[Int] = a.right
def add(a: Int, b: Int): ErrorOr[Int] = (a + b).right
def multiply(a: Int, b: Int): ErrorOr[Int] = (a * b).right

init(3).flatMap(add(_, 4)).flatMap(multiply(_, 3)) // 21

It looks good, because scalaz either's flatmap is right biased, so it will operate based on the right value.

However, if method is going to change for the API call, so the return type would be Future[ErrorOr[T]] . Is there any way I can use to return Future[ErrorOr[T]] ? Also, I probably want to use future.flatMap as a callback instead of using await here to block

def init(a: Int): Future[ErrorOr[Int]] = Future(a.right)
def add(a: Int, b: Int): Future[ErrorOr[Int]] = Future((a + b).right)
def multiply(a: Int, b: Int): Future[ErrorOr[Int]] = Future((a * b).right)

Answer 1

您可以将init的结果包装在EitherT monad转换器中，使用flatMapF而不是flatMap来直接使用add和multiply ，就像现在一样，然后调用run来获取Future[ErrorOr[Int]] ：

EitherT(init(3)).flatMapF(add(_, 4)).flatMapF(multiply(_, 3)).run

Answer 2

You might consider using scalaz.concurrent.Task :

def init(a: Int): Task[Int] = Task.now(a)
def add(a: Int, b: Int): Task[Int] = Task.now(a + b)
def multiply(a: Int, b: Int): Task[Int] = Task.now(a * b)

So:

scala> val res = init(3).flatMap(add(_, 4)).flatMap(multiply(_, 3))
res: scalaz.concurrent.Task[Int] = scalaz.concurrent.Task@3fdb3076

Can be easily converted to:

scala> res.get
res1: scalaz.concurrent.Future[scalaz.\/[Throwable,Int]] = ...

scala> res.get.run
res5: scalaz.\/[Throwable,Int] = \/-(21)

If you need to fail:

scala> def add(a: Int, b: Int): Task[Int] = Task.fail(new RuntimeException("fail"))
add: (a: Int, b: Int)scalaz.concurrent.Task[Int]

scala> init(3).flatMap(add(_, 4)).flatMap(multiply(_, 3)).get.run
res4: scalaz.\/[Throwable,Int] = -\/(java.lang.RuntimeException: fail)

Please note, that the Future here is scalaz.concurrent.Future

Update

If you need to pass Either to the Task - you can use this:

import Task._

implicit class FutureToTask[T](f: Future[\/[Throwable, T]]){
   def task = async(f.runAsync)
}