Simplified implementations of Array.foreach and Array.map improve performance by 2–3.5×

[2Pit]

Hi!

I've been benchmarking performance of Array.map and Array.foreach in Scala and found that their implementations can be made significantly faster — map by up to 3.5×, and foreach by up to 2× — by simplifying the loop structure in cases where the function operates on statically known primitive types.

The current implementation relies on a match over array types, introducing overhead and making performance less predictable in cases chained transformations. In contrast, a plain loop yields consistent scaling and significantly lower latency per element.

Here’s how the current map method can be simplified:

// current version
def oldMap[B](f: A => B)(implicit ct: ClassTag[B]): Array[B] = {
  val len = xs.length
  val ys = new Array[B](len)
  if (len > 0) {
    var i = 0
    (xs: Any @unchecked) match {
      case xs: Array[Int] => while (i < len) { ys(i) = f(xs(i).asInstanceOf[A]); i += 1 }
      case xs: Array[Long] => while (i < len) { ys(i) = f(xs(i).asInstanceOf[A]); i += 1 }
      // other primitive types...
    }
  }
  ys
}

// proposed version
def newMap[B](f: A => B)(implicit ct: ClassTag[B]): Array[B] = {
  val len = xs.length
  val ys = new Array[B](len)
  var i = 0
  while (i < len) {
    ys(i) = f(xs(i))
    i += 1
  }
  ys
}

You can find the full analysis with plots and measurements below.
Would this kind of improvement be something you'd like to see in the standard library? I'd be happy to contribute a PR.

📊 https://github.com/2Pit/scala-benchmarks/blob/main/review/array_map_foreach/README.md