Add LazyZipOps and some other files to stdlib

Author: odersky

tests/pos-special/stdlib/collection/BufferedIterator.scala

@@ -0,0 +1,32 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala.collection
+import language.experimental.captureChecking
+
+/** Buffered iterators are iterators which provide a method `head`
+ *  that inspects the next element without discarding it.
+ */
+trait BufferedIterator[+A] extends Iterator[A] {
+
+  /** Returns next element of iterator without advancing beyond it.
+   */
+  def head: A
+
+  /** Returns an option of the next element of an iterator without advancing beyond it.
+    * @return  the next element of this iterator if it has a next element
+    *           `None` if it does not
+    */
+  def headOption : Option[A] = if (hasNext) Some(head) else None
+
+  override def buffered: this.type = this
+}

tests/pos-special/stdlib/collection/Hashing.scala

@@ -0,0 +1,63 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala
+package collection
+import language.experimental.captureChecking
+
+
+protected[collection] object Hashing {
+
+  def elemHashCode(key: Any): Int = key.##
+
+  def improve(hcode: Int): Int = {
+    var h: Int = hcode + ~(hcode << 9)
+    h = h ^ (h >>> 14)
+    h = h + (h << 4)
+    h ^ (h >>> 10)
+  }
+
+  def computeHash(key: Any): Int =
+    improve(elemHashCode(key))
+
+  /**
+    * Utility method to keep a subset of all bits in a given bitmap
+    *
+    * Example
+    *    bitmap (binary): 00000001000000010000000100000001
+    *    keep (binary):                               1010
+    *    result (binary): 00000001000000000000000100000000
+    *
+    * @param bitmap the bitmap
+    * @param keep a bitmask containing which bits to keep
+    * @return the original bitmap with all bits where keep is not 1 set to 0
+    */
+  def keepBits(bitmap: Int, keep: Int): Int = {
+    var result = 0
+    var current = bitmap
+    var kept = keep
+    while (kept != 0) {
+      // lowest remaining bit in current
+      val lsb = current ^ (current & (current - 1))
+      if ((kept & 1) != 0) {
+        // mark bit in result bitmap
+        result |= lsb
+      }
+      // clear lowest remaining one bit in abm
+      current &= ~lsb
+      // look at the next kept bit
+      kept >>>= 1
+    }
+    result
+  }
+
+}

tests/pos-special/stdlib/collection/Iterable.scala

@@ -96,7 +96,7 @@ trait Iterable[+A] extends IterableOnce[A]
     * @return a decorator `LazyZip2` that allows strict operations to be performed on the lazily evaluated pairs
     *         or chained calls to `lazyZip`. Implicit conversion to `Iterable[(A, B)]` is also supported.
     */
-  def lazyZip[B](that: Iterable[B]): LazyZip2[A, B, this.type] = new LazyZip2(this, this, that)
+  def lazyZip[B](that: Iterable[B]^): LazyZip2[A, B, this.type]^{this, that} = new LazyZip2(this, this, that)
 }
 
 /** Base trait for Iterable operations