Scala中zip/zipWithIndex与map操作能否像flatMap、collect那样合并？

Great question! The short answer is yes—while Scala's standard library doesn’t include a built-in method that directly merges zip/zipWithIndex with map, you can easily create this functionality yourself using Scala’s implicit class extensions (a very idiomatic approach). Let’s break this down for both cases:

1. Combining zipWithIndex and map #

If you find yourself repeatedly writing collection.zipWithIndex.map { case (elem, idx) => ... }, you can wrap this logic into a reusable mapWithIndex method. Here’s how:

// Define an implicit class to add the method to all Iterable types
implicit class IterableMapWithIndex[A](val coll: Iterable[A]) extends AnyVal {
  def mapWithIndex[B](f: (A, Int) => B): Iterable[B] =
    coll.zipWithIndex.map { case (elem, index) => f(elem, index) }
}

// Usage example
val numbers = List(10, 20, 30)
val indexedStrings = numbers.mapWithIndex((num, idx) => s"Number $num is at index $idx")
// Result: List("Number 10 is at index 0", "Number 20 is at index 1", "Number 30 is at index 2")

This works for any Iterable (List, Vector, Set, etc.) because we’re extending Iterable[A]. Using AnyVal makes this a value class, so there’s no runtime overhead.

2. Combining zip and map #

Similarly, if you frequently pair two collections with zip then map over the tuples, you can create a mapZip method that handles both steps in one go:

implicit class IterableMapZip[A](val coll: Iterable[A]) extends AnyVal {
  def mapZip[B, C](other: Iterable[B])(f: (A, B) => C): Iterable[C] =
    coll.zip(other).map { case (a, b) => f(a, b) }
}

// Usage example
val letters = List("a", "b", "c")
val combined = numbers.mapZip(letters)((num, letter) => s"$num-$letter")
// Result: List("10-a", "20-b", "30-c")

Why isn’t this built into the standard library? #

Scala’s standard library prioritizes small, composable operations (like zip + map) over specialized combined methods. But since extension methods are so straightforward to write, you can tailor the functionality exactly to your needs without cluttering the standard library.

It’s also worth noting that for some specific collections (like Array), you might find niche index-aware methods, but the implicit class approach works universally across all Scala collections.

内容的提问来源于stack exchange，提问作者user51