Naming consistency

Author: julienrf

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

@@ -1,6 +1,8 @@
 package strawman
 package collection.immutable
 
+import strawman.collection.IterableMonoTransforms
+
 /** Base type of immutable Maps */
 trait Map[K, +V]
   extends collection.Map[K, V]
@@ -9,27 +11,19 @@ trait Map[K, +V]
 /** Base trait of immutable Maps implementations */
 trait MapLike[K, +V, +C[X, +Y] <: Map[X, Y]]
   extends collection.MapLike[K, V, C]
-    with MapOps[K, V, C]
+    with MapMonoTransforms[K, V, C[K, V]]
     with Iterable[(K, V)]
 
 /** Immutable Map operations returning a self-like Map */
-trait MapOps[K, +V, +C[X, +Y] <: Map[X, Y]] {
-
-  /**
-    * Add a key/value pair to this map, returning a new map.
-    *
-    * @param kv the key/value pair.
-    * @tparam V1 the type of the value in the key/value pair.
-    * @return A new map with the new binding added to this map.
-    */
-  def + [V1 >: V](kv: (K, V1)): C[K, V1]
+trait MapMonoTransforms[K, +V, +Repr <: Map[K, V]]
+  extends IterableMonoTransforms[(K, V), Repr] {
 
   /**
     * Removes a key from this map, returning a new map.
     *
     * @param key the key to be removed
     * @return a new map without a binding for ''key''
     */
-  def - (key: K): C[K, V]
+  def - (key: K): Repr
 
 }

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

@@ -1,17 +1,22 @@
-package strawman.collection.immutable
+package strawman
+package collection.immutable
 
 /** Base trait for immutable set collections */
 trait Set[A]
-  extends strawman.collection.Set[A]
+  extends collection.Set[A]
     with Iterable[A]
     with SetLike[A, Set]
 
 /** Base trait for immutable set operations */
 trait SetLike[A, +C[X] <: Set[X]]
-  extends strawman.collection.SetLike[A, C]
-    with SetOps[A, C[A]]
+  extends collection.SetLike[A, C]
+    with SetMonoTransforms[A, C[A]]
 
-trait SetOps[A, +Repr] {
+/** Transformation operations returning a Set containing the same kind of
+  * elements
+  */
+trait SetMonoTransforms[A, +Repr]
+  extends collection.SetMonoTransforms[A, Repr] {
 
   def + (elem: A): Repr
 

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

@@ -1,7 +1,7 @@
 package strawman
 package collection.immutable
 
-import strawman.collection.{IterableMonoTransforms, IterablePolyTransforms, MapPolyTransforms, Sorted, SortedLike}
+import strawman.collection.{IterablePolyTransforms, MapPolyTransforms, Sorted, SortedLike}
 
 import scala.annotation.unchecked.uncheckedVariance
 import scala.Ordering
@@ -15,8 +15,7 @@ trait SortedMapLike[K, +V, +C[X, +Y] <: SortedMap[X, Y]]
   extends SortedLike[K, C[K, V]]
     with SortedMapPolyTransforms[K, V, C]
     with MapLike[K, V, Map] // Inherited Map operations can only return a `Map` because they don’t take an evidence `Ordering`
-    with MapOps[K, V, C] // Operations that return the same collection type can return a `SortedMap`, though
-    with IterableMonoTransforms[(K, V), C[K, V]] // Transformation operations that return the same collection type can return a `SortedMap`, though
+    with MapMonoTransforms[K, V, C[K, V]] // Operations that return the same collection type can return a `SortedMap`, though
 
 /** Polymorphic transformation methods for sorted Maps */
 trait SortedMapPolyTransforms[K, +V, +C[X, Y] <: Sorted[X]]
@@ -31,5 +30,14 @@ trait SortedMapPolyTransforms[K, +V, +C[X, Y] <: Sorted[X]]
   // And finally, we add new overloads taking an ordering
   def map[K2, V2](f: (K, V) => (K2, V2))(implicit ordering: Ordering[K2]): C[K2, V2]
 
+  /**
+    * Add a key/value pair to this map, returning a new map.
+    *
+    * @param kv the key/value pair.
+    * @tparam V1 the type of the value in the key/value pair.
+    * @return A new map with the new binding added to this map.
+    */
+  def + [V1 >: V](kv: (K, V1)): C[K, V1]
+
 }
 

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

@@ -1,6 +1,6 @@
 package strawman.collection.immutable
 
-import strawman.collection.{SetMonoTransforms, Sorted, SortedLike, SortedPolyTransforms}
+import strawman.collection.{Sorted, SortedLike, SortedPolyTransforms}
 
 /** Base trait for sorted sets */
 trait SortedSet[A]
@@ -12,5 +12,4 @@ trait SortedSetLike[A, +C[X] <: SortedSet[X]]
   extends SortedLike[A, C[A]]
     with SortedPolyTransforms[A, C]
     with SetLike[A, Set] // Inherited Set operations return a `Set`
-    with SetOps[A, C[A]] // Override the return type of Set ops to return C[A]
-    with SetMonoTransforms[A, C[A]]
+    with SetMonoTransforms[A, C[A]] // Override the return type of Set ops to return C[A]

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

@@ -22,7 +22,7 @@ final class TreeMap[K, +V]
   // Members declared in collection.MapLike
   def get(key: K): Option[V] = ???
 
-  // Members declared in collection.immutable.MapLike
+  // Members declared in collection.immutable.MapMonoTransforms
   def -(key: K): TreeMap[K,V] = ???
   def +[V1 >: V](kv: (K, V1)): TreeMap[K,V1] = ???
 

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

@@ -26,16 +26,16 @@ final class TreeSet[A]()(implicit val ordering: Ordering[A])
   def & (that: strawman.collection.Set[A]): TreeSet[A] = ???
   def ++ (that: strawman.collection.Set[A]): TreeSet[A] = ???
 
+  // From immutable.SetMonoTransforms
+  def +(elem: A): TreeSet[A] = ???
+  def -(elem: A): TreeSet[A] = ???
+
   // From SortedLike
   def range(from: A, until: A): TreeSet[A] = ???
 
   // From SortedPolyTransforms
   def map[B](f: (A) => B)(implicit ordering: Ordering[B]): TreeSet[B] = ???
 
-  // From immutable.SetLike
-  def +(elem: A): TreeSet[A] = ???
-  def -(elem: A): TreeSet[A] = ???
-
 }
 
 object TreeSet extends OrderingGuidedFactories[TreeSet] {

src/test/scala/strawman/collection/test/Test.scala

@@ -303,7 +303,7 @@ class StrawmanTest {
   }
 
   def sortedSets(xs: immutable.SortedSet[Int]): Unit = {
-    val xs1 = xs.map((x: Int) => x.toString)
+    val xs1 = xs.map((x: Int) => x.toString) // TODO Remove type annotation when https://github.com/scala/scala/pull/5708 is published
     val xs2: immutable.SortedSet[String] = xs1
   }
 
@@ -325,7 +325,7 @@ class StrawmanTest {
     val xs2: immutable.SortedMap[String, Int] = xs1
     val xs3 = xs.map(kv => kv._1)
     val xs4: immutable.Iterable[String] = xs3
-    val xs5 = xs.map((k: String, v: Int) => (v, k))
+    val xs5 = xs.map((k: String, v: Int) => (v, k)) // TODO Remove type annotation when https://github.com/scala/scala/pull/5708 is published
     val xs6: immutable.SortedMap[Int, String] = xs5
     class Foo
 //    val xs7 = xs.map((k: String, v: Int) => (new Foo, v)) Error: No implicit Ordering defined for Foo