Try组合:List[Try[T]]toTry[List[T]] inScala-边看边学

我想知道如何在 Scala 中将List[Try[T]]转换为Try[List[T]]？

我试过使用累加器和折叠的权利，但它似乎并不理想。

使用猫很容易：

import cats._
import cats.data._
import cats.implicits._
import scala.util.{Try, Success, Failure}
val tries: List[Try[Int]] = List(Success(1), Success(2), Success(3))
tries.sequence

更多信息请参见Traverse docs。

Try(list.map(_.get))

这将只返回第一个失败，所以如果你想捕获列表中的所有失败，你需要更复杂的东西。

我也建议只使用猫...

但是，如果您不想在项目中添加另一个（big）依赖项，则只需一个函数。
您可以自己实现它！-（cats 实现可能更好）

import scala.util.{Try, Success, Failure}
def sequence[A](list: List[Try[A]]): Try[List[A]] = {
  @annotation.tailrec
  def loop(remaining: List[Try[A]], acc: List[A]): Try[List[A]] =
    remaining match {
      case Nil                => Success(acc.reverse)
      case Success(a) :: tail => loop(remaining = tail, acc = a :: acc)
      case Failure(e) :: _    => Failure(e)
    }
  loop(remaining = list, acc = List.empty)
}

此外，如果您之前使用了map，则可以使用traverse而不是sequence。

def traverse[A, B](list: List[A])(f: A => Try[B]): Try[List[B]] = {
  @annotation.tailrec
  def loop(remaining: List[A], acc: List[B]): Try[List[B]] =
    remaining match {
      case Nil          => Success(acc.reverse)
      case head :: tail => f(head) match {
        case Success(b) => loop(remaining = tail, acc = b :: acc)
        case Failure(e) => Failure(e)
      }
    }
  loop(remaining = list, acc = List.empty)
}

无论如何，猫（和一般的 FP）是非常有用的（正如您刚刚看到的）。
因此，我建议您尝试一下。

猫是一个很好的方式去，但它可以通过标准库没有太多的复杂性。

import util.{Try, Success, Failure}
def seqnc[T](lst :List[Try[T]]) :Try[List[T]] =
  lst.foldRight(Try(List.empty[T])) {
    case (tt, acc) => for { t <- tt
                            a <- acc
                          } yield t :: a
  }

本站系公益性非盈利分享网址，本文来自用户投稿，不代表边看边学立场，如若转载，请注明出处