Cross-compatible breakOut for specific collections like SortedMap

Author: MasseGuillaume

compat/src/main/scala-2.11_2.12/scala/collection/compat/package.scala

@@ -65,6 +65,84 @@ package object compat {
     def iterator: Iterator[A] = self.toIterator
   }
 
+  implicit class TraversableOnceKVExtensionMethods[K, V](private val self: TraversableOnce[(K, V)]) extends AnyVal {
+    def toImmutableSortedMap(implicit ordering: Ordering[K]): i.SortedMap[K, V] = {
+      val b = i.SortedMap.canBuildFrom[K, V](ordering)()
+      b ++= self
+      b.result()
+    }
+
+    def toImmutableHashMap: i.HashMap[K, V] = {
+      val b = i.HashMap.canBuildFrom[K, V]()
+      b ++= self
+      b.result()
+    }
+
+    def toImmutableListMap: i.ListMap[K, V] = {
+      val b = i.ListMap.canBuildFrom[K, V]()
+      b ++= self
+      b.result()
+    }
+
+    def toImmutableTreeMap(implicit ordering: Ordering[K]): i.TreeMap[K, V] = {
+      val b = i.TreeMap.canBuildFrom[K, V](ordering)()
+      b ++= self
+      b.result()
+    }
+
+    def toMutableSortedMap(implicit ordering: Ordering[K]): m.SortedMap[K, V] = {
+      val b = m.SortedMap.canBuildFrom[K, V](ordering)()
+      b ++= self
+      b.result()
+    }
+
+    def toMutableHashMap: m.HashMap[K, V] = {
+      val b = m.HashMap.canBuildFrom[K, V]()
+      b ++= self
+      b.result()
+    }
+
+    def toMutableListMap: m.ListMap[K, V] = {
+      val b = m.ListMap.canBuildFrom[K, V]()
+      b ++= self
+      b.result()
+    }
+
+    def toMutableTreeMap(implicit ordering: Ordering[K]): m.TreeMap[K, V] = {
+      val b = m.TreeMap.canBuildFrom[K, V](ordering)()
+      b ++= self
+      b.result()
+    }
+
+    def toMutableMap: m.Map[K, V] = {
+      val b = m.Map.canBuildFrom[K, V]()
+      b ++= self
+      b.result()
+    }
+  }
+
+  implicit class TraversableOnceIntVExtensionMethods[V](private val self: TraversableOnce[(Int, V)]) extends AnyVal {
+    def toImmutableIntMap: i.IntMap[V] = {
+      val b = i.IntMap.canBuildFrom[Int, V]()
+      b ++= self
+      b.result()
+    }
+  }
+
+  implicit class TraversableOnceLongVExtensionMethods[V](private val self: TraversableOnce[(Long, V)]) extends AnyVal {
+    def toImmutableLongMap: i.LongMap[V] = {
+      val b = i.LongMap.canBuildFrom[Long, V]()
+      b ++= self
+      b.result()
+    }
+
+    def toMutableLongMap: m.LongMap[V] = {
+      val b = m.LongMap.canBuildFrom[Long, V]()
+      b ++= self
+      b.result()
+    }
+  }
+
   // This really belongs into scala.collection but there's already a package object in scala-library so we can't add to it
   type IterableOnce[+X] = TraversableOnce[X]
   val  IterableOnce     = TraversableOnce

compat/src/main/scala-2.13/scala/collection/compat/package.scala

@@ -1,5 +1,7 @@
 package scala.collection
 
+import scala.collection.{immutable => i, mutable => m}
+
 package object compat {
   type Factory[-A, +C] = scala.collection.Factory[A, C]
   val  Factory         = scala.collection.Factory
@@ -9,4 +11,46 @@ package object compat {
 
   type IterableOnce[+X] = scala.collection.IterableOnce[X]
   val  IterableOnce     = scala.collection.IterableOnce
+
+  implicit class TraversableOnceKVExtensionMethods[K, V](private val self: IterableOnce[(K, V)]) extends AnyVal {
+    def toImmutableSortedMap(implicit ordering: Ordering[K]): i.SortedMap[K, V] =
+      i.SortedMap.from(self)
+
+    def toImmutableHashMap: i.HashMap[K, V] =
+      i.HashMap.from(self)
+
+    def toImmutableListMap: i.ListMap[K, V] =
+      i.ListMap.from(self)
+
+    def toImmutableTreeMap(implicit ordering: Ordering[K]): i.TreeMap[K, V] =
+      i.TreeMap.from(self)
+
+    def toMutableSortedMap(implicit ordering: Ordering[K]): m.SortedMap[K, V] =
+      m.SortedMap.from(self)
+
+    def toMutableHashMap: m.HashMap[K, V] =
+      m.HashMap.from(self)
+
+    def toMutableListMap: m.ListMap[K, V] =
+      m.ListMap.from(self)
+
+    def toMutableTreeMap(implicit ordering: Ordering[K]): m.TreeMap[K, V] =
+      m.TreeMap.from(self)
+
+    def toMutableMap: m.Map[K, V] =
+      m.Map.from(self)
+  }
+
+  implicit class TraversableOnceIntVExtensionMethods[V](private val self: TraversableOnce[(Int, V)]) extends AnyVal {
+    def toImmutableIntMap: i.IntMap[V] =
+      i.IntMap.from(self)
+  }
+
+  implicit class TraversableOnceLongVExtensionMethods[V](private val self: TraversableOnce[(Long, V)]) extends AnyVal {
+    def toImmutableLongMap: i.LongMap[V] =
+      i.LongMap.from(self)
+
+    def toMutableLongMap: m.LongMap[V] =
+      m.LongMap.from(self)
+  }
 }

scalafix/input/src/main/scala/fix/BreakoutSrc.scala

@@ -34,7 +34,6 @@ class BreakoutSrc(ts: Traversable[Int], vec: Vector[Int], list: List[Int], seq:
   // `List.map`
   list.map(x => x)(breakOut): Set[Int]
 
-
   // `SeqLike.reverseMap`
   seq.reverseMap(_ + 1)(breakOut): Set[Int]
 
@@ -86,6 +85,24 @@ class BreakoutSrc(ts: Traversable[Int], vec: Vector[Int], list: List[Int], seq:
   // `Vector.updated`
   (vec.updated(0, 0))(breakOut): List[Int]
 
+  // Future
   Future.sequence(List(Future(1)))(breakOut, global): Future[Seq[Int]]
   Future.traverse(List(1))(x => Future(x))(breakOut, global): Future[Seq[Int]]
+
+  // Iterable
+  List(1).map(x => x)(breakOut): Iterator[Int]
+
+  // Specific collections
+  List(1 -> "1").map(x => x)(breakOut): immutable.SortedMap[Int, String]
+  List(1 -> "1").map(x => x)(breakOut): immutable.HashMap[Int, String]
+  List(1 -> "1").map(x => x)(breakOut): immutable.ListMap[Int, String]
+  List(1 -> "1").map(x => x)(breakOut): immutable.TreeMap[Int, String]
+  List(1 -> "1").map(x => x)(breakOut): mutable.SortedMap[Int, String]
+  List(1 -> "1").map(x => x)(breakOut): mutable.HashMap[Int, String]
+  List(1 -> "1").map(x => x)(breakOut): mutable.ListMap[Int, String]
+  List(1 -> "1").map(x => x)(breakOut): mutable.TreeMap[Int, String]
+  List(1 -> "1").map(x => x)(breakOut): mutable.Map[Int, String]
+  List(1 -> "1").map(x => x)(breakOut): immutable.IntMap[String]
+  List(1L -> "1").map(x => x)(breakOut): immutable.LongMap[String]
+  List(1L -> "1").map(x => x)(breakOut): mutable.LongMap[String]
 }

scalafix/output212/src/main/scala/fix/BreakoutSrc.scala

@@ -34,7 +34,6 @@ class BreakoutSrc(ts: Iterable[Int], vec: Vector[Int], list: List[Int], seq: Seq
   // `List.map`
   list.iterator.map(x => x).to(scala.collection.immutable.Set): Set[Int]
 
-
   // `SeqLike.reverseMap`
   seq.reverseIterator.map(_ + 1).to(scala.collection.immutable.Set): Set[Int]
 
@@ -86,6 +85,24 @@ class BreakoutSrc(ts: Iterable[Int], vec: Vector[Int], list: List[Int], seq: Seq
   // `Vector.updated`
   (vec.view.updated(0, 0)).to(scala.collection.immutable.List): List[Int]
 
+  // Future
   Future.sequence(List(Future(1)))(scala.collection.immutable.List, global): Future[Seq[Int]]
   Future.traverse(List(1))(x => Future(x))(scala.collection.immutable.List, global): Future[Seq[Int]]
+
+  // Iterable
+  List(1).iterator.map(x => x): Iterator[Int]
+
+  // Specific collections
+  List(1 -> "1").iterator.map(x => x).toImmutableSortedMap: immutable.SortedMap[Int, String]
+  List(1 -> "1").iterator.map(x => x).toImmutableHashMap: immutable.HashMap[Int, String]
+  List(1 -> "1").iterator.map(x => x).toImmutableListMap: immutable.ListMap[Int, String]
+  List(1 -> "1").iterator.map(x => x).toImmutableTreeMap: immutable.TreeMap[Int, String]
+  List(1 -> "1").iterator.map(x => x).toMutableSortedMap: mutable.SortedMap[Int, String]
+  List(1 -> "1").iterator.map(x => x).toMutableHashMap: mutable.HashMap[Int, String]
+  List(1 -> "1").iterator.map(x => x).toMutableListMap: mutable.ListMap[Int, String]
+  List(1 -> "1").iterator.map(x => x).toMutableTreeMap: mutable.TreeMap[Int, String]
+  List(1 -> "1").iterator.map(x => x).toMutableMap: mutable.Map[Int, String]
+  List(1 -> "1").iterator.map(x => x).toImmutableIntMap: immutable.IntMap[String]
+  List(1L -> "1").iterator.map(x => x).toImmutableLongMap: immutable.LongMap[String]
+  List(1L -> "1").iterator.map(x => x).toMutableLongMap: mutable.LongMap[String]
 }