Add an iterator() alias to iterator

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

@@ -33,21 +33,37 @@ package object compat {
     simpleCBF(fact.newBuilder)
 
   implicit class IterableFactoryExtensionMethods[CC[X] <: GenTraversable[X]](private val fact: GenericCompanion[CC]) {
-    def from[A](source: TraversableOnce[A]): CC[A] = fact.apply(source.toSeq: _*)
+    def from[A](source: TraversableOnce[A]): CC[A] = (fact.newBuilder[A] ++= source).result()
   }
 
   implicit class MapFactoryExtensionMethods[CC[A, B] <: Map[A, B] with MapLike[A, B, CC[A, B]]](private val fact: MapFactory[CC]) {
-    def from[K, V](source: TraversableOnce[(K, V)]): CC[K, V] = fact.apply(source.toSeq: _*)
+    def from[K, V](source: TraversableOnce[(K, V)]): CC[K, V] = (fact.newBuilder[K, V] ++= source).result()
+  }
+
+  implicit class SortedMapFactoryExtensionMethods[CC[A, B] <: SortedMap[A, B] with SortedMapLike[A, B, CC[A, B]]](private val fact: SortedMapFactory[CC]) extends AnyVal {
+    def from[K : Ordering, V](source: TraversableOnce[(K, V)]): CC[K, V] = (fact.newBuilder[K, V] ++= source).result()
   }
 
   implicit class BitSetFactoryExtensionMethods[C <: scala.collection.BitSet with scala.collection.BitSetLike[C]](private val fact: BitSetFactory[C]) {
-    def fromSpecific(source: TraversableOnce[Int]): C = fact.apply(source.toSeq: _*)
+    def fromSpecific(source: TraversableOnce[Int]): C = (fact.newBuilder ++= source).result()
+  }
+
+  implicit class SortedSetFactoryExtensionMethods[CC[X] <: SortedSet[X] with SortedSetLike[X, CC[X]]](private val fact: SortedSetFactory[CC]) extends AnyVal {
+    def from[A : Ordering](source: TraversableOnce[A]): CC[A] = (fact.newBuilder[A] ++= source).result()
   }
 
   implicit class StreamExtensionMethods[A](private val stream: Stream[A]) extends AnyVal {
     def lazyAppendAll(as: => TraversableOnce[A]): Stream[A] = stream.append(as)
   }
 
+  implicit class IterableExtensionMethods[A](private val as: IterableLike[A, _]) extends AnyVal {
+    def iterator(): Iterator[A] = as.iterator
+  }
+
+  implicit class BuilderExtensionMethods[Elem, To](val builder: Builder[Elem, To]) extends AnyVal {
+    def apply(): builder.type = builder
+  }
+
   // 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]
 }

src/test/scala/collection/CollectionTest.scala

@@ -5,7 +5,7 @@ import java.util
 import org.junit.Test
 import org.junit.Assert._
 
-import scala.collection.immutable.BitSet
+import scala.collection.immutable.{BitSet, TreeMap, TreeSet}
 import scala.collection.compat._
 
 class CollectionTest {
@@ -47,5 +47,25 @@ class CollectionTest {
     val m = Map.from(ys)
     val mT: Map[Int, String] = m
     assertEquals(Map(1 -> "a", 2 -> "b"), m)
+
+    val ts = TreeSet.from(xs)
+    val tsT: TreeSet[Int] = ts
+    assertEquals(TreeSet(1, 2, 3), ts)
+
+    val tm = TreeMap.from(ys)
+    val tmT: TreeMap[Int, String] = tm
+    assertEquals(TreeMap(1 -> "a", 2 -> "b"), tm)
+  }
+
+  @Test
+  def testNewBuilder(): Unit = {
+    List.newBuilder[Int]()
+    Vector.newBuilder[String]()
+    Map.newBuilder[Int, String]()
+    BitSet.newBuilder()
+    // The following cases don’t work because the `newBuilder` method takes implicit parameters
+    // Array.newBuilder[Int]()
+    // TreeSet.newBuilder[Int]()
+    // TreeMap.newBuilder[Int, String]()
   }
 }

src/test/scala/collection/FactoryTest.scala

@@ -28,4 +28,12 @@ class FactoryTest {
     Assert.assertEquals(1, counter) // One element has been evaluated because Stream is not lazy in its head
   }
 
+  @Test
+  def streamFromPreservesLaziness(): Unit = {
+    var counter = 0
+    val source = Stream.continually { counter += 1; 1 }
+    val result = Stream.from(source)
+    Assert.assertEquals(1, counter) // One element has been evaluated because Stream is not lazy in its head
+  }
+
 }

src/test/scala/collection/IterableLikeTest.scala

@@ -0,0 +1,14 @@
+package collection
+
+import org.junit.Test
+
+import scala.collection.compat._
+
+class IterableLikeTest {
+
+  @Test
+  def iteratorTest(): Unit = {
+    List(1, 2, 3).iterator()
+  }
+
+}