如何创建具有特定类型的 List 的包装器

Question

我正在尝试创建具有特定类型（例如 List[Int]）的 List 包装器，以便采用隐式 CanBuildFrom 参数的方法返回我的包装器的实例而不是 List。

一种可能的解决方案（感觉相当重量级）是：

import scala.collection._
import generic.{CanBuildFrom, SeqForwarder}
import mutable.{Builder, ListBuffer}

class MyList(list: List[Int]) extends immutable.LinearSeq[Int]
                                 with LinearSeqLike[Int, MyList]
                                 with SeqForwarder[Int] {
  override def newBuilder: Builder[Int, MyList] = MyList.newBuilder
  protected override def underlying = list
}

object MyList {
  def newBuilder: Builder[Int, MyList] =
    new ListBuffer[Int] mapResult(new MyList(_))

  implicit def canBuildFrom: CanBuildFrom[MyList, Int, MyList] = {
    new CanBuildFrom[MyList, Int, MyList] {
      def apply(from: MyList) = from.newBuilder
      def apply() = newBuilder
    }
  }
}

val l1 = new MyList(List(1,2,3))

println(l1.isInstanceOf[MyList])
println(l1.map(_ + 1).isInstanceOf[MyList])
println(l1.filter(_ == 2).isInstanceOf[MyList])

是否有更好/更简单的方法来创建这样的包装器，或者我是否错过了 MyList 实现中的任何重要内容？

编辑：后续问题是：是否可以将整个包装器逻辑放入 ListWrapper 类或特征中，以便可以实现上述 MyList像这样：

class MyList extends ListWrapper[Int, MyList]

object MyList extends ListWrapperFactory[Int, MyList]

Answer 1

据我阅读这篇文章所知：

http:// /www.scala-lang.org/docu/files/collections-api/collections-impl.html

如果您想要过滤器/地图/等，您的解决方案是最简单的。到 MyList 的所有返回实例。 filter 等操作需要 newBuilder，而 map 等操作需要隐式 CanBuildFrom，这可能会更改集合类型。

您在 CanBuildFrom 中应该做的是：

def apply(from: MyList) = from.newBuilder // call it on `from'

确保静态类型 MyList 上的 map 实际上具有动态类型是 MyList 的子类型将重用相同的动态类型。

编辑：似乎缺少一些东西，因为此 map 返回 List 的实例，而不是 MyList ：

val l1: LinearSeq[Int] = new MyList(List(1, 2, 3))
println(l1.map(_ + 1)) // prints List(2, 3, 4)

看起来链接文章中的 RNA 示例也是如此。如果它具有静态类型 IndexedSeq[Base] 而不是 RNA，则其上的 map 返回一个向量。

编辑2：看起来这是一个更普遍的问题，在这个问题中讨论。

Answer 2

关于我的后续问题如何通过类或特征混合包装器逻辑，这就是我想到的：

import scala.collection._

trait ListWrapper[Elem, Repr <: ListWrapper[Elem, Repr]]
    extends immutable.LinearSeq[Elem]
    with LinearSeqLike[Elem, Repr]
    with generic.SeqForwarder[Elem] { self: Repr =>

  def wrapperCompanion: ListWrapperCompanion[Elem, Repr]

  override def newBuilder: mutable.Builder[Elem, Repr] =
    wrapperCompanion.newBuilder
}

trait ListWrapperCompanion[Elem, Repr <: ListWrapper[Elem, Repr]] {
  def apply(elems: TraversableOnce[Elem]): Repr

  def newBuilder: mutable.Builder[Elem, Repr] =
    new mutable.ListBuffer[Elem].mapResult(apply)

  def canBuildFromWrapper: generic.CanBuildFrom[Repr, Elem, Repr] = {
    new generic.CanBuildFrom[Repr, Elem, Repr] {
      def apply(from: Repr) = from.newBuilder
      def apply() = newBuilder
    }
  }
}

现在 MyList 可以通过以下方式实现：

class MyList(val underlying: List[Int]) extends ListWrapper[Int, MyList] {
  def wrapperCompanion = MyList
}

object MyList extends ListWrapperCompanion[Int, MyList] {
  def apply(elems: TraversableOnce[Int]) = new MyList(elems.toList)

  implicit def canBuildFrom = canBuildFromWrapper
}

这绝对比将所有样板代码放在其中要好MyList 的定义，但是要使 MyList 成为 List 的包装器，仍然需要编写很多代码。