Monad transformers-Scalaz-List[Future[String\/String]]到Future[String\/String]

我想知道如何将

列表[Future[String\/String]

转换为

未来[String\/String]

事实上，我只想应用列表中的每个元素

EitherT.apply

我想要的是这样的：

val result: EitherT[Future, String, String] =
    for{
        _                     <- EitherT.apply(fun(arg1))
        _                     <- EitherT.apply(fun(arg2))
        res                   <- EitherT.apply(fun(arg3))
    } yield res
result.run

// ...

def fun(arg1: MyType): Future[String\/String] = ...

val结果：EitherT[未来，字符串，字符串]=
为了{
_我找到了一种不用EitherT.apply的方法

def seqCheck(elements: List[Element]): Future[String\/String] = elements match {
    case element :: tail  =>
        fun(element) flatMap {
            case \/-(_) =>
                seqCheck(tail)
            case -\/(e) => Future{
                -\/(e)
            }
        }
    case Nil                =>
        Future {
            \/-("Ok")
        }
}

它不像我希望的那么好，但似乎很管用。
如果有人知道最好的方法…
我已经找到了一种方法，但不使用EitherT.apply

def seqCheck(elements: List[Element]): Future[String\/String] = elements match {
    case element :: tail  =>
        fun(element) flatMap {
            case \/-(_) =>
                seqCheck(tail)
            case -\/(e) => Future{
                -\/(e)
            }
        }
    case Nil                =>
        Future {
            \/-("Ok")
        }
}

它不像我希望的那么好，但似乎很管用。
如果有人知道一个最好的方法…
可以做到。我想你忘记了输出类型中的一些东西-你输入了一个
列表
，但你只得到一个元素？谢谢！@GáborBakos Future.sequence很好，但是性能如何？@lmm事实上我只想一个接一个地检查每个元素的
乐趣的结果如果有一个返回左边（失败），则返回这个，否则返回\/-（“确定”）.我已经找到了一种方法。看看我的答案。我能做到。我想你忘记了输出类型中的一些东西-你输入了一个
列表
，但你只得到了一个元素？谢谢！@GáborBakos Future.sequence很好，但是性能呢？@lmm事实上我只想一个接一个地检查
乐趣的结果列表的每个元素。如果有一个返回左（失败），则返回此元素，否则返回\/-（“确定”）.我已经找到了一种方法。看看我的答案。我能做到。我想你忘记了输出类型中的一些东西-你输入了一个
列表
，但你只得到了一个元素？谢谢！@GáborBakos Future.sequence很好，但是性能呢？@lmm事实上我只想一个接一个地检查
乐趣的结果列表中的每一个元素。如果有一个返回左（失败），则返回此元素，否则返回\/-（“确定”）。我找到了一种方法。请参阅我的答案。