Use “sorted” everywhere, for consistency

Author: julienrf

src/main/scala/strawman/collection/Factories.scala

@@ -74,54 +74,54 @@ object MapFactory {
 }
 
 /** Base trait for companion objects of collections that require an implicit evidence */
-trait OrderedIterableFactory[+CC[_]] {
+trait SortedIterableFactory[+CC[_]] {
 
-  def orderedFromIterable[E : Ordering](it: Iterable[E]): CC[E]
+  def sortedFromIterable[E : Ordering](it: Iterable[E]): CC[E]
 
   def empty[A : Ordering]: CC[A]
 
-  def apply[A : Ordering](xs: A*): CC[A] = orderedFromIterable(View.Elems(xs: _*))
+  def apply[A : Ordering](xs: A*): CC[A] = sortedFromIterable(View.Elems(xs: _*))
 
-  def fill[A : Ordering](n: Int)(elem: => A): CC[A] = orderedFromIterable(View.Fill(n)(elem))
+  def fill[A : Ordering](n: Int)(elem: => A): CC[A] = sortedFromIterable(View.Fill(n)(elem))
 }
 
-object OrderedIterableFactory {
+object SortedIterableFactory {
   import scala.language.implicitConversions
 
-  implicit def toSpecific[A: Ordering, CC[_]](factory: OrderedIterableFactory[CC]): FromSpecificIterable[A, CC[A]] =
+  implicit def toSpecific[A: Ordering, CC[_]](factory: SortedIterableFactory[CC]): FromSpecificIterable[A, CC[A]] =
     new FromSpecificIterable[A, CC[A]] {
-      def fromSpecificIterable(it: Iterable[A]): CC[A] = factory.orderedFromIterable[A](it)
+      def fromSpecificIterable(it: Iterable[A]): CC[A] = factory.sortedFromIterable[A](it)
     }
 
-  class Delegate[CC[_]](delegate: OrderedIterableFactory[CC]) extends OrderedIterableFactory[CC] {
+  class Delegate[CC[_]](delegate: SortedIterableFactory[CC]) extends SortedIterableFactory[CC] {
     def empty[A : Ordering]: CC[A] = delegate.empty
-    def orderedFromIterable[E : Ordering](it: Iterable[E]): CC[E] = delegate.orderedFromIterable(it)
+    def sortedFromIterable[E : Ordering](it: Iterable[E]): CC[E] = delegate.sortedFromIterable(it)
   }
 
 }
 
 /** Factory methods for collections of kind `* −> * -> *` which require an implicit evidence value for the key type */
-trait OrderedMapFactory[+CC[X, Y]] {
+trait SortedMapFactory[+CC[X, Y]] {
 
   def empty[K : Ordering, V]: CC[K, V]
 
-  def orderedFromIterable[K : Ordering, V](it: Iterable[(K, V)]): CC[K, V]
+  def sortedFromIterable[K : Ordering, V](it: Iterable[(K, V)]): CC[K, V]
 
   def apply[K : Ordering, V](elems: (K, V)*): CC[K, V] =
-    orderedFromIterable(elems.toStrawman)
+    sortedFromIterable(elems.toStrawman)
 }
 
-object OrderedMapFactory {
+object SortedMapFactory {
   import scala.language.implicitConversions
 
-  implicit def toSpecific[K : Ordering, V, CC[_, _]](factory: OrderedMapFactory[CC]): FromSpecificIterable[(K, V), CC[K, V]] =
+  implicit def toSpecific[K : Ordering, V, CC[_, _]](factory: SortedMapFactory[CC]): FromSpecificIterable[(K, V), CC[K, V]] =
     new FromSpecificIterable[(K, V), CC[K, V]] {
-      def fromSpecificIterable(it: Iterable[(K, V)]): CC[K, V] = factory.orderedFromIterable(it)
+      def fromSpecificIterable(it: Iterable[(K, V)]): CC[K, V] = factory.sortedFromIterable(it)
     }
 
-  class Delegate[CC[_, _]](delegate: OrderedMapFactory[CC]) extends OrderedMapFactory[CC] {
+  class Delegate[CC[_, _]](delegate: SortedMapFactory[CC]) extends SortedMapFactory[CC] {
     def empty[K: Ordering, V]: CC[K, V] = delegate.empty[K, V]
-    def orderedFromIterable[K: Ordering, V](it: Iterable[(K, V)]): CC[K, V] = delegate.orderedFromIterable(it)
+    def sortedFromIterable[K: Ordering, V](it: Iterable[(K, V)]): CC[K, V] = delegate.sortedFromIterable(it)
   }
 
 }

src/main/scala/strawman/collection/SortedMap.scala

@@ -14,20 +14,20 @@ trait SortedMapOps[K, +V, +CC[X, Y] <: SortedMap[X, Y] with SortedMapOps[X, Y, C
   extends MapOps[K, V, Map, C]
      with SortedOps[K, C] {
 
-  protected[this] def orderedMapFromIterable[K2, V2](it: collection.Iterable[(K2, V2)])(implicit ordering: Ordering[K2]): CC[K2, V2]
+  protected[this] def sortedMapFromIterable[K2, V2](it: collection.Iterable[(K2, V2)])(implicit ordering: Ordering[K2]): CC[K2, V2]
 
   def firstKey: K = head._1
   def lastKey: K = last._1
 
   // And finally, we add new overloads taking an ordering
   def map[K2, V2](f: ((K, V)) => (K2, V2))(implicit ordering: Ordering[K2]): CC[K2, V2] =
-    orderedMapFromIterable(View.Map[(K, V), (K2, V2)](coll, f))
+    sortedMapFromIterable(View.Map[(K, V), (K2, V2)](coll, f))
 
   def flatMap[K2, V2](f: ((K, V)) => IterableOnce[(K2, V2)])(implicit ordering: Ordering[K2]): CC[K2, V2] =
-    orderedMapFromIterable(View.FlatMap(coll, f))
+    sortedMapFromIterable(View.FlatMap(coll, f))
 
   def ++[K2 >: K, V2 >: V](xs: IterableOnce[(K2, V2)])(implicit ordering: Ordering[K2]): CC[K2, V2] =
-    orderedMapFromIterable(View.Concat(coll, xs))
+    sortedMapFromIterable(View.Concat(coll, xs))
 }
 
-object SortedMap extends OrderedMapFactory.Delegate[SortedMap](TreeMap)
+object SortedMap extends SortedMapFactory.Delegate[SortedMap](TreeMap)

src/main/scala/strawman/collection/SortedSet.scala

@@ -11,19 +11,19 @@ trait SortedSetOps[A, +CC[X], +C <: SortedSet[A]]
   extends SetOps[A, Set, C]
      with SortedOps[A, C] {
 
-  protected[this] def orderedFromIterable[B: Ordering](it: Iterable[B]): CC[B]
+  protected[this] def sortedFromIterable[B: Ordering](it: Iterable[B]): CC[B]
 
   def firstKey: A = head
   def lastKey: A = last
 
   /** Map */
-  def map[B : Ordering](f: A => B): CC[B] = orderedFromIterable(View.Map(coll, f))
+  def map[B : Ordering](f: A => B): CC[B] = sortedFromIterable(View.Map(coll, f))
 
   /** Flatmap */
-  def flatMap[B : Ordering](f: A => IterableOnce[B]): CC[B] = orderedFromIterable(View.FlatMap(coll, f))
+  def flatMap[B : Ordering](f: A => IterableOnce[B]): CC[B] = sortedFromIterable(View.FlatMap(coll, f))
 
   /** Zip. Interesting because it requires to align to source collections. */
-  def zip[B](xs: IterableOnce[B])(implicit ev: Ordering[(A @uncheckedVariance, B)]): CC[(A @uncheckedVariance, B)] = orderedFromIterable(View.Zip(coll, xs))
+  def zip[B](xs: IterableOnce[B])(implicit ev: Ordering[(A @uncheckedVariance, B)]): CC[(A @uncheckedVariance, B)] = sortedFromIterable(View.Zip(coll, xs))
   // sound bcs of VarianceNote
 
   def collect[B: Ordering](pf: scala.PartialFunction[A, B]): CC[B] = flatMap(a =>
@@ -32,4 +32,4 @@ trait SortedSetOps[A, +CC[X], +C <: SortedSet[A]]
   )
 }
 
-object SortedSet extends OrderedIterableFactory.Delegate[SortedSet](immutable.SortedSet)
+object SortedSet extends SortedIterableFactory.Delegate[SortedSet](immutable.SortedSet)

src/main/scala/strawman/collection/immutable/BitSet.scala

@@ -29,7 +29,7 @@ sealed abstract class BitSet
   def iterableFactory = Set
 
   protected[this] def fromSpecificIterable(coll: collection.Iterable[Int]): BitSet = BitSet.fromSpecificIterable(coll)
-  protected[this] def orderedFromIterable[B : Ordering](it: collection.Iterable[B]): SortedSet[B] = SortedSet.orderedFromIterable(it)
+  protected[this] def sortedFromIterable[B : Ordering](it: collection.Iterable[B]): SortedSet[B] = SortedSet.sortedFromIterable(it)
 
 
   protected[collection] def fromBitMaskNoCopy(elems: Array[Long]): BitSet = BitSet.fromBitMaskNoCopy(elems)

src/main/scala/strawman/collection/immutable/SortedSet.scala

@@ -17,4 +17,4 @@ trait SortedSetOps[A,
   extends SetOps[A, Set, C]
      with collection.SortedSetOps[A, CC, C]
 
-object SortedSet extends OrderedIterableFactory.Delegate[SortedSet](TreeSet)
+object SortedSet extends SortedIterableFactory.Delegate[SortedSet](TreeSet)

src/main/scala/strawman/collection/immutable/TreeMap.scala

@@ -2,7 +2,7 @@ package strawman
 package collection
 package immutable
 
-import strawman.collection.OrderedMapFactory
+import strawman.collection.SortedMapFactory
 import strawman.collection.immutable.{RedBlackTree => RB}
 import strawman.collection.mutable.Builder
 
@@ -39,10 +39,10 @@ final class TreeMap[K, +V] private (tree: RB.Tree[K, V])(implicit val ordering:
   def iterableFactory = List
 
   protected[this] def fromSpecificIterable(coll: collection.Iterable[(K, V)]): TreeMap[K, V] =
-    TreeMap.orderedFromIterable(coll)
+    TreeMap.sortedFromIterable(coll)
 
-  protected[this] def orderedMapFromIterable[K2, V2](it: collection.Iterable[(K2, V2)])(implicit ordering: Ordering[K2]): TreeMap[K2, V2] =
-    TreeMap.orderedFromIterable(it)
+  protected[this] def sortedMapFromIterable[K2, V2](it: collection.Iterable[(K2, V2)])(implicit ordering: Ordering[K2]): TreeMap[K2, V2] =
+    TreeMap.sortedFromIterable(it)
 
   def iterator(): collection.Iterator[(K, V)] = RB.iterator(tree)
 
@@ -100,11 +100,11 @@ final class TreeMap[K, +V] private (tree: RB.Tree[K, V])(implicit val ordering:
   *  @define Coll immutable.TreeMap
   *  @define coll immutable tree map
   */
-object TreeMap extends OrderedMapFactory[TreeMap] {
+object TreeMap extends SortedMapFactory[TreeMap] {
 
   def empty[K : Ordering, V]: TreeMap[K, V] = new TreeMap()
 
-  def orderedFromIterable[K : Ordering, V](it: collection.Iterable[(K, V)]): TreeMap[K, V] =
+  def sortedFromIterable[K : Ordering, V](it: collection.Iterable[(K, V)]): TreeMap[K, V] =
     it match {
       case tm: TreeMap[K, V] => tm
       case _ => empty[K, V] ++ it

src/main/scala/strawman/collection/immutable/TreeSet.scala

@@ -64,10 +64,10 @@ final class TreeSet[A] private (tree: RB.Tree[A, Unit])(implicit val ordering: O
   def iterableFactory = Set
 
   protected[this] def fromSpecificIterable(coll: strawman.collection.Iterable[A]): TreeSet[A] =
-    TreeSet.orderedFromIterable(coll)
+    TreeSet.sortedFromIterable(coll)
 
-  protected[this] def orderedFromIterable[B : Ordering](coll: strawman.collection.Iterable[B]): TreeSet[B] =
-    TreeSet.orderedFromIterable(coll)
+  protected[this] def sortedFromIterable[B : Ordering](coll: strawman.collection.Iterable[B]): TreeSet[B] =
+    TreeSet.sortedFromIterable(coll)
 
   def unordered: Set[A] = this
 
@@ -103,11 +103,11 @@ final class TreeSet[A] private (tree: RB.Tree[A, Unit])(implicit val ordering: O
     else newSet(RB.delete(tree, elem))
 }
 
-object TreeSet extends OrderedIterableFactory[TreeSet] {
+object TreeSet extends SortedIterableFactory[TreeSet] {
 
   def empty[A: Ordering]: TreeSet[A] = new TreeSet[A]
 
-  def orderedFromIterable[E: Ordering](it: strawman.collection.Iterable[E]): TreeSet[E] =
+  def sortedFromIterable[E: Ordering](it: strawman.collection.Iterable[E]): TreeSet[E] =
     it match {
       case ts: TreeSet[E] => ts
       case _ => empty[E] ++ it

src/main/scala/strawman/collection/mutable/BitSet.scala

@@ -36,8 +36,8 @@ class BitSet(protected[collection] final var elems: Array[Long])
 
   def iterableFactory = Set
 
-  protected[this] def orderedFromIterable[B : Ordering](it: collection.Iterable[B]): collection.mutable.SortedSet[B] =
-    collection.mutable.SortedSet.orderedFromIterable(it)
+  protected[this] def sortedFromIterable[B : Ordering](it: collection.Iterable[B]): collection.mutable.SortedSet[B] =
+    collection.mutable.SortedSet.sortedFromIterable(it)
 
   protected[this] def fromSpecificIterable(coll: collection.Iterable[Int]): BitSet =
     BitSet.fromSpecificIterable(coll)

src/main/scala/strawman/collection/mutable/SortedSet.scala

@@ -17,4 +17,4 @@ trait SortedSetOps[A, +CC[X], +C <: SortedSet[A]]
     with collection.SortedSetOps[A, CC, C]
 
 object SortedSet
-  extends OrderedIterableFactory.Delegate[SortedSet](TreeSet)
+  extends SortedIterableFactory.Delegate[SortedSet](TreeSet)

src/main/scala/strawman/collection/mutable/TreeMap.scala

@@ -1,7 +1,7 @@
 package strawman
 package collection.mutable
 
-import collection.{Iterator, OrderedMapFactory}
+import collection.{Iterator, SortedMapFactory}
 import collection.mutable.{RedBlackTree => RB}
 
 import scala.{Boolean, Int, None, Option, Ordering, SerialVersionUID, Serializable, Some, Unit}
@@ -34,9 +34,9 @@ sealed class TreeMap[K, V] private (tree: RB.Tree[K, V])(implicit val ordering:
     */
   def this()(implicit ord: Ordering[K]) = this(RB.Tree.empty)(ord)
 
-  protected[this] def fromSpecificIterable(coll: collection.Iterable[(K, V)]): TreeMap[K, V] = TreeMap.orderedFromIterable(coll)
+  protected[this] def fromSpecificIterable(coll: collection.Iterable[(K, V)]): TreeMap[K, V] = TreeMap.sortedFromIterable(coll)
 
-  protected[this] def orderedMapFromIterable[K2, V2](it: collection.Iterable[(K2, V2)])(implicit ordering: Ordering[K2]): TreeMap[K2, V2] = TreeMap.orderedFromIterable(it)
+  protected[this] def sortedMapFromIterable[K2, V2](it: collection.Iterable[(K2, V2)])(implicit ordering: Ordering[K2]): TreeMap[K2, V2] = TreeMap.sortedFromIterable(it)
 
   def iterator(): Iterator[(K, V)] = RB.iterator(tree)
 
@@ -172,9 +172,9 @@ sealed class TreeMap[K, V] private (tree: RB.Tree[K, V])(implicit val ordering:
   * @define Coll mutable.TreeMap
   * @define coll mutable tree map
   */
-object TreeMap extends OrderedMapFactory[TreeMap] {
+object TreeMap extends SortedMapFactory[TreeMap] {
 
-  def orderedFromIterable[K : Ordering, V](it: collection.Iterable[(K, V)]): TreeMap[K, V] =
+  def sortedFromIterable[K : Ordering, V](it: collection.Iterable[(K, V)]): TreeMap[K, V] =
     Growable.fromIterable(empty[K, V], it)
 
   def empty[K : Ordering, V]: TreeMap[K, V] = new TreeMap[K, V]()