Scala 如何创建一个接受任何Seq[T，Int]并返回原始Seq类型的函数。

我很难定义这个问题。我想这样做：

val list = List(("a",1), ("b",2))

private def shiftIndex[C <: Seq[_]](seq: C, amount: Int): C = {
  seq.map({ case (value, integer) => (value, integer + amount) })
}

shiftIndex(list,3) 

但它应该适用于最普遍的情况：

seq实现map（我知道它不是：seq）

seq存储的是任何内容的元组和一个Int

如有任何与资源的链接可以解释这些概念，我们将不胜感激

import scala.collection.generic.CanBuildFrom
import scala.collection.GenTraversable
import scala.collection.GenTraversableLike

def shiftIndex[T, Repr](seq: GenTraversableLike[(T, Int), Repr], amount: Int)(
    implicit bf: CanBuildFrom[Repr, (T, Int), Repr]) = {
  seq.map { case (value, integer) => (value, integer + amount) }
}

shiftIndex(List(("a", 1), ("b", 2)), 3)     // List((a,4), (b,5))
shiftIndex(Set(("a", 1), ("b", 2)), 3)      // Set((a,4), (b,5))
shiftIndex(Map(("a", 1), ("b", 2)), 3)      // Map(a -> 4, b -> 5)

尽管我可能会推荐一种外观更好、更通用的解决方案。在这里，我丰富了GenTraversable，使成对的所有可遍历对象都有一个方法

mapVals

，该方法将函数应用于成对的第二部分，并且返回类型与它所运行的对象相同：

class EnrichedWithMapVals[T, U, Repr](seq: GenTraversableLike[(T, U), Repr]) {
  def mapVals[R, That](f: U => R)(implicit bf: CanBuildFrom[Repr, (T, R), That]) = {
    seq.map { case (x, y) => (x, f(y)) }
  }
}
implicit def enrichWithMapVals[T, U, Repr](self: GenTraversableLike[(T, U), Repr]) = new EnrichedWithMapVals(self)

List(("a", 1), ("b", 2)).mapVals(_ + 3)     // List((a,4), (b,5))
Set(("a", 1), ("b", 2)).mapVals(_ + 3)      // Set((a,4), (b,5))
Map(("a", 1), ("b", 2)).mapVals(_ + 3)      // Map(a -> 4, b -> 5)

使用中解释的方法（或更简单的

CanBuildFrom

变体，如果您的问题允许，也可以使用）。

class EnrichedWithMapVals[T, U, Repr](seq: GenTraversableLike[(T, U), Repr]) {
  def mapVals[R, That](f: U => R)(implicit bf: CanBuildFrom[Repr, (T, R), That]) = {
    seq.map { case (x, y) => (x, f(y)) }
  }
}
implicit def enrichWithMapVals[T, U, Repr](self: GenTraversableLike[(T, U), Repr]) = new EnrichedWithMapVals(self)

List(("a", 1), ("b", 2)).mapVals(_ + 3)     // List((a,4), (b,5))
Set(("a", 1), ("b", 2)).mapVals(_ + 3)      // Set((a,4), (b,5))
Map(("a", 1), ("b", 2)).mapVals(_ + 3)      // Map(a -> 4, b -> 5)