Merge pull request #223 from marcelocenerine/master

Add zipWith operation

Author: julienrf

README.md

@@ -231,7 +231,7 @@ For more information, see the [CONTRIBUTING](CONTRIBUTING.md) file.
 - [x] `sliding`
 - [x] `unzip`
 - [x] `values` / `valuesIterator`
-- [x] `zip` / `zipWithIndex`
+- [x] `zip` / `zipWithIndex` / `lazyZip`
 
 ### In-place mutating operations
 

benchmarks/time/src/main/scala/strawman/collection/immutable/HashSetBenchmark.scala

@@ -135,6 +135,21 @@ class HashSetBenchmark {
     }
   }
 
+  @Benchmark
+  def transform_zip(bh: Blackhole): Unit = bh.consume(xs.zip(xs))
+
+  @Benchmark
+  def transform_zipMapTupled(bh: Blackhole): Unit = {
+    val f = (a: Long, b: Long) => (a, b)
+    bh.consume(xs.zip(xs).map(f.tupled))
+  }
+
+  @Benchmark
+  def transform_zipWithIndex(bh: Blackhole): Unit = bh.consume(xs.zipWithIndex)
+
+  @Benchmark
+  def transform_lazyZip(bh: Blackhole): Unit = bh.consume(xs.lazyZip(xs).map((_, _)))
+
   @Benchmark
   def transform_unzip(bh: Blackhole): Unit = bh.consume(zipped.unzip)
 

benchmarks/time/src/main/scala/strawman/collection/immutable/ImmutableArrayBenchmark.scala

@@ -273,6 +273,21 @@ class ImmutableArrayBenchmark {
     }
   }
 
+  @Benchmark
+  def transform_zip(bh: Blackhole): Unit = bh.consume(xs.zip(xs))
+
+  @Benchmark
+  def transform_zipMapTupled(bh: Blackhole): Unit = {
+    val f = (a: Long, b: Long) => (a, b)
+    bh.consume(xs.zip(xs).map(f.tupled))
+  }
+
+  @Benchmark
+  def transform_zipWithIndex(bh: Blackhole): Unit = bh.consume(xs.zipWithIndex)
+
+  @Benchmark
+  def transform_lazyZip(bh: Blackhole): Unit = bh.consume(xs.lazyZip(xs).map((_, _)))
+
   @Benchmark
   def transform_unzip(bh: Blackhole): Unit = bh.consume(zipped.unzip)
 

benchmarks/time/src/main/scala/strawman/collection/immutable/LazyListBenchmark.scala

@@ -273,6 +273,21 @@ class LazyListBenchmark {
     }
   }
 
+  @Benchmark
+  def transform_zip(bh: Blackhole): Unit = bh.consume(xs.zip(xs))
+
+  @Benchmark
+  def transform_zipMapTupled(bh: Blackhole): Unit = {
+    val f = (a: Long, b: Long) => (a, b)
+    bh.consume(xs.zip(xs).map(f.tupled))
+  }
+
+  @Benchmark
+  def transform_zipWithIndex(bh: Blackhole): Unit = bh.consume(xs.zipWithIndex)
+
+  @Benchmark
+  def transform_lazyZip(bh: Blackhole): Unit = bh.consume(xs.lazyZip(xs).map((_, _)))
+
   @Benchmark
   def transform_unzip(bh: Blackhole): Unit = bh.consume(zipped.unzip)
 

benchmarks/time/src/main/scala/strawman/collection/immutable/ListBenchmark.scala

@@ -273,6 +273,21 @@ class ListBenchmark {
     }
   }
 
+  @Benchmark
+  def transform_zip(bh: Blackhole): Unit = bh.consume(xs.zip(xs))
+
+  @Benchmark
+  def transform_zipMapTupled(bh: Blackhole): Unit = {
+    val f = (a: Long, b: Long) => (a, b)
+    bh.consume(xs.zip(xs).map(f.tupled))
+  }
+
+  @Benchmark
+  def transform_zipWithIndex(bh: Blackhole): Unit = bh.consume(xs.zipWithIndex)
+
+  @Benchmark
+  def transform_lazyZip(bh: Blackhole): Unit = bh.consume(xs.lazyZip(xs).map((_, _)))
+
   @Benchmark
   def transform_unzip(bh: Blackhole): Unit = bh.consume(zipped.unzip)
 

benchmarks/time/src/main/scala/strawman/collection/immutable/NumericRangeBenchmark.scala

@@ -21,12 +21,14 @@ class NumericRangeBenchmark {
   var xs: NumericRange[Int] = _
   var zs: NumericRange[Int] = _
   var randomIndices: scala.Array[Int] = _
+  var zipped: IndexedSeq[(Long, Long)] = _
   def fresh(n: Int) = NumericRange.inclusive(1, n, 1)
 
   @Setup(Level.Trial)
   def initTrial(): Unit = {
     xs = fresh(size)
     zs = NumericRange.inclusive(-1, (-size / 1000) min -2, -1)
+    zipped = xs.map(x => (x, x))
     if (size > 0) {
       randomIndices = scala.Array.fill(1000)(scala.util.Random.nextInt(size))
     }
@@ -176,4 +178,25 @@ class NumericRangeBenchmark {
     val result = xs.groupBy(_ % 5)
     bh.consume(result)
   }
+
+  @Benchmark
+  def transform_zip(bh: Blackhole): Unit = bh.consume(xs.zip(xs))
+
+  @Benchmark
+  def transform_zipMapTupled(bh: Blackhole): Unit = {
+    val f = (a: Int, b: Int) => (a, b)
+    bh.consume(xs.zip(xs).map(f.tupled))
+  }
+
+  @Benchmark
+  def transform_zipWithIndex(bh: Blackhole): Unit = bh.consume(xs.zipWithIndex)
+
+  @Benchmark
+  def transform_lazyZip(bh: Blackhole): Unit = {
+    val xs1: IndexedSeq[Int] = xs
+    bh.consume(xs1.lazyZip(xs1).map((_, _)))
+  }
+
+  @Benchmark
+  def transform_unzip(bh: Blackhole): Unit = bh.consume(zipped.unzip)
 }

benchmarks/time/src/main/scala/strawman/collection/immutable/RangeBenchmark.scala

@@ -21,12 +21,14 @@ class RangeBenchmark {
   var xs: Range = _
   var zs: Range = _
   var randomIndices: scala.Array[Int] = _
+  var zipped: IndexedSeq[(Long, Long)] = _
   def fresh(n: Int) = Range.inclusive(1, n, 1)
 
   @Setup(Level.Trial)
   def initTrial(): Unit = {
     xs = fresh(size)
     zs = Range.inclusive(-1, (-size / 1000) min -2, -1)
+    zipped = xs.map(x => (x, x))
     if (size > 0) {
       randomIndices = scala.Array.fill(1000)(scala.util.Random.nextInt(size))
     }
@@ -176,4 +178,25 @@ class RangeBenchmark {
     val result = xs.groupBy(_ % 5)
     bh.consume(result)
   }
+
+  @Benchmark
+  def transform_zip(bh: Blackhole): Unit = bh.consume(xs.zip(xs))
+
+  @Benchmark
+  def transform_zipMapTupled(bh: Blackhole): Unit = {
+    val f = (a: Int, b: Int) => (a, b)
+    bh.consume(xs.zip(xs).map(f.tupled))
+  }
+
+  @Benchmark
+  def transform_zipWithIndex(bh: Blackhole): Unit = bh.consume(xs.zipWithIndex)
+
+  @Benchmark
+  def transform_lazyZip(bh: Blackhole): Unit = {
+    val xs1: IndexedSeq[Int] = xs
+    bh.consume(xs1.lazyZip(xs1).map((_, _)))
+  }
+
+  @Benchmark
+  def transform_unzip(bh: Blackhole): Unit = bh.consume(zipped.unzip)
 }

benchmarks/time/src/main/scala/strawman/collection/immutable/ScalaHashSetBenchmark.scala

@@ -5,8 +5,8 @@ import java.util.concurrent.TimeUnit
 import org.openjdk.jmh.annotations._
 import org.openjdk.jmh.infra.Blackhole
 
-import scala.{Any, AnyRef, Int, Long, Unit, math}
-import scala.Predef.intWrapper
+import scala.{Any, AnyRef, Int, Long, Tuple2, Unit, math}
+import scala.Predef.{intWrapper, $conforms, tuple2ToZippedOps}
 
 @BenchmarkMode(scala.Array(Mode.AverageTime))
 @OutputTimeUnit(TimeUnit.NANOSECONDS)
@@ -135,6 +135,21 @@ class ScalaHashSetBenchmark {
     }
   }
 
+  @Benchmark
+  def transform_zip(bh: Blackhole): Unit = bh.consume(xs.zip(xs))
+
+  @Benchmark
+  def transform_zipMapTupled(bh: Blackhole): Unit = {
+    val f = (a: Long, b: Long) => (a, b)
+    bh.consume(xs.zip(xs).map(f.tupled))
+  }
+
+  @Benchmark
+  def transform_zipWithIndex(bh: Blackhole): Unit = bh.consume(xs.zipWithIndex)
+
+  @Benchmark
+  def transform_lazyZip(bh: Blackhole): Unit = bh.consume((xs, xs).zipped.map((_, _)))
+
   @Benchmark
   def transform_unzip(bh: Blackhole): Unit = bh.consume(zipped.unzip(t => (t._1, t._2)))
 

benchmarks/time/src/main/scala/strawman/collection/immutable/ScalaListBenchmark.scala

@@ -5,8 +5,8 @@ import java.util.concurrent.TimeUnit
 import org.openjdk.jmh.annotations._
 import org.openjdk.jmh.infra.Blackhole
 
-import scala.{Any, AnyRef, Int, Long, Unit, math}
-import scala.Predef.{intWrapper, $conforms}
+import scala.{Any, AnyRef, Int, Long, Tuple2, Unit, math}
+import scala.Predef.{intWrapper, $conforms, tuple2ToZippedOps}
 
 @BenchmarkMode(scala.Array(Mode.AverageTime))
 @OutputTimeUnit(TimeUnit.NANOSECONDS)
@@ -270,6 +270,21 @@ class ScalaListBenchmark {
     }
   }
 
+  @Benchmark
+  def transform_zip(bh: Blackhole): Unit = bh.consume(xs.zip(xs))
+
+  @Benchmark
+  def transform_zipMapTupled(bh: Blackhole): Unit = {
+    val f = (a: Long, b: Long) => (a, b)
+    bh.consume(xs.zip(xs).map(f.tupled))
+  }
+
+  @Benchmark
+  def transform_zipWithIndex(bh: Blackhole): Unit = bh.consume(xs.zipWithIndex)
+
+  @Benchmark
+  def transform_lazyZip(bh: Blackhole): Unit = bh.consume((xs, xs).zipped.map((_, _)))
+
   @Benchmark
   def transform_unzip(bh: Blackhole): Unit = bh.consume(zipped.unzip)
 

benchmarks/time/src/main/scala/strawman/collection/immutable/ScalaTreeSetBenchmark.scala

@@ -5,8 +5,8 @@ import java.util.concurrent.TimeUnit
 import org.openjdk.jmh.annotations._
 import org.openjdk.jmh.infra.Blackhole
 
-import scala.{Any, AnyRef, Int, Long, Unit, math}
-import scala.Predef.intWrapper
+import scala.{Any, AnyRef, Int, Long, Tuple2, Unit, math}
+import scala.Predef.{intWrapper, tuple2ToZippedOps, $conforms}
 
 @BenchmarkMode(scala.Array(Mode.AverageTime))
 @OutputTimeUnit(TimeUnit.NANOSECONDS)
@@ -135,6 +135,21 @@ class ScalaTreeSetBenchmark {
     }
   }
 
+  @Benchmark
+  def transform_zip(bh: Blackhole): Unit = bh.consume(xs.zip(xs))
+
+  @Benchmark
+  def transform_zipMapTupled(bh: Blackhole): Unit = {
+    val f = (a: Long, b: Long) => (a, b)
+    bh.consume(xs.zip(xs).map(f.tupled))
+  }
+
+  @Benchmark
+  def transform_zipWithIndex(bh: Blackhole): Unit = bh.consume(xs.zipWithIndex)
+
+  @Benchmark
+  def transform_lazyZip(bh: Blackhole): Unit = bh.consume((xs, xs).zipped.map((_, _)))
+
   @Benchmark
   def transform_unzip(bh: Blackhole): Unit = bh.consume(zipped.unzip(t => (t._1, t._2)))