Two more value classes.

Tuple2Zipped and Tuple3Zipped.

1 files changed, 28 insertions, 30 deletions

diff --git a/src/library/scala/runtime/Tuple3Zipped.scala b/src/library/scala/runtime/Tuple3Zipped.scala
index f3ca08649d..f6aafe41fb 100644
--- a/src/library/scala/runtime/Tuple3Zipped.scala
+++ b/src/library/scala/runtime/Tuple3Zipped.scala
@@ -13,7 +13,7 @@ import scala.collection.generic.{ CanBuildFrom => CBF }
 import language.{ higherKinds, implicitConversions }
 
 /** See comment on ZippedTraversable2. */
-trait ZippedTraversable3[+El1, +El2, +El3] {
+trait ZippedTraversable3[+El1, +El2, +El3] extends Any {
   def foreach[U](f: (El1, El2, El3) => U): Unit
 }
 object ZippedTraversable3 {
@@ -24,17 +24,15 @@ object ZippedTraversable3 {
   }
 }
 
-class Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3](
-  coll1: TraversableLike[El1, Repr1],
-  coll2: IterableLike[El2, Repr2],
-  coll3: IterableLike[El3, Repr3]
-) extends ZippedTraversable3[El1, El2, El3] {
+final class Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3](val colls: (TraversableLike[El1, Repr1], IterableLike[El2, Repr2], IterableLike[El3, Repr3]))
+        extends AnyVal with ZippedTraversable3[El1, El2, El3] {
+
   def map[B, To](f: (El1, El2, El3) => B)(implicit cbf: CBF[Repr1, B, To]): To = {
-    val b = cbf(coll1.repr)
-    val elems2 = coll2.iterator
-    val elems3 = coll3.iterator
+    val b = cbf(colls._1.repr)
+    val elems2 = colls._2.iterator
+    val elems3 = colls._3.iterator
 
-    for (el1 <- coll1) {
+    for (el1 <- colls._1) {
       if (elems2.hasNext && elems3.hasNext)
         b += f(el1, elems2.next, elems3.next)
       else
@@ -44,11 +42,11 @@ class Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3](
   }
 
   def flatMap[B, To](f: (El1, El2, El3) => TraversableOnce[B])(implicit cbf: CBF[Repr1, B, To]): To = {
-    val b = cbf(coll1.repr)
-    val elems2 = coll2.iterator
-    val elems3 = coll3.iterator
+    val b = cbf(colls._1.repr)
+    val elems2 = colls._2.iterator
+    val elems3 = colls._3.iterator
 
-    for (el1 <- coll1) {
+    for (el1 <- colls._1) {
       if (elems2.hasNext && elems3.hasNext)
         b ++= f(el1, elems2.next, elems3.next)
       else
@@ -61,14 +59,14 @@ class Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3](
                implicit cbf1: CBF[Repr1, El1, To1],
                         cbf2: CBF[Repr2, El2, To2],
                         cbf3: CBF[Repr3, El3, To3]): (To1, To2, To3) = {
-    val b1 = cbf1(coll1.repr)
-    val b2 = cbf2(coll2.repr)
-    val b3 = cbf3(coll3.repr)
-    val elems2 = coll2.iterator
-    val elems3 = coll3.iterator
+    val b1 = cbf1(colls._1.repr)
+    val b2 = cbf2(colls._2.repr)
+    val b3 = cbf3(colls._3.repr)
+    val elems2 = colls._2.iterator
+    val elems3 = colls._3.iterator
     def result = (b1.result, b2.result, b3.result)
 
-    for (el1 <- coll1) {
+    for (el1 <- colls._1) {
       if (elems2.hasNext && elems3.hasNext) {
         val el2 = elems2.next
         val el3 = elems3.next
@@ -86,10 +84,10 @@ class Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3](
   }
 
   def exists(f: (El1, El2, El3) => Boolean): Boolean = {
-    val elems2 = coll2.iterator
-    val elems3 = coll3.iterator
+    val elems2 = colls._2.iterator
+    val elems3 = colls._3.iterator
 
-    for (el1 <- coll1) {
+    for (el1 <- colls._1) {
       if (elems2.hasNext && elems3.hasNext) {
         if (f(el1, elems2.next, elems3.next))
           return true
@@ -103,10 +101,10 @@ class Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3](
     !exists((x, y, z) => !f(x, y, z))
 
   def foreach[U](f: (El1, El2, El3) => U): Unit = {
-    val elems2 = coll2.iterator
-    val elems3 = coll3.iterator
+    val elems2 = colls._2.iterator
+    val elems3 = colls._3.iterator
 
-    for (el1 <- coll1) {
+    for (el1 <- colls._1) {
       if (elems2.hasNext && elems3.hasNext)
         f(el1, elems2.next, elems3.next)
       else
@@ -116,7 +114,7 @@ class Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3](
 }
 
 object Tuple3Zipped {
-  class Ops[T1, T2, T3](x: (T1, T2, T3)) {
+  final class Ops[T1, T2, T3](val x: (T1, T2, T3)) extends AnyVal {
     def invert[El1, CC1[X] <: TraversableOnce[X], El2, CC2[X] <: TraversableOnce[X], El3, CC3[X] <: TraversableOnce[X], That]
       (implicit w1: T1 <:< CC1[El1],
                 w2: T2 <:< CC2[El2],
@@ -129,14 +127,14 @@ object Tuple3Zipped {
         val it3 = x._3.toIterator
         while (it1.hasNext && it2.hasNext && it3.hasNext)
           buf += ((it1.next, it2.next, it3.next))
-        
+
         buf.result
       }
-    
+
     def zipped[El1, Repr1, El2, Repr2, El3, Repr3]
       (implicit w1: T1 => TraversableLike[El1, Repr1],
                 w2: T2 => IterableLike[El2, Repr2],
                 w3: T3 => IterableLike[El3, Repr3]
-      ): Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3] = new Tuple3Zipped(x._1, x._2, x._3)
+      ): Tuple3Zipped[El1, Repr1, El2, Repr2, El3, Repr3] = new Tuple3Zipped((x._1, x._2, x._3))
   }
 }