Merge pull request #3274 from BalmungSan/chunk-as-seq

Chunk improvements

benchmark/src/main/scala/fs2/benchmark/ChunkBenchmark.scala

@@ -33,7 +33,7 @@ class ChunkBenchmark {
 
   @Setup
   def setup() =
-    ints = Chunk.seq((0 until chunkSize).map(_ + 1000)).compact
+    ints = Chunk.from((0 until chunkSize).map(_ + 1000)).compact
 
   @Benchmark
   def map(): Unit = {

benchmark/src/main/scala/fs2/benchmark/ChunksBenchmark.scala

@@ -45,9 +45,9 @@ class ChunksBenchmark {
 
   @Setup
   def setup() = {
-    chunkSeq = Seq.range(0, chunkCount).map(_ => Chunk.seq(Seq.fill(chunkSize)(Obj.create)))
+    chunkSeq = Seq.range(0, chunkCount).map(_ => Chunk.from(Seq.fill(chunkSize)(Obj.create)))
     sizeHint = chunkSeq.foldLeft(0)(_ + _.size)
-    flattened = Chunk.seq(chunkSeq).flatten
+    flattened = Chunk.from(chunkSeq).flatten
   }
 
   @Benchmark

benchmark/src/main/scala/fs2/benchmark/LinesBenchmark.scala

@@ -49,7 +49,7 @@ class LinesBenchmark {
           .grouped(chunkSize)
           .grouped(chunkSize)
           .foldLeft(Stream[IO, String]()) { case (acc, strings) =>
-            acc ++ Stream.chunk(Chunk.seq(strings))
+            acc ++ Stream.chunk(Chunk.from(strings))
           }
       }
 

benchmark/src/main/scala/fs2/benchmark/PullBenchmark.scala

@@ -34,7 +34,7 @@ class PullBenchmark {
   @Benchmark
   def unconsPull(): Int = {
     val s: Stream[Pure, Int] = Stream
-      .chunk(Chunk.seq(0 to 2560))
+      .chunk(Chunk.from(0 to 2560))
       .repeatPull { s =>
         s.unconsN(n).flatMap {
           case Some((h, t)) => Pull.output(h).as(Some(t))

build.sbt

@@ -215,6 +215,10 @@ ThisBuild / mimaBinaryIssueFilters ++= Seq(
   ),
   ProblemFilters.exclude[DirectMissingMethodProblem](
     "fs2.io.file.Watcher#DefaultWatcher.this"
+  ),
+  // Private internal method: #3274
+  ProblemFilters.exclude[DirectMissingMethodProblem](
+    "fs2.Chunk.platformIterable"
   )
 )
 

core/shared/src/main/scala-2.12/fs2/ChunkPlatform.scala

@@ -21,23 +21,67 @@
 
 package fs2
 
-import scala.collection.mutable.WrappedArray
+import scala.annotation.unchecked.uncheckedVariance
+import scala.collection.{Iterable => GIterable}
+import scala.collection.generic.{CanBuildFrom, GenericCompanion}
+import scala.collection.mutable.{Builder, WrappedArray}
 import scala.reflect.ClassTag
 
-private[fs2] trait ChunkPlatform[+O] { self: Chunk[O] => }
+private[fs2] trait ChunkPlatform[+O] {
+  self: Chunk[O] =>
 
-private[fs2] trait ChunkCompanionPlatform { self: Chunk.type =>
+  def asSeqPlatform: Option[IndexedSeq[O]] =
+    None
+}
+
+private[fs2] trait ChunkAsSeqPlatform[+O] {
+  self: ChunkAsSeq[O] =>
+
+  override val hasDefiniteSize: Boolean =
+    true
+
+  override def copyToArray[O2 >: O](xs: Array[O2], start: Int, len: Int): Unit =
+    chunk.take(len).copyToArray(xs, start)
+
+  override def map[O2, That](f: O ⇒ O2)(implicit bf: CanBuildFrom[IndexedSeq[O], O2, That]): That =
+    new ChunkAsSeq(chunk.map(f)).asInstanceOf[That]
+
+  override def zipWithIndex[O2 >: O, That](implicit
+      bf: CanBuildFrom[IndexedSeq[O], (O2, Int), That]
+  ): That =
+    new ChunkAsSeq(chunk.zipWithIndex).asInstanceOf[That]
 
-  protected def platformIterable[O](i: Iterable[O]): Option[Chunk[O]] =
+  override def to[Col[_]](implicit
+      cbf: CanBuildFrom[Nothing, O, Col[O @uncheckedVariance]]
+  ): Col[O @uncheckedVariance] =
+    chunk.to(cbf)
+
+  override def genericBuilder[B]: Builder[B, IndexedSeq[B]] =
+    Vector.newBuilder
+
+  override def companion: GenericCompanion[IndexedSeq] =
+    Vector
+}
+
+private[fs2] trait ChunkCompanionPlatform {
+  self: Chunk.type =>
+
+  protected def platformFrom[O](i: GIterable[O]): Option[Chunk[O]] =
     i match {
-      case a: WrappedArray[O] => Some(wrappedArray(a))
-      case _                  => None
+      case wrappedArray: WrappedArray[O] =>
+        val arr = wrappedArray.array.asInstanceOf[Array[O]]
+        Some(array(arr)(ClassTag(arr.getClass.getComponentType)))
+
+      case _ =>
+        None
     }
 
   /** Creates a chunk backed by a `WrappedArray`
     */
-  def wrappedArray[O](wrappedArray: WrappedArray[O]): Chunk[O] = {
-    val arr = wrappedArray.array.asInstanceOf[Array[O]]
-    array(arr)(ClassTag(arr.getClass.getComponentType))
-  }
+  @deprecated(
+    "Use the `from` general factory instead",
+    "3.8.1"
+  )
+  def wrappedArray[O](wrappedArray: WrappedArray[O]): Chunk[O] =
+    from(wrappedArray)
 }

core/shared/src/main/scala-2.13+/fs2/Chunk213And3Compat.scala

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2013 Functional Streams for Scala
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+package fs2
+
+import scala.collection.{Iterable => GIterable, Factory, SeqFactory}
+import scala.collection.immutable.ArraySeq
+import scala.reflect.ClassTag
+
+private[fs2] trait Chunk213And3Compat[+O] {
+  self: Chunk[O] =>
+
+  def toArraySeq[O2 >: O: ClassTag]: ArraySeq[O2] = {
+    val array: Array[O2] = new Array[O2](size)
+    copyToArray(array)
+    ArraySeq.unsafeWrapArray[O2](array)
+  }
+
+  def toArraySeqUntagged: ArraySeq[O] = {
+    val buf = ArraySeq.untagged.newBuilder[O]
+    buf.sizeHint(size)
+    var i = 0
+    while (i < size) {
+      buf += apply(i)
+      i += 1
+    }
+    buf.result()
+  }
+}
+
+private[fs2] trait ChunkAsSeq213And3Compat[+O] {
+  self: ChunkAsSeq[O] =>
+
+  override def knownSize: Int =
+    chunk.size
+
+  override def copyToArray[O2 >: O](xs: Array[O2], start: Int, len: Int): Int = {
+    chunk.take(len).copyToArray(xs, start)
+    math.min(len, xs.length - start)
+  }
+
+  override def map[O2](f: O => O2): IndexedSeq[O2] =
+    new ChunkAsSeq(chunk.map(f))
+
+  override def zipWithIndex: IndexedSeq[(O, Int)] =
+    new ChunkAsSeq(chunk.zipWithIndex)
+
+  override def tapEach[U](f: O => U): IndexedSeq[O] = {
+    chunk.foreach { o => f(o); () }
+    this
+  }
+
+  override def to[C1](factory: Factory[O, C1]): C1 =
+    chunk.to(factory)
+
+  override val iterableFactory: SeqFactory[IndexedSeq] =
+    ArraySeq.untagged
+
+  override lazy val empty: IndexedSeq[O] =
+    new ChunkAsSeq(Chunk.empty)
+}
+
+private[fs2] trait ChunkCompanion213And3Compat {
+  self: Chunk.type =>
+
+  protected def platformFrom[O](i: GIterable[O]): Option[Chunk[O]] =
+    i match {
+      case arraySeq: ArraySeq[O] =>
+        val arr = arraySeq.unsafeArray.asInstanceOf[Array[O]]
+        Some(array(arr)(ClassTag[O](arr.getClass.getComponentType)))
+
+      case _ =>
+        None
+    }
+
+  /** Creates a chunk backed by an immutable `ArraySeq`. */
+  @deprecated(
+    "Use the `from` general factory instead",
+    "3.8.1"
+  )
+  def arraySeq[O](arraySeq: ArraySeq[O]): Chunk[O] =
+    from(arraySeq)
+
+  /** Creates a chunk from a `scala.collection.IterableOnce`. */
+  def iterableOnce[O](i: IterableOnce[O]): Chunk[O] =
+    iterator(i.iterator)
+}

core/shared/src/main/scala-2.13/fs2/ChunkPlatform.scala

@@ -22,45 +22,31 @@
 package fs2
 
 import scala.collection.immutable.ArraySeq
-import scala.collection.immutable
-import scala.reflect.ClassTag
 
-private[fs2] trait ChunkPlatform[+O] { self: Chunk[O] =>
-
-  def toArraySeq[O2 >: O: ClassTag]: ArraySeq[O2] = {
-    val array: Array[O2] = new Array[O2](size)
-    copyToArray(array)
-    ArraySeq.unsafeWrapArray[O2](array)
-  }
-
-  def toArraySeqUntagged: ArraySeq[O] = {
-    val buf = ArraySeq.untagged.newBuilder[O]
-    buf.sizeHint(size)
-    var i = 0
-    while (i < size) {
-      buf += apply(i)
-      i += 1
+private[fs2] trait ChunkPlatform[+O] extends Chunk213And3Compat[O] {
+  self: Chunk[O] =>
+
+  def asSeqPlatform: Option[IndexedSeq[O]] =
+    this match {
+      case arraySlice: Chunk.ArraySlice[_] =>
+        Some(
+          ArraySeq
+            .unsafeWrapArray(arraySlice.values)
+            .slice(
+              from = arraySlice.offset,
+              until = arraySlice.offset + arraySlice.length
+            )
+        )
+
+      case _ =>
+        None
     }
-    buf.result()
-  }
 }
 
-private[fs2] trait ChunkCompanionPlatform { self: Chunk.type =>
-
-  protected def platformIterable[O](i: Iterable[O]): Option[Chunk[O]] =
-    i match {
-      case a: immutable.ArraySeq[O] => Some(arraySeq(a))
-      case _                        => None
-    }
-
-  /** Creates a chunk backed by an immutable `ArraySeq`.
-    */
-  def arraySeq[O](arraySeq: immutable.ArraySeq[O]): Chunk[O] = {
-    val arr = arraySeq.unsafeArray.asInstanceOf[Array[O]]
-    array(arr)(ClassTag[O](arr.getClass.getComponentType))
-  }
+private[fs2] trait ChunkAsSeqPlatform[+O] extends ChunkAsSeq213And3Compat[O] {
+  self: ChunkAsSeq[O] =>
+}
 
-  /** Creates a chunk from a `scala.collection.IterableOnce`. */
-  def iterableOnce[O](i: collection.IterableOnce[O]): Chunk[O] =
-    iterator(i.iterator)
+private[fs2] trait ChunkCompanionPlatform extends ChunkCompanion213And3Compat {
+  self: Chunk.type =>
 }