基于原点的约束函数（路径依赖类型？类型生成？）

抱歉，标题太糟糕了，不确定有更好的标题。这是我的问题的总体简化（抱歉，如果它看起来如此微不足道，那么它毫无意义）：

class RList[T](data: List[T]) {
   def map[V](f: T=>V): RList[V] = ...
}

的想法RList（受限列表）的缺点是您无法调整其大小，或更改其中元素的顺序。但是您可以使用函数为您提供一个新的 RList，其中包含更改的数据。

现在需要一个创建 RList 的函数。它可能有签名某物 like:

def toRList[T](values: List[T]): RList[T] = ...

到目前为止，一切都很好。但现在是棘手的部分。我需要一个有效的功能like this:

def zip[T, V](left: RList[T], right: RList[V]): RList[(T,V)]

但还有一个额外的限制left and right具有相同的起源。因此，保证它们的大小相同。

例如应该编译的代码：

val x = toRList(List(1, 2, 3))
val y = x.map(_ * 2)
val z = y.map(_.toString)
zip(y,z)

例如应该失败的代码编译

val y = toRList(List(2, 4, 6))
val z = toRList(List("one", "two"))
zip(y,z)

*注意：在我最初的问题中，对 zip 的约束必须是它们来自同一“源”。仅仅保证它们的长度相同是不够的（更不用说，列表的大小在编译时未知）*

我还需要能够使用zip多次，所以这样的东西应该编译

zip(a,zip(b,c))

（假设a, b and c均来自同一来源）

Thanks!

制作的缺点之一RList生产者的一个内在特征是用以下方式编写方法或函数变得不太令人愉快RList生产者外部的争论——你最终会得到很多这样的结果：

def foo[P <: RListProducer, T](rl: P#RList[T]) = ???

另一种选择是给予RList对于每个“源”来说都是唯一的类型成员RList，但每个来源都会传递给它的“孩子”。像这样的东西：

trait RList[T] { outer =>
  type S
  protected val wrapped: List[T]

  def map[V](f: T => V) = new RList[V] {
    type S = outer.S
    protected val wrapped = outer.wrapped.map(f)
  }

  def zip[V](r: RList[V] { type S = outer.S }) = new RList[(T, V)] {
    type S = outer.S
    protected val wrapped = outer.wrapped.zip(r.wrapped)
  }
}

object RList {
  def toRList[T](ts: List[T]) = new RList[T] {
    type S = this.type
    protected val wrapped = ts
  }
}

现在假设我们有以下内容：

val a = RList.toRList(1 :: 2 :: 3 :: Nil)
val b = a.map(_.toString)
val c = RList.toRList("1" :: "2" :: "3" :: Nil)

Now a zip b (or a zip b zip a zip a等）将编译，但如果你抛出一个c你会得到一个编译器错误。

Note:我最初写的是zip如下：

def zip[V](r: RList[V])(implicit ev: r.S =:= S) = new RList[(T, V)] { ... }

这给出了一个稍微好一点的编译器错误消息，但如果您在 2.10 之前工作，则需要使用以下命令打开依赖方法类型-Ydependent-method-types.