scala - 在参数化类中混合通用特征而不复制类型参数

假设我想创建一个可以混合到任何 Traversable[T] 中的特征。最后，我希望能够这样说:

val m = Map("name" -> "foo") with MoreFilterOperations

并在 MoreFilterOperations 上拥有以 Traversable 必须提供的任何内容表示的方法，例如:

def filterFirstTwo(f: (T) => Boolean) = filter(f) take 2

然而，问题显然是 T 没有定义为 MoreFilterOperations 上的类型参数。一旦我这样做，它当然是可行的，但是我的代码会读到:

val m = Map("name" -> "foo") with MoreFilterOperations[(String,String)]

或者如果我定义了这种类型的变量:

var m2: Map[String,String] with MoreFilterOperations[(String,String)] = ...

这是我的口味冗长的方式。我想以这样的方式定义特征，我可以将后者写为:

var m2: Map[String,String] with MoreFilterOperations

我尝试了自我类型、抽象类型成员，但没有产生任何有用的结果。有什么线索吗？

最佳答案

Map("name" -> "foo") 是一个函数调用而不是一个构造函数，这意味着你不能写:

Map("name" -> "foo") with MoreFilterOperations

你能写的更多

val m = Map("name" -> "foo")
val m2 = m with MoreFilterOperations

要获得一个 mixin，你必须使用一个具体的类型，一个天真的第一次尝试是这样的:

def EnhMap[K,V](entries: (K,V)*) =
  new collection.immutable.HashMap[K,V] with MoreFilterOptions[(K,V)] ++ entries

在这里使用工厂方法可以避免重复类型参数。但是，这行不通，因为 ++ 方法只会返回一个普通的旧 HashMap ，而没有混合!

解决方案(如 Sam 建议的)是使用隐式转换来添加拉皮条方法。这将允许您使用所有常用技术转换 map ，并且仍然能够在生成的 map 上使用您的额外方法。我通常会使用类而不是特征来执行此操作，因为具有可用的构造函数参数会导致语法更清晰:

class MoreFilterOperations[T](t: Traversable[T]) {
  def filterFirstTwo(f: (T) => Boolean) = t filter f take 2
}

object MoreFilterOperations {
  implicit def traversableToFilterOps[T](t:Traversable[T]) =
    new MoreFilterOperations(t)
}

这允许你然后写

val m = Map("name"->"foo", "name2"->"foo2", "name3"->"foo3")
val m2 = m filterFirstTwo (_._1.startsWith("n"))

但它仍然不能很好地与集合框架配合使用。你从 Map 开始，最后是 Traversable 。这不是事情应该如何运作。这里的技巧是还使用高级类型对集合类型进行抽象

import collection.TraversableLike

class MoreFilterOperations[Repr <% TraversableLike[T,Repr], T] (xs: Repr) {
  def filterFirstTwo(f: (T) => Boolean) = xs filter f take 2
}

足够简单。您必须提供 Repr ，代表集合的类型，以及 T ，元素的类型。我使用 TraversableLike 而不是 Traversable 因为它嵌入了它的表示；没有这个，无论起始类型如何，filterFirstTwo 都会返回一个 Traversable。

现在是隐式转换。这是类型符号中事情变得有点棘手的地方。首先，我使用了一个更高级的类型来捕获集合的表示: CC[X] <: Traversable[X] ，这参数化了 CC 类型，它必须是 Traversable 的子类(注意这里使用 X 作为占位符，CC[_] <: Traversable[_] 并不意味着一样)。

还有一个隐式 CC[T] <:< TraversableLike[T,CC[T]] ，编译器使用它来静态保证我们的集合 CC[T] 确实是 TraversableLike 的子类，因此是 MoreFilterOperations 构造函数的有效参数:

object MoreFilterOperations {
  implicit def traversableToFilterOps[CC[X] <: Traversable[X], T]
  (xs: CC[T])(implicit witness: CC[T] <:< TraversableLike[T,CC[T]]) =
    new MoreFilterOperations[CC[T], T](xs)
}

到现在为止还挺好。但是仍然存在一个问题......它不适用于 map ，因为它们采用两个类型参数。解决方法是在 MoreFilterOperations 对象中添加另一个隐式，使用与之前相同的原则:

implicit def mapToFilterOps[CC[KX,VX] <: Map[KX,VX], K, V]
(xs: CC[K,V])(implicit witness: CC[K,V] <:< TraversableLike[(K,V),CC[K,V]]) =
  new MoreFilterOperations[CC[K,V],(K,V)](xs)

当您还想处理实际上不是集合但可以被视为好像它们是集合的类型时，真正的美妙就出现了。还记得 Repr <% TraversableLike 构造函数中的 MoreFilterOperations 吗？这是一个 View 边界，并允许可以隐式转换为 TraversableLike 的类型以及直接子类。字符串就是一个典型的例子:

implicit def stringToFilterOps
(xs: String)(implicit witness: String <%< TraversableLike[Char,String])
: MoreFilterOperations[String, Char] =
  new MoreFilterOperations[String, Char](xs)

如果你现在在 REPL 上运行它:

val m = Map("name"->"foo", "name2"->"foo2", "name3"->"foo3")
//  m: scala.collection.immutable.Map[java.lang.String,java.lang.String] =
//    Map((name,foo), (name2,foo2), (name3,foo3))

val m2 = m filterFirstTwo (_._1.startsWith("n"))
//  m2: scala.collection.immutable.Map[java.lang.String,java.lang.String] =
//    Map((name,foo), (name2,foo2))

"qaxfwcyebovjnbointofm" filterFirstTwo (_ < 'g')
//res5: String = af

Map进去，Map出来。字符串进去，字符串出来。等等...

我还没有尝试过使用 Stream 、 Set 或 Vector ，但您可以确信，如果您这样做了，它将返回与您开始时相同类型的集合。

关于scala - 在参数化类中混合通用特征而不复制类型参数，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/5026055/