Add support for collecting elements to a SortedSet or SortedMap

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

@@ -25,9 +25,11 @@ import scala.collection.generic.{
   GenericTraversableTemplate,
   MapFactory,
   SetFactory,
+  SortedMapFactory,
+  SortedSetFactory,
   TraversableFactory
 }
-import scala.collection.{MapLike, SetLike, Traversable}
+import scala.collection.{MapLike, SetLike, SortedMapLike, SortedSetLike, Traversable}
 
 import fs2.internal._
 
@@ -52,11 +54,31 @@ private[fs2] trait CollectorPlatform { self: Collector.type =>
   ): Collector.Aux[(K, V), C[K, V]] =
     make(Builder.fromMapFactory(f))
 
+  implicit def supportsSortedMapFactory[
+      K: Ordering,
+      V,
+      C[a, b] <: collection.SortedMap[a, b] with SortedMapLike[
+        a,
+        b,
+        C[a, b]
+      ]
+  ](
+      f: SortedMapFactory[C]
+  ): Collector.Aux[(K, V), C[K, V]] =
+    make(Builder.fromSortedMapFactory(f))
+
   implicit def supportsSetFactory[A, C[x] <: Set[x] with SetLike[x, C[x]]](
       f: SetFactory[C]
   ): Collector.Aux[A, C[A]] =
     make(Builder.fromSetFactory(f))
 
+  implicit def supportsSortedSetFactory[A: Ordering, C[x] <: collection.SortedSet[
+    x
+  ] with SortedSetLike[x, C[x]]](
+      f: SortedSetFactory[C]
+  ): Collector.Aux[A, C[A]] =
+    make(Builder.fromSortedSetFactory(f))
+
   private[fs2] trait BuilderPlatform { self: Collector.Builder.type =>
     def fromFactory[A, C[_], B](f: Factory[A, C[B]]): Builder[A, C[B]] =
       fromBuilder(f())
@@ -71,9 +93,25 @@ private[fs2] trait CollectorPlatform { self: Collector.type =>
     ): Builder[(K, V), C[K, V]] =
       fromBuilder(f.newBuilder)
 
+    def fromSortedMapFactory[
+        K: Ordering,
+        V,
+        C[a, b] <: collection.SortedMap[a, b] with SortedMapLike[a, b, C[a, b]]
+    ](
+        f: SortedMapFactory[C]
+    ): Builder[(K, V), C[K, V]] =
+      fromBuilder(f.newBuilder)
+
     def fromSetFactory[A, C[x] <: collection.Set[x] with SetLike[x, C[x]]](
         f: SetFactory[C]
     ): Builder[A, C[A]] =
       fromBuilder(f.newBuilder)
+
+    def fromSortedSetFactory[A: Ordering, C[x] <: collection.SortedSet[x] with SortedSetLike[x, C[
+      x
+    ]]](
+        f: SortedSetFactory[C]
+    ): Builder[A, C[A]] =
+      fromBuilder(f.newBuilder)
   }
 }

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

@@ -22,7 +22,13 @@
 package fs2
 
 import scala.collection.immutable.ArraySeq
-import scala.collection.{Factory, IterableFactory, MapFactory}
+import scala.collection.{
+  Factory,
+  EvidenceIterableFactory,
+  IterableFactory,
+  MapFactory,
+  SortedMapFactory
+}
 import scala.reflect.ClassTag
 
 private[fs2] trait CollectorPlatform { self: Collector.type =>
@@ -38,6 +44,16 @@ private[fs2] trait CollectorPlatform { self: Collector.type =>
   implicit def supportsMapFactory[K, V, C[_, _]](f: MapFactory[C]): Collector.Aux[(K, V), C[K, V]] =
     make(Builder.fromMapFactory(f))
 
+  implicit def supportsSortedMapFactory[K: Ordering, V, C[_, _]](
+      f: SortedMapFactory[C]
+  ): Collector.Aux[(K, V), C[K, V]] =
+    make(Builder.fromSortedMapFactory(f))
+
+  implicit def supportsEvidenceIterableFactory[A, C[_], E[_]](f: EvidenceIterableFactory[C, E])(
+      implicit ev: E[A]
+  ): Collector.Aux[A, C[A]] =
+    make(Builder.fromEvidenceIterableFactory(f))
+
   /** Use `ArraySeq.untagged` to build a `Collector` where a `ClassTag` is not available.
     */
   implicit def supportsTaggedArraySeq[A: ClassTag](
@@ -64,6 +80,16 @@ private[fs2] trait CollectorPlatform { self: Collector.type =>
     def fromMapFactory[K, V, C[_, _]](f: MapFactory[C]): Builder[(K, V), C[K, V]] =
       fromBuilder(f.newBuilder)
 
+    def fromSortedMapFactory[K: Ordering, V, C[_, _]](
+        f: SortedMapFactory[C]
+    ): Builder[(K, V), C[K, V]] =
+      fromBuilder(f.newBuilder)
+
+    def fromEvidenceIterableFactory[A, C[_], E[_]](f: EvidenceIterableFactory[C, E])(implicit
+        ev: E[A]
+    ): Builder[A, C[A]] =
+      fromBuilder(f.newBuilder)
+
     def taggedArraySeq[A: ClassTag]: Builder[A, ArraySeq[A]] =
       array[A].mapResult(ArraySeq.unsafeWrapArray)
   }

core/shared/src/main/scala-3/fs2/CollectorPlatform.scala

@@ -22,7 +22,13 @@
 package fs2
 
 import scala.collection.immutable.ArraySeq
-import scala.collection.{Factory, IterableFactory, MapFactory}
+import scala.collection.{
+  Factory,
+  EvidenceIterableFactory,
+  IterableFactory,
+  MapFactory,
+  SortedMapFactory
+}
 import scala.reflect.ClassTag
 
 private[fs2] trait CollectorPlatform { self: Collector.type =>
@@ -38,6 +44,16 @@ private[fs2] trait CollectorPlatform { self: Collector.type =>
   implicit def supportsMapFactory[K, V, C[_, _]](f: MapFactory[C]): Collector.Aux[(K, V), C[K, V]] =
     make(Builder.fromMapFactory(f))
 
+  implicit def supportsSortedMapFactory[K: Ordering, V, C[_, _]](
+      f: SortedMapFactory[C]
+  ): Collector.Aux[(K, V), C[K, V]] =
+    make(Builder.fromSortedMapFactory(f))
+
+  implicit def supportsEvidenceIterableFactory[A, C[_], E[_]](f: EvidenceIterableFactory[C, E])(
+      implicit ev: E[A]
+  ): Collector.Aux[A, C[A]] =
+    make(Builder.fromEvidenceIterableFactory(f))
+
   /** Use `ArraySeq.untagged` to build a `Collector` where a `ClassTag` is not available.
     */
   implicit def supportsTaggedArraySeq[A: ClassTag](
@@ -72,6 +88,16 @@ private[fs2] trait CollectorPlatform { self: Collector.type =>
     def fromMapFactory[K, V, C[_, _]](f: MapFactory[C]): Builder[(K, V), C[K, V]] =
       fromBuilder(f.newBuilder)
 
+    def fromSortedMapFactory[K: Ordering, V, C[_, _]](
+        f: SortedMapFactory[C]
+    ): Builder[(K, V), C[K, V]] =
+      fromBuilder(f.newBuilder)
+
+    def fromEvidenceIterableFactory[A, C[_], E[_]](f: EvidenceIterableFactory[C, E])(implicit
+        ev: E[A]
+    ): Builder[A, C[A]] =
+      fromBuilder(f.newBuilder)
+
     def taggedArraySeq[A: ClassTag]: Builder[A, ArraySeq[A]] =
       array[A].mapResult(ArraySeq.unsafeWrapArray)
   }

core/shared/src/test/scala/fs2/CompilationTest.scala

@@ -120,4 +120,8 @@ object ThisModuleShouldCompile {
   Stream(1, 2, 3).compile.to(Set)
   Stream(1, 2, 3).to(List)
   Stream(1, 2, 3).covary[Fallible].to(List)
+  Stream(1, 2, 3).to(Set)
+  Stream(1, 2, 3).to(collection.immutable.SortedSet)
+  Stream(1 -> 1, 2 -> 2, 3 -> 3).to(Map)
+  Stream(1 -> 1, 2 -> 2, 3 -> 3).to(collection.immutable.SortedMap)
 }