Scala 通过使用自己的方法扩展TraversableLike来丰富我的库

我试图用自己的方法扩展TraversableLike，但失败了

首先，看看我想要实现什么：

class RichList[A](steps: List[A]) {
  def step(f: (A, A) => A): List[A] = {
    def loop(ret: List[A], steps: List[A]): List[A] = steps match {
      case _ :: Nil => ret.reverse.tail
      case _ => loop(f(steps.tail.head, steps.head) :: ret, steps.tail)
    }
    loop(List(steps.head), steps)
  }
}
implicit def listToRichList[A](l: List[A]) = new RichList(l)

val f = (n: Int) => n * (2*n - 1)
val fs = (1 to 10) map f
fs.toList step (_ - _)

这段代码运行良好，它计算列表元素之间的差异。但是我想要这样一个代码，它可以与

Seq

，

Set

等一起工作，而不仅仅是与

List

一起工作

我试过这个：

class RichT[A, CC[X] <: TraversableLike[X, CC[X]]](steps: CC[A]) {
  def step(f: (A, A) => A): CC[A] = {
    def loop(ret: CC[A], steps: CC[A]): CC[A] =
      if (steps.size > 1) loop(ret ++ f(steps.tail.head, steps.head), steps.tail)
      else ret.tail
    loop(CC(steps.head), steps)
  }
}
implicit def tToRichT[A, CC[X] <: TraversableLike[X, CC[X]]](t: CC[A]) = new RichT(t)

class RichT[A，CC[X]A:CC[A]={
def循环（ret:CC[A]，步骤：CC[A]）：CC[A]=
if（steps.size>1）循环（ret++f（steps.tail.head，steps.head），steps.tail）
要不然就退尾
循环（CC（steps.head），steps）
}
}
基于Rex的评论，我编写了以下代码：

class RichIter[A, C[A] <: Iterable[A]](ca: C[A]) {
  import scala.collection.generic.CanBuildFrom
  def step(f: (A, A) => A)(implicit cbfc: CanBuildFrom[C[A], A, C[A]]): C[A] = {
    val iter = ca.iterator
    val as = cbfc()

    if (iter.hasNext) {
      var olda = iter.next
      as += olda
      while (iter.hasNext) {
        val a = iter.next
        as += f(a, olda)
        olda = a
      }
    }
    as.result
  }
}
implicit def iterToRichIter[A, C[A] <: Iterable[A]](ca: C[A]) = new RichIter[A, C](ca)

val f = (n: Int) => n * (2*n - 1)
val fs = (1 to 10) map f
fs step (_ - _)

class-RichIter[A，C[A]A（隐式cbfc:CanBuildFrom[C[A]，A，C[A]]）：C[A]={
val iter=ca.iterator
val as=cbfc（）
if（iter.hasNext）{
var olda=iter.next
as+=olda
while（iter.hasNext）{
val a=iter.next
as+=f（a，olda）
奥尔达=a
}
}
结果
}
}
隐式def iterToRichIter[A，C[A]n*（2*n-1）
val fs=（1到10）映射f
fs步骤（-41;

这与预期的效果一样。
我认为这个问题是非常有用答案的可能重复。我可以剪切粘贴并添加适合的方法，稍后再了解更详细的细节。