Scala 理解 traverse、traverseU 和 traverseM

在本文中，我们将介绍 Scala 中的 traverse、traverseU 和 traverseM 这三个函数的使用和理解。

阅读更多：Scala 教程

traverse 函数

traverse 函数是 Scala 集合类中常用的一个函数，它的作用是将集合中的每个元素应用一个函数，并返回一个包含应用函数后的结果的新集合。与 map 函数不同的是，traverse 函数可以处理返回值为其他类型的函数。

在 Scala 中，traverse 函数的定义如下：

def traverse[A, B](list: List[A])(f: A => Option[B]): Option[List[B]] = list match {
  case Nil    => Some(Nil)
  case h :: t => for {
    x <- f(h)
    xs <- traverse(t)(f)
  } yield x :: xs
}

上述代码中的 f 是一个将类型 A 的元素转化为 Option[B] 类型的函数。traverse 函数首先会检查传入的集合是否为空，如果是空集合，那么直接返回一个包含空集合的 Some，否则，会首先对集合中的首个元素应用函数 f，然后递归调用 traverse 函数处理剩余的元素，并通过 yield 构造一个新的集合，最终返回一个 Some。

下面是一个简单的示例，展示了如何使用 traverse 函数将集合中的字符串转化为整型数字：

val list = List("1", "2", "3", "4", "5")
val result = traverse(list)(s => Try(s.toInt).toOption)
// 输出：Some(List(1, 2, 3, 4, 5))

在上述示例中，我们定义了一个包含字符串数字的集合 list，然后使用 traverse 函数将每个字符串转化为整型数字。由于 Try(s.toInt).toOption 可能会在转化失败时返回 None，因此我们可以确保最终得到的结果是一个 Option 类型的集合。

traverseU 函数

traverseU 函数是 traverse 函数的简化版本，它用于处理在函数应用过程中可能会抛出异常的情况。traverseU 函数会将异常包装在 Either 类型的值中，以便于后续的处理。

在 Scala 中，traverseU 函数的定义如下：

def traverseU[A, B](list: List[A])(f: A => Either[Throwable, B]): Either[Throwable, List[B]] = list match {
  case Nil    => Right(Nil)
  case h :: t => for {
    x <- f(h).right
    xs <- traverseU(t)(f).right
  } yield x :: xs
}

与 traverse 函数类似，traverseU 函数首先会检查传入的集合是否为空，如果是空集合，那么直接返回一个包含空集合的 Right，否则，会首先对集合中的首个元素应用函数 f，然后递归调用 traverseU 函数处理剩余的元素，并通过 yield 构造一个新的集合，最终返回一个 Right。

下面是一个简单的示例，展示了如何使用 traverseU 函数将集合中的字符串转化为整型数字，并处理可能的异常：

val list = List("1", "2", "3", "a", "5")
val result = traverseU(list)(s => Either.catchOnly[NumberFormatException](s.toInt))
// 输出：Left(java.lang.NumberFormatException: For input string: "a")

在上述示例中，我们定义了一个包含字符串数字和一个非数字的字符串的集合 list，然后使用 traverseU 函数将每个字符串转化为整型数字。由于有一个字符串无法转化为数字，导致引发了 NumberFormatException 异常，因此最终的结果是一个包含异常的 Left 值。

traverse## traverseM 函数

traverseM 函数是 traverse 函数的进一步扩展，可以应用于包含多层嵌套结构的集合。它使用单子（Monad）来处理嵌套结构的情况，从而更加灵活地处理集合中的元素。

在 Scala 中，traverseM 函数的定义如下：

def traverseM[F[_]: Applicative, A, B](list: List[A])(f: A => F[B]): F[List[B]] = list match {
  case Nil    => Applicative[F].pure(Nil)
  case h :: t => (f(h), traverseM(t)(f)).mapN(_ :: _)
}

在上述代码中，F[_]: Applicative 表示 F 是一个单子，并且我们需要使用 Applicative 的方法来处理这个单子。traverseM 函数首先会检查传入的集合是否为空，如果是空集合，那么直接返回一个包含空集合的单子（通过 Applicative[F].pure(Nil) 实现），否则，会首先对集合中的首个元素应用函数 f，然后递归调用 traverseM 函数处理剩余的元素，并通过 mapN 构造一个新的集合，最终返回一个新的单子。

下面是一个简单的示例，展示了如何使用 traverseM 函数将集合中的数字转化为字符串，并处理包含多层嵌套结构的结果：

import cats.implicits._
import cats.data.OptionT

val nestedList = List(Option(1), Option(2), Option(3), Option(4), Option(5))
val result = traverseM(nestedList)(n => OptionT.some(n.toString))
// 输出：Some(List("1", "2", "3", "4", "5"))

在上述示例中，我们定义了一个包含包含多层嵌套结构的数字的集合 nestedList，然后使用 traverseM 函数将每个数字转化为字符串。由于我们使用了 OptionT.some 来处理嵌套结构的情况，最终的结果是一个包含多层嵌套结构的字符串的单子。

总结

本文介绍了 Scala 中的 traverse、traverseU 和 traverseM 函数的使用和理解。traverse 函数可以将集合中的每个元素应用一个函数，并返回一个包含结果的新集合。traverseU 函数可以处理函数应用过程中可能抛出的异常。traverseM 函数进一步扩展了 traverse 函数，可以应用于包含多层嵌套结构的集合，并使用单子（Monad）来处理嵌套结构的情况。通过学习和掌握这三个函数，我们可以更加灵活地处理集合中的元素。