WrappedArray -> ArraySeq

Author: lrytz

README.md

@@ -161,7 +161,7 @@ as the collection can (in some cases) be built in parallel.
 
 Because the wrappers are invoked based on the static type of the collection, there are also cases where parallelization
 is inefficient when interfacing with Java 8 Streams (e.g. when a collection is typed as `Seq[String]` so might have linear
-access like `List`, but actually is a `WrappedArray[String]` that can be efficiently parallelized) but can be efficient
+access like `List`, but actually is an `ArraySeq[String]` that can be efficiently parallelized) but can be efficient
 with Scala parallel collections.  The `parStream` method is only available when the static type is known to be compatible
 with rapid parallel operation; `seqStream` can be parallelized by using `.parallel`, but may or may not be efficient.
 

benchmark/src/main/scala/bench/CollectionSource.scala

@@ -256,7 +256,7 @@ package object generate {
 
   class MuqThings(val sizes: Array[Int]) extends AbstractThings[collection.mutable.Queue]("mutable.Queue") {}
 
-  class WraThings(val sizes: Array[Int]) extends AbstractThings[collection.mutable.WrappedArray]("mutable.WrappedArray") {}
+  class AsqThings(val sizes: Array[Int]) extends AbstractThings[collection.mutable.ArraySeq]("mutable.ArraySeq") {}
 
   class JixThings(val sizes: Array[Int]) extends AbstractThings[java.util.ArrayList]("java.util.ArrayList") {}
 
@@ -279,7 +279,7 @@ package object generate {
     lazy val lhs = new LhsThings(sizes)
     lazy val prq = new PrqThings(sizes)
     lazy val muq = new MuqThings(sizes)
-    lazy val wra = new WraThings(sizes)
+    lazy val asq = new AsqThings(sizes)
     lazy val jix = new JixThings(sizes)
     lazy val jln = new JlnThings(sizes)
   }

benchmark/src/main/scala/bench/ParseJmhLog.scala

@@ -24,7 +24,7 @@ object ParseJmhLog {
     "stm" -> "collection.immutable.Stream",
     "trs" -> "collection.immutable.TreeSet",
     "vec" -> "collection.immutable.Vector",
-    "wra" -> "collection.mutable.WrappedArray",
+    "asq" -> "collection.mutable.ArraySeq",
     "jix" -> "java.util.ArrayList",
     "jln" -> "java.util.LinkedList"
   )

src/main/scala/scala/compat/java8/StreamConverters.scala

@@ -195,19 +195,19 @@ with converterImpl.Priority1AccumulatorConverters
     def parStream: LongStream = seqStream.parallel
   }
 
-  implicit final class EnrichDoubleWrappedArrayWithStream(private val a: collection.mutable.WrappedArray[Double])
+  implicit final class EnrichDoubleArraySeqWithStream(private val a: collection.mutable.ArraySeq[Double])
     extends AnyVal with MakesSequentialStream[Double, DoubleStream] with MakesParallelStream[Double, DoubleStream] {
     def seqStream: DoubleStream = java.util.Arrays.stream(a.array)
     def parStream: DoubleStream = seqStream.parallel
   }
 
-  implicit final class EnrichIntWrappedArrayWithStream(private val a: collection.mutable.WrappedArray[Int])
+  implicit final class EnrichIntArraySeqWithStream(private val a: collection.mutable.ArraySeq[Int])
     extends AnyVal with MakesSequentialStream[Int, IntStream] with MakesParallelStream[Int, IntStream] {
     def seqStream: IntStream = java.util.Arrays.stream(a.array)
     def parStream: IntStream = seqStream.parallel
   }
 
-  implicit final class EnrichLongWrappedArrayWithStream(private val a: collection.mutable.WrappedArray[Long])
+  implicit final class EnrichLongArraySeqWithStream(private val a: collection.mutable.ArraySeq[Long])
     extends AnyVal with MakesSequentialStream[Long, LongStream] with MakesParallelStream[Long, LongStream] {
     def seqStream: LongStream = java.util.Arrays.stream(a.array)
     def parStream: LongStream = seqStream.parallel

src/main/scala/scala/compat/java8/converterImpl/StepConverters.scala

@@ -16,7 +16,7 @@ trait Priority1StepConverters extends Priority2StepConverters {
   implicit def richDefaultHashMapCanStep[K, V](underlying: collection.mutable.HashMap[K, V]) = new RichHashMapCanStep[K, V](underlying)
   implicit def richLinkedHashMapCanStep[K, V](underlying: collection.mutable.LinkedHashMap[K, V]) = new RichLinkedHashMapCanStep[K, V](underlying)
   implicit def richArrayCanStep[A](underlying: Array[A]) = new RichArrayCanStep[A](underlying)
-  implicit def richWrappedArrayCanStep[A](underlying: collection.mutable.WrappedArray[A]) = new RichArrayCanStep[A](underlying.array)
+  implicit def richArraySeqCanStep[A](underlying: collection.mutable.ArraySeq[A]) = new RichArrayCanStep[A](underlying.array)
   implicit def richHashSetCanStep[A](underlying: collection.mutable.HashSet[A]) = new RichHashSetCanStep[A](underlying)
   implicit def richIteratorCanStep[A](underlying: Iterator[A]) = new RichIteratorCanStep(underlying)
   implicit def richImmHashMapCanStep[K, V](underlying: collection.immutable.HashMap[K, V]) = new RichImmHashMapCanStep[K, V](underlying)

src/test/scala/scala/compat/java8/StepConvertersTest.scala

@@ -153,7 +153,7 @@ class StepConvertersTest {
     Okay( cm.AnyRefMap[String,String]("fish" -> "salmon").keyStepper )
     Okay( cm.AnyRefMap[String,String]("fish" -> "salmon").valueStepper )
     good( cm.ArrayBuffer[String]("salmon").stepper )
-    good( (Array("salmon"): cm.WrappedArray[String]).stepper )
+    good( (Array("salmon"): cm.ArraySeq[String]).stepper )
     good( cm.ArraySeq[String]("salmon").stepper )
     _eh_( cm.ArrayStack[String]("salmon").stepper )
     Okay( (cm.ArrayBuffer[String]("salmon"): cm.Buffer[String]).stepper )
@@ -192,7 +192,6 @@ class StepConvertersTest {
     Okay( cm.WeakHashMap[String, String]("fish" -> "salmon").stepper )
     Okay( cm.WeakHashMap[String, String]("fish" -> "salmon").keyStepper )
     Okay( cm.WeakHashMap[String, String]("fish" -> "salmon").valueStepper )
-    good( (Array("salmon"): cm.WrappedArray[String]).stepper )
 
     // Java 6 converters section
 
@@ -272,7 +271,7 @@ class StepConvertersTest {
     Okay( (cm.HashSet[Double](3.14159): cm.AbstractSet[Double]).stepper )
     Okay( cm.AnyRefMap[String,Double]("fish" -> 3.14159).valueStepper )
     good( cm.ArrayBuffer[Double](3.14159).stepper )
-    good( (Array(3.14159): cm.WrappedArray[Double]).stepper )
+    good( (Array(3.14159): cm.ArraySeq[Double]).stepper )
     good( cm.ArraySeq[Double](3.14159).stepper )
     _eh_( cm.ArrayStack[Double](3.14159).stepper )
     Okay( (cm.ArrayBuffer[Double](3.14159): cm.Buffer[Double]).stepper )
@@ -304,7 +303,6 @@ class StepConvertersTest {
     Okay( cm.UnrolledBuffer[Double](3.14159).stepper )
     Okay( cm.WeakHashMap[Double, Double](2.718281828 -> 3.14159).keyStepper )
     Okay( cm.WeakHashMap[Double, Double](2.718281828 -> 3.14159).valueStepper )
-    good( (Array(3.14159): cm.WrappedArray[Double]).stepper )
 
     // Java 6 converters section
 
@@ -392,7 +390,7 @@ class StepConvertersTest {
     Okay( (cm.HashSet[Int](654321): cm.AbstractSet[Int]).stepper )
     Okay( cm.AnyRefMap[String, Int]("fish" -> 654321).valueStepper )
     good( cm.ArrayBuffer[Int](654321).stepper )
-    good( (Array(654321): cm.WrappedArray[Int]).stepper )
+    good( (Array(654321): cm.ArraySeq[Int]).stepper )
     good( cm.ArraySeq[Int](654321).stepper )
     _eh_( cm.ArrayStack[Int](654321).stepper )
     Okay( (cm.ArrayBuffer[Int](654321): cm.Buffer[Int]).stepper )
@@ -424,7 +422,6 @@ class StepConvertersTest {
     Okay( cm.UnrolledBuffer[Int](654321).stepper )
     Okay( cm.WeakHashMap[Int, Int](0xDEEDED -> 654321).keyStepper )
     Okay( cm.WeakHashMap[Int, Int](0xDEEDED -> 654321).valueStepper )
-    good( (Array(654321): cm.WrappedArray[Int]).stepper )
 
     // Java 6 converters section
 
@@ -440,12 +437,12 @@ class StepConvertersTest {
     implicit val spec = SpecCheck(_.isInstanceOf[IntStepper], x => s"$x should be an IntStepper")
 
     good( Array[Short](654321.toShort).stepper )
-    good( (Array[Short](654321.toShort): cm.WrappedArray[Short]).stepper )
+    good( (Array[Short](654321.toShort): cm.ArraySeq[Short]).stepper )
 
     //TODO: None of these currently work because there are no native Stepper implementations:
 
     //good( ci.NumericRange(123456.toShort, 123458.toShort, 1.toShort).stepper )
-    //good( ((Array[Short](654321.toShort): cm.WrappedArray[Short]): cm.ArrayLike[Short, cm.WrappedArray[Short]]).stepper )
+    //good( ((Array[Short](654321.toShort): cm.ArraySeq[Short]): cm.ArrayLike[Short, cm.ArraySeq[Short]]).stepper )
     //good( (Array[Short](654321.toShort): cm.ArrayOps[Short]).stepper )
     //good( cm.ResizableArray[Short](654321.toShort).stepper )
   }
@@ -526,7 +523,7 @@ class StepConvertersTest {
     Okay( (cm.HashSet[Long](0x123456789L): cm.AbstractSet[Long]).stepper )
     Okay( cm.AnyRefMap[String,Long]("fish" -> 0x123456789L).valueStepper )
     good( cm.ArrayBuffer[Long](0x123456789L).stepper )
-    good( (Array(0x123456789L): cm.WrappedArray[Long]).stepper )
+    good( (Array(0x123456789L): cm.ArraySeq[Long]).stepper )
     good( cm.ArraySeq[Long](0x123456789L).stepper )
     _eh_( cm.ArrayStack[Long](0x123456789L).stepper )
     Okay( (cm.ArrayBuffer[Long](0x123456789L): cm.Buffer[Long]).stepper )
@@ -559,7 +556,6 @@ class StepConvertersTest {
     Okay( cm.UnrolledBuffer[Long](0x123456789L).stepper )
     Okay( cm.WeakHashMap[Long, Long](1234567654321L -> 0x123456789L).keyStepper )
     Okay( cm.WeakHashMap[Long, Long](1234567654321L -> 0x123456789L).valueStepper )
-    good( (Array(0x123456789L): cm.WrappedArray[Long]).stepper )
 
     // Java 6 converters section
 

src/test/scala/scala/compat/java8/StreamConvertersTest.scala

@@ -111,15 +111,15 @@ class StreamConvertersTest {
     assert(newLongStream(1).boxed.unboxed.isInstanceOf[LongStream])
   }
 
-  import collection.mutable.{ ArrayBuffer, WrappedArray }
+  import collection.mutable.{ ArrayBuffer, ArraySeq }
   def abufO(n: Int) = { val ab = new ArrayBuffer[String]; arrayO(n).foreach(ab += _); ab }
   def abufD(n: Int) = { val ab = new ArrayBuffer[Double]; arrayD(n).foreach(ab += _); ab }
   def abufI(n: Int) = { val ab = new ArrayBuffer[Int]; arrayI(n).foreach(ab += _); ab }
   def abufL(n: Int) = { val ab = new ArrayBuffer[Long]; arrayL(n).foreach(ab += _); ab }
-  def wrapO(n: Int): WrappedArray[String] = arrayO(n)
-  def wrapD(n: Int): WrappedArray[Double] = arrayD(n)
-  def wrapI(n: Int): WrappedArray[Int] = arrayI(n)
-  def wrapL(n: Int): WrappedArray[Long] = arrayL(n)
+  def wrapO(n: Int): ArraySeq[String] = arrayO(n)
+  def wrapD(n: Int): ArraySeq[Double] = arrayD(n)
+  def wrapI(n: Int): ArraySeq[Int] = arrayI(n)
+  def wrapL(n: Int): ArraySeq[Long] = arrayL(n)
   def vectO(n: Int) = arrayO(n).toVector
   def vectD(n: Int) = arrayD(n).toVector
   def vectI(n: Int) = arrayI(n).toVector
@@ -257,10 +257,10 @@ class StreamConvertersTest {
 
   @Test
   def streamMaterialization(): Unit = {
-    val coll = collection.mutable.WrappedArray.make[Int](Array(1,2,3))
-    val streamize = implicitly[collection.mutable.WrappedArray[Int] => MakesSequentialStream[Int, IntStream]]
-    assertTrue(streamize(coll).getClass.getName.contains("EnrichIntWrappedArrayWithStream"))
-    val steppize = implicitly[collection.mutable.WrappedArray[Int] => MakesStepper[Int, Any]]
+    val coll = collection.mutable.ArraySeq.make[Int](Array(1,2,3))
+    val streamize = implicitly[collection.mutable.ArraySeq[Int] => MakesSequentialStream[Int, IntStream]]
+    assertTrue(streamize(coll).getClass.getName.contains("EnrichIntArraySeqWithStream"))
+    val steppize = implicitly[collection.mutable.ArraySeq[Int] => MakesStepper[Int, Any]]
     assertTrue(steppize(coll).getClass.getName.contains("RichArrayCanStep"))
     val stepper = steppize(coll).stepper
     assertTrue(stepper.getClass.getName.contains("StepsIntArray"))