在 scala 中对集合进行操作的通用函数

Question

这似乎是一个简单的问题，我以前肯定有人问过，但找不到我要找的东西。

如何编写一个将集合作为参数（或任何可被视为集合）的函数，对其执行一些操作，并返回相同类型的集合？

例如：

scala> def foo[Repr <% Traversable[String]](repr: Repr) = repr.map(_.size)
foo: [Repr](repr: Repr)(implicit evidence$1: Repr => Traversable[String])Traversable[Int]

这适用于某些收藏：

scala> foo(Vector("Hello","World"))
res0: Traversable[Int] = Vector(5, 5)

但当我尝试其他收藏时令人惊讶（例如Option）：

scala> foo(Some("HelloWorld"))
res1: Traversable[Int] = List(10)

一个小问题是返回类型Traversable，理想情况下它应该是给方法的任何类型。更大的问题是实际的实现类型：Option 变成了List。 当在类（行为类似于集合）上尝试但没有隐含的范围时，情况会变得更糟。例如：Try:

scala> import scala.util._
import scala.util._

scala> foo(Success("HelloWorld"))
<console>:12: error: No implicit view available from scala.util.Success[String] => Traversable[String].
              foo(Success("HelloWorld"))
                 ^

那么，有没有办法编写一个通用函数，当给定一个“类似集合”的参数时，可以对其元素进行操作并返回正确的类型？

理想情况下，我想在任何东西上使用它（甚至是 Future 和 Try），但对于我的特定用途，我可以只使用真正的集合和 Option。

编辑：

为了说明一个可能的解决方案，（这迫使我复制和粘贴代码，因此，这不是我想要的）是简单地编写两个没有视图边界的函数：

scala> :paste
// Entering paste mode (ctrl-D to finish)

def foo[Repr <: Traversable[String]](repr: Repr) = repr.map(_.size)
def foo(repr: Option[String]) = repr.map(_.size)

// Exiting paste mode, now interpreting.

foo: [Repr <: Traversable[String]](repr: Repr)Traversable[Int] <and> (repr: Option[String])Option[Int]
foo: [Repr <: Traversable[String]](repr: Repr)Traversable[Int] <and> (repr: Option[String])Option[Int]

scala> foo(Vector("bar"))
res2: Traversable[Int] = Vector(3)

scala> foo(Some("bar"))
res3: Option[Int] = Some(3)

Answer 1

我确实认为 Kolmar 对一般问题的看法是正确的，但 Scala 确实支持鸭式打字，所以你可以这样做：

def foo[T[V]](duck: {def map[U](value: String=>U): T[_]}) ={
   duck.map(_.size)
}

foo(Vector("bar")).toVector                         //> res0: Vector[_$2] = List(3)
foo(Some("bar"))                                  //> res1: Option[_$2] = Some(3)

（toVector 只是为了强制迭代器的 eval 否则会导致）

Answer 2

映射的概念由函子表示。为通用类轻松提供函子实现的一种方法是使用 scalaz 库：

import scala.language.higherKinds
import scalaz.Functor
import scalaz.Scalaz._

def foo[El <: String, Coll[_]](repr: Coll[El])(implicit ev: Functor[Coll]) =
    repr.map(_.size)

现在，这仅适用于 List、Vector 和 Future：

scala> foo(Vector("Hello","World"))
res1: scala.collection.immutable.Vector[Int] = Vector(5, 5)

scala> foo(List("Hello","World"))
res2: List[Int] = List(5, 5)

scala> import scala.concurrent.Future
scala> import scala.concurrent.ExecutionContext.Implicits.global
scala> foo(Future("HelloWorld")) andThen PartialFunction(println(_))

Success(10)

将它与Some 一起使用有点问题，因为只有Option 有Functor 实现，而不是Some：

scala> foo(Some("HelloWorld"))
<console>:12: error: could not find implicit value for parameter ev: scalaz.Functor[Some]
              foo(Some("HelloWorld"))
                 ^

所以你必须提供Option 而不是Some 给foo：

scala> foo(Some("HelloWorld"): Option[String])
res3: Option[Int] = Some(10)

scala> foo(Option("HelloWorld"))
res4: Option[Int] = Some(10)

scala> foo("HelloWorld".some) // This is from scalaz
res5: Option[Int] = Some(10)

而且 scalaz 没有任何 Try 的类型类实现，所以如果你想将 Functor 与 Try 一起使用，你必须自己提供实现：

import scala.util.Try
import scalaz.Functor

implicit object TryIsFunctor extends Functor[Try] {
  def map[A, B](fa: Try[A])(f: A => B): Try[B] = fa map f
}

那么foo 将与Try 一起使用，但类似于Option，参数的类型应为Try，而不是Success 或Failure：

scala> foo(Try("HelloWorld"))
res9: scala.util.Try[Int] = Success(10)

另外，我相信 scalaz 中没有用于更通用集合类型的 Functor 实现，例如 Iterable 或 Seq。

除了常见的高阶函数Functor 仅支持map。所以要使用flatMap 和filter，你必须提供不同的类型类而不是Functor。比如scalaz.Monad支持map和flatMap，scalaz.MonadPlus支持map、flatMap和filter。

如果你不想使用 scalaz，你可能不得不自己用类型类做一些非常相似的东西，以获得一个好的结果类型而不是 Traversable。例如，使用标准库中的CanBuildFrom。