Take advantage of IndexedViews in IndexedSeqOps

Add IndexedView.Slice
Reduce indirection levels by generalizing views to accept XxxOps
parameters instead of collection types
Add MapView.FilterKeys

Author: julienrf

collections/src/main/scala/strawman/collection/ArrayOps.scala

@@ -27,7 +27,7 @@ object ArrayOps {
 class ArrayOps[A](val xs: Array[A]) extends AnyVal
   with IterableOnce[A]
   with IndexedSeqOps[A, immutable.IndexedSeq, Array[A]]
-  with StrictOptimizedSeqOps[A, Seq, Array[A]] {
+  with StrictOptimizedSeqOps[A, immutable.IndexedSeq, Array[A]] {
 
   protected def fromTaggedIterable[B: ClassTag](coll: Iterable[B]): Array[B] = coll.toArray[B]
 
@@ -51,7 +51,7 @@ class ArrayOps[A](val xs: Array[A]) extends AnyVal
 
   override def className = "Array"
 
-  def map[B: ClassTag](f: A => B): Array[B] = fromTaggedIterable(new View.Map(toIterable, f))
+  def map[B: ClassTag](f: A => B): Array[B] = fromTaggedIterable(new View.Map(this, f))
 
   def mapInPlace(f: A => A): Array[A] = {
     var i = 0
@@ -65,7 +65,7 @@ class ArrayOps[A](val xs: Array[A]) extends AnyVal
   def flatMap[B: ClassTag](f: A => IterableOnce[B]): Array[B] = fromTaggedIterable(new View.FlatMap(toIterable, f))
 
   def flatMap[BS, B](f: A => BS)(implicit asIterable: BS => Iterable[B], m: ClassTag[B]): Array[B] =
-    fromTaggedIterable(new View.FlatMap(toIterable, (x: A) => asIterable(f(x))))
+    fromTaggedIterable(new View.FlatMap(this, (x: A) => asIterable(f(x))))
 
   def flatten[B](implicit asIterable: A => strawman.collection.Iterable[B], m: ClassTag[B]): Array[B] = {
     val b = WrappedArray.newBuilder[B]().mapResult(_.toArray)
@@ -81,22 +81,22 @@ class ArrayOps[A](val xs: Array[A]) extends AnyVal
 
   @`inline` final def ++[B >: A : ClassTag](xs: Iterable[B]): Array[B] = appendedAll(xs)
 
-  def zip[B: ClassTag](that: Iterable[B]): Array[(A, B)] = fromTaggedIterable(new View.Zip(toIterable, that))
+  def zip[B: ClassTag](that: Iterable[B]): Array[(A, B)] = fromTaggedIterable(new View.Zip(this, that))
 
-  def zipWithIndex(implicit ct: ClassTag[(A, Int)]): Array[(A, Int)] = fromTaggedIterable(new View.ZipWithIndex(toIterable))
+  def zipWithIndex(implicit ct: ClassTag[(A, Int)]): Array[(A, Int)] = fromTaggedIterable(new View.ZipWithIndex(this))
 
-  def appended[B >: A : ClassTag](x: B): Array[B] = fromTaggedIterable(new View.Appended(toIterable, x))
+  def appended[B >: A : ClassTag](x: B): Array[B] = fromTaggedIterable(new View.Appended(this, x))
   @`inline` final def :+ [B >: A : ClassTag](x: B): Array[B] = appended(x)
-  def prepended[B >: A : ClassTag](x: B): Array[B] = fromTaggedIterable(new View.Prepended(x, toIterable))
+  def prepended[B >: A : ClassTag](x: B): Array[B] = fromTaggedIterable(new View.Prepended(x, this))
   @`inline` final def +: [B >: A : ClassTag](x: B): Array[B] = prepended(x)
-  def prependedAll[B >: A : ClassTag](prefix: Iterable[B]): Array[B] = fromTaggedIterable(new View.Concat(prefix, toIterable))
+  def prependedAll[B >: A : ClassTag](prefix: Iterable[B]): Array[B] = fromTaggedIterable(new View.Concat(prefix, this))
   @`inline` final def ++: [B >: A : ClassTag](prefix: Iterable[B]): Array[B] = prependedAll(prefix)
-  def appendedAll[B >: A : ClassTag](suffix: Iterable[B]): Array[B] = fromTaggedIterable(new View.Concat(toIterable, suffix))
+  def appendedAll[B >: A : ClassTag](suffix: Iterable[B]): Array[B] = fromTaggedIterable(new View.Concat(this, suffix))
   @`inline` final def :++ [B >: A : ClassTag](suffix: Iterable[B]): Array[B] = appendedAll(suffix)
   @`inline` final def concat[B >: A : ClassTag](suffix: Iterable[B]): Array[B] = appendedAll(suffix)
 
   def patch[B >: A : ClassTag](from: Int, other: Iterable[B], replaced: Int): Array[B] =
-    fromTaggedIterable(new View.Patched(toIterable, from, other, replaced)) //TODO optimize
+    fromTaggedIterable(new View.Patched(this, from, other, replaced)) //TODO optimize
 
   /** Converts an array of pairs into an array of first elements and an array of second elements.
     *

collections/src/main/scala/strawman/collection/IndexedSeq.scala

@@ -29,14 +29,24 @@ trait IndexedSeqOps[+A, +CC[_], +C] extends Any with SeqOps[A, CC, C] { self =>
 
   override def view: IndexedView[A] = new IndexedView.Id[A](this)
 
-  override protected[this] def reversed: Iterable[A] = view.reverse
+  override protected[this] def reversed: Iterable[A] = new IndexedView.Reverse(this)
 
-  /** A collection containing the last `n` elements of this collection. */
-  override def takeRight(n: Int): C = fromSpecificIterable(view.takeRight(n))
+  // Override transformation operations to use more efficient views than the default ones
+  override def prepended[B >: A](elem: B): CC[B] = iterableFactory.from(new IndexedView.Prepended(elem, this))
 
-  /** The rest of the collection without its `n` last elements. For
-    * linear, immutable collections this should avoid making a copy. */
-  override def dropRight(n: Int): C = fromSpecificIterable(view.dropRight(n))
+  override def take(n: Int): C = fromSpecificIterable(new IndexedView.Take(this, n))
+
+  override def takeRight(n: Int): C = fromSpecificIterable(new IndexedView.TakeRight(this, n))
+
+  override def drop(n: Int): C = fromSpecificIterable(new IndexedView.Drop(this, n))
+
+  override def dropRight(n: Int): C = fromSpecificIterable(new IndexedView.DropRight(this, n))
+
+  override def map[B](f: A => B): CC[B] = iterableFactory.from(new IndexedView.Map(this, f))
+
+  override def reverse: C = fromSpecificIterable(new IndexedView.Reverse(this))
+
+  override def slice(from: Int, until: Int): C = fromSpecificIterable(new IndexedView.Slice(this, from, until))
 
   override def lengthCompare(len: Int): Int = length - len
 

collections/src/main/scala/strawman/collection/IndexedView.scala

@@ -27,45 +27,58 @@ trait IndexedView[+A] extends IndexedSeqOps[A, View, View[A]] with SeqView[A] {
   override def dropRight(n: Int): IndexedView[A] = new IndexedView.DropRight(this, n)
   override def map[B](f: A => B): IndexedView[B] = new IndexedView.Map(this, f)
   override def reverse: IndexedView[A] = new IndexedView.Reverse(this)
+  override def slice(from: Int, until: Int): IndexedView[A] = new IndexedView.Slice(this, from, until)
 }
 
 object IndexedView {
 
-  class Id[+A](underlying: IndexedSeqOps[A, AnyConstr, _])
+  /** An `IndexedSeqOps` whose collection type and collection type constructor are unknown */
+  type SomeIndexedSeqOps[A] = IndexedSeqOps[A, AnyConstr, _]
+
+  class Id[+A](underlying: SomeIndexedSeqOps[A])
     extends SeqView.Id(underlying) with IndexedView[A]
 
-  class Prepended[+A](elem: A, underlying: Iterable[A] with IndexedSeqOps[A, AnyConstr, _])
+  class Prepended[+A](elem: A, underlying: SomeIndexedSeqOps[A])
     extends SeqView.Prepended(elem, underlying) with IndexedView[A]
 
-  class Take[A](underlying: IndexedView[A], n: Int)
+  class Take[A](underlying: SomeIndexedSeqOps[A], n: Int)
     extends SeqView.Take(underlying, n) with IndexedView[A]
 
-  class TakeRight[A](underlying: IndexedView[A], n: Int) extends IndexedView[A] {
+  class TakeRight[A](underlying: SomeIndexedSeqOps[A], n: Int) extends IndexedView[A] {
     private[this] val delta = (underlying.size - (n max 0)) max 0
     def length = underlying.size - delta
     @throws[IndexOutOfBoundsException]
     def apply(i: Int) = underlying.apply(i + delta)
   }
 
-  class Drop[A](underlying: IndexedView[A], n: Int) extends View.Drop[A](underlying, n) with IndexedView[A] {
+  class Drop[A](underlying: SomeIndexedSeqOps[A], n: Int) extends View.Drop[A](underlying, n) with IndexedView[A] {
     def length = (underlying.size - normN) max 0
     @throws[IndexOutOfBoundsException]
     def apply(i: Int) = underlying.apply(i + normN)
   }
 
-  class DropRight[A](underlying: IndexedView[A], n: Int) extends IndexedView[A] {
+  class DropRight[A](underlying: SomeIndexedSeqOps[A], n: Int) extends IndexedView[A] {
     private[this] val len = (underlying.size - (n max 0)) max 0
     def length = len
     @throws[IndexOutOfBoundsException]
     def apply(i: Int) = underlying.apply(i)
   }
 
-  class Map[A, B](underlying: IndexedView[A], f: A => B)
+  class Map[A, B](underlying: SomeIndexedSeqOps[A], f: A => B)
     extends SeqView.Map(underlying, f) with IndexedView[B]
 
-  class Reverse[A](underlying: IndexedView[A]) extends IndexedView[A] {
+  class Reverse[A](underlying: SomeIndexedSeqOps[A]) extends IndexedView[A] {
     def length = underlying.size
     @throws[IndexOutOfBoundsException]
     def apply(i: Int) = underlying.apply(size - 1 - i)
   }
+
+  class Slice[A](underlying: SomeIndexedSeqOps[A], from: Int, until: Int) extends IndexedView[A] {
+    protected val lo = from max 0
+    protected val hi = until min underlying.length
+    protected val len = (hi - lo) max 0
+    @throws[IndexOutOfBoundsException]
+    def apply(i: Int): A = underlying(lo + i)
+    def length: Int = len
+  }
 }

collections/src/main/scala/strawman/collection/Iterable.scala

@@ -84,7 +84,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
   protected[this] def fromSpecificIterable(coll: Iterable[A]): C
 
   /** Similar to `fromSpecificIterable`, but for a (possibly) different type of element.
-    * Note that the return type is know `CC[E]`.
+    * Note that the return type is now `CC[E]`.
     */
   @`inline` final protected[this] def fromIterable[E](it: Iterable[E]): CC[E] = iterableFactory.from(it)
 
@@ -711,15 +711,15 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *  @return      a new $coll consisting of all elements of this $coll that satisfy the given
     *               predicate `pred`. Their order may not be preserved.
     */
-  def filter(pred: A => Boolean): C = fromSpecificIterable(new View.Filter(toIterable, pred, isFlipped = false))
+  def filter(pred: A => Boolean): C = fromSpecificIterable(new View.Filter(this, pred, isFlipped = false))
 
   /** Selects all elements of this $coll which do not satisfy a predicate.
     *
     *  @param pred  the predicate used to test elements.
     *  @return      a new $coll consisting of all elements of this $coll that do not satisfy the given
     *               predicate `pred`. Their order may not be preserved.
     */
-  def filterNot(pred: A => Boolean): C = fromSpecificIterable(new View.Filter(toIterable, pred, isFlipped = true))
+  def filterNot(pred: A => Boolean): C = fromSpecificIterable(new View.Filter(this, pred, isFlipped = true))
 
   /** Creates a non-strict filter of this $coll.
     *
@@ -744,7 +744,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     */
   class WithFilter(p: A => Boolean) extends collection.WithFilter[A, CC] {
 
-    protected[this] def filtered = new View.Filter(toIterable, p, isFlipped = false)
+    protected[this] def filtered = new View.Filter(IterableOps.this, p, isFlipped = false)
 
     def map[B](f: A => B): CC[B] = iterableFactory.from(new View.Map(filtered, f))
 
@@ -764,7 +764,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *  which requires only a single traversal.
     */
   def partition(p: A => Boolean): (C, C) = {
-    val pn = new View.Partition(toIterable, p)
+    val pn = new View.Partition(this, p)
     (fromSpecificIterable(pn.first), fromSpecificIterable(pn.second))
   }
 
@@ -780,7 +780,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
   def splitAt(n: Int): (C, C) = (take(n), drop(n))
 
   /** A collection containing the first `n` elements of this collection. */
-  def take(n: Int): C = fromSpecificIterable(new View.Take(toIterable, n))
+  def take(n: Int): C = fromSpecificIterable(new View.Take(this, n))
 
   /** A collection containing the last `n` elements of this collection. */
   def takeRight(n: Int): C = {
@@ -802,7 +802,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *  @return  the longest prefix of this $coll whose elements all satisfy
     *           the predicate `p`.
     */
-  def takeWhile(p: A => Boolean): C = fromSpecificIterable(new View.TakeWhile(toIterable, p))
+  def takeWhile(p: A => Boolean): C = fromSpecificIterable(new View.TakeWhile(this, p))
 
   /** Splits this $coll into a prefix/suffix pair according to a predicate.
     *
@@ -820,7 +820,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
   /** The rest of the collection without its `n` first elements. For
     *  linear, immutable collections this should avoid making a copy.
     */
-  def drop(n: Int): C = fromSpecificIterable(new View.Drop(toIterable, n))
+  def drop(n: Int): C = fromSpecificIterable(new View.Drop(this, n))
 
   /** The rest of the collection without its `n` last elements. For
     *  linear, immutable collections this should avoid making a copy.
@@ -843,7 +843,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *  @return  the longest suffix of this $coll whose first element
     *           does not satisfy the predicate `p`.
     */
-  def dropWhile(p: A => Boolean): C = fromSpecificIterable(new View.DropWhile(toIterable, p))
+  def dropWhile(p: A => Boolean): C = fromSpecificIterable(new View.DropWhile(this, p))
 
   /** Partitions elements in fixed size ${coll}s.
    *  @see [[scala.collection.Iterator]], method `grouped`
@@ -907,7 +907,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *           of this $coll.
     */
   def slice(from: Int, until: Int): C =
-    fromSpecificIterable(new View.Drop(new View.Take(toIterable, until), from))
+    fromSpecificIterable(new View.Drop(new View.Take(this, until), from))
 
   /** Partitions this $coll into a map of ${coll}s according to some discriminator function.
     *
@@ -1022,7 +1022,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *  @param op      the binary operator applied to the intermediate result and the element
     *  @return        collection with intermediate results
     */
-  def scanLeft[B](z: B)(op: (B, A) => B): CC[B] = fromIterable(new View.ScanLeft(toIterable, z, op))
+  def scanLeft[B](z: B)(op: (B, A) => B): CC[B] = fromIterable(new View.ScanLeft(this, z, op))
 
   /** Produces a collection containing cumulative results of applying the operator going right to left.
     *  The head of the collection is the last cumulative result.
@@ -1056,7 +1056,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *  @return       a new $coll resulting from applying the given function
     *                `f` to each element of this $coll and collecting the results.
     */
-  def map[B](f: A => B): CC[B] = fromIterable(new View.Map(toIterable, f))
+  def map[B](f: A => B): CC[B] = fromIterable(new View.Map(this, f))
 
   /** Builds a new collection by applying a function to all elements of this $coll
     *  and using the elements of the resulting collections.
@@ -1089,7 +1089,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *  @return       a new $coll resulting from applying the given collection-valued function
     *                `f` to each element of this $coll and concatenating the results.
     */
-  def flatMap[B](f: A => IterableOnce[B]): CC[B] = fromIterable(new View.FlatMap(toIterable, f))
+  def flatMap[B](f: A => IterableOnce[B]): CC[B] = fromIterable(new View.FlatMap(this, f))
 
   /** Converts this $coll of traversable collections into
     *  a $coll formed by the elements of these traversable
@@ -1119,7 +1119,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *
     */
   def flatten[B](implicit asIterable: A => IterableOnce[B]): CC[B] =
-    fromIterable(new View.FlatMap(toIterable, asIterable))
+    fromIterable(new View.FlatMap(this, asIterable))
 
   /** Builds a new collection by applying a partial function to all elements of this $coll
     *  on which the function is defined.
@@ -1159,7 +1159,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *  @return       a new $coll which contains all elements
     *                of this $coll followed by all elements of `suffix`.
     */
-  def concat[B >: A](suffix: Iterable[B]): CC[B] = fromIterable(new View.Concat(toIterable, suffix))
+  def concat[B >: A](suffix: Iterable[B]): CC[B] = fromIterable(new View.Concat(this, suffix))
 
   /** Alias for `concat` */
   @`inline` final def ++ [B >: A](suffix: Iterable[B]): CC[B] = concat(suffix)
@@ -1173,7 +1173,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *  @return        a new $coll containing pairs consisting of corresponding elements of this $coll and `that`.
     *                 The length of the returned collection is the minimum of the lengths of this $coll and `that`.
     */
-  def zip[B](that: Iterable[B]): CC[(A @uncheckedVariance, B)] = fromIterable(new View.Zip(toIterable, that))
+  def zip[B](that: Iterable[B]): CC[(A @uncheckedVariance, B)] = fromIterable(new View.Zip(this, that))
   // sound bcs of VarianceNote
 
   /** Zips this $coll with its indices.
@@ -1183,7 +1183,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *  @example
     *    `List("a", "b", "c").zipWithIndex == List(("a", 0), ("b", 1), ("c", 2))`
     */
-  def zipWithIndex: CC[(A @uncheckedVariance, Int)] = fromIterable(new View.ZipWithIndex(toIterable))
+  def zipWithIndex: CC[(A @uncheckedVariance, Int)] = fromIterable(new View.ZipWithIndex(this))
 
   /** Returns a $coll formed from this $coll and another iterable collection
     *  by combining corresponding elements in pairs.
@@ -1199,7 +1199,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *                 If this $coll is shorter than `that`, `thisElem` values are used to pad the result.
     *                 If `that` is shorter than this $coll, `thatElem` values are used to pad the result.
     */
-  def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): CC[(A1, B)] = fromIterable(new View.ZipAll(toIterable, that, thisElem, thatElem))
+  def zipAll[A1 >: A, B](that: Iterable[B], thisElem: A1, thatElem: B): CC[(A1, B)] = fromIterable(new View.ZipAll(this, that, thisElem, thatElem))
 
   /** Converts this $coll of pairs into two collections of the first and second
     *  half of each pair.
@@ -1221,7 +1221,7 @@ trait IterableOps[+A, +CC[_], +C] extends Any with IterableOnce[A] {
     *                half of each element pair of this $coll.
     */
   def unzip[A1, A2](implicit asPair: A => (A1, A2)): (CC[A1], CC[A2]) = {
-    val unzipped = new View.Unzip(toIterable)
+    val unzipped = new View.Unzip(this)
     (fromIterable(unzipped.first), fromIterable(unzipped.second))
   }
 

collections/src/main/scala/strawman/collection/Map.scala

@@ -158,7 +158,7 @@ trait MapOps[K, +V, +CC[_, _] <: IterableOps[_, AnyConstr, _], +C]
     *  @return an immutable map consisting only of those key value pairs of this map where the key satisfies
     *          the predicate `p`. The resulting map wraps the original map without copying any elements.
     */
-  def filterKeys(p: K => Boolean): View[(K, V)] = new View.FilterKeys(toIterable, p)
+  def filterKeys(p: K => Boolean): MapView[K, V] = new MapView.FilterKeys(this, p)
 
   /** Transforms this map by applying a function to every retrieved value.
     *  @param  f   the function used to transform values of this map.