Scala 计算每个元素上的函数的最佳方法是对这些集合中的元素进行增量阴影

计算集合中每个元素上的函数并对每个元素进行增量阴影的最佳方法是什么，如以下简单示例所示：

val v = IndexedSeq(1,2,3,4)

v.shadowMap{ e => e + 1}

shadow 1: (3,4,5)
shadow 2: (2,4,5)
shadow 3: (2,3,5)
shadow 4: (2,3,4)

我认为首先要做的是

补丁

或

切片

，但也许有一种更好的方法可以用纯功能风格来做这件事

谢谢

---

Sr.

您可以这样定义它：

class ShadowMapSeq[A, Repr <: Seq[A]](seq: SeqLike[A, Repr]) {
  def shadowMap[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): Iterator[That] = {
    seq.indices.iterator.map { i =>
      val b = bf(seq.asInstanceOf[Repr])
      b.sizeHint(seq.size - 1)
      b ++= (seq.take(i) ++ seq.drop(i + 1)).map(f)
      b.result
    }
  }
}
implicit def shadowMapSeq[A, Repr <: Seq[A]](seq: SeqLike[A, Repr]) = new ShadowMapSeq(seq)

scala> val v = IndexedSeq(1, 2, 3, 4)
scala> val results = v.shadowMap(_ + 1)
scala> results foreach println
Vector(3, 4, 5)
Vector(2, 4, 5)
Vector(2, 3, 5)
Vector(2, 3, 4)

如果“纯功能风格”的意思是“不参考索引”（因为你说你想避免

patch

和

slice

），你可以很优雅地使用它。例如，以下是如何编写它（这只是一个演示，如果您想更完美地总结它，您可以使用dhg在其答案中给出的方法）：

一般来说，您最好使用dhg的真实代码解决方案，但拉链是一种方便的数据结构，非常适合解决此问题。

def shadowMap[a，B]（xs:Seq[a]）（f:a=>B）={
def shadowMap[A,B](xs: Seq[A])(f: A => B) = {
  val ys = xs map f
  for (i <- ys.indices; (as, bs) = ys splitAt i) yield as ++ bs.tail
}

val ys=xs映射f
（i）有关：
def shadowMap[A,B](xs: Seq[A])(f: A => B) = {
  val ys = xs map f
  for (i <- ys.indices; (as, bs) = ys splitAt i) yield as ++ bs.tail
}