Remove type members representing collection types

Author: julienrf

collections-contrib/src/main/scala/strawman/collection/decorators/HasImmutableMapOps.scala

@@ -3,15 +3,14 @@ package decorators
 
 /**
   * Type class witnessing that a collection representation type `Repr` has
-  * a conversion to `immutable.MapOps[K, V, CC2, C]`, for some type `K`,
-  * `V`, `CC2[_, _]` and `C`
+  * a conversion to `immutable.MapOps[K, V, _, _]`.
+  *
   * @see [[scala.collection.decorators.HasIterableOps]]
   */
 trait HasImmutableMapOps[Repr] extends HasMapOps[Repr] {
 
-  type CC2[X, +Y] <: immutable.MapOps[X, Y, CC2, _]
-
-  type C <: immutable.MapOps[K, V, CC2, C]
+  protected type CC2[X, +Y] <: immutable.MapOps[X, Y, CC2, _]
+  protected type C <: immutable.MapOps[K, V, CC2, C]
 
   /** A conversion from the representation type `Repr` to `immutable.MapOps[K, V, CC2, C]` */
   val conversion: Repr => immutable.MapOps[K, V, CC2, C]
@@ -20,32 +19,29 @@ trait HasImmutableMapOps[Repr] extends HasMapOps[Repr] {
 
 object HasImmutableMapOps {
 
+  type SomeImmutableMapOps[K, +V] <: immutable.MapOps[K, V, SomeImmutableMapOps, SomeImmutableMapOps[K, V]]
+
   /** A type alias for `HasImmutableMapOps` that moves type members to type parameters */
-  type Aux[Repr, K0, V0, CC20[X, +Y] <: immutable.MapOps[X, Y, CC20, _], C0 <: immutable.MapOps[K0, V0, CC20, C0]] = HasImmutableMapOps[Repr] {
-    type K = K0
-    type V = V0
-    type CC2[X, +Y] = CC20[X, Y]
-    type C = C0
-  }
+  type Aux[Repr, K0, V0] = HasImmutableMapOps[Repr] { type K = K0; type V = V0 }
 
   // 1. Map collections
-  implicit def mapHasMapOps[CC20[X, +Y] <: immutable.MapOps[X, Y, CC20, CC20[X, Y]], K0, V0]: HasImmutableMapOps.Aux[CC20[K0, V0], K0, V0, CC20, CC20[K0, V0]] =
-    new HasImmutableMapOps[CC20[K0, V0]] {
+  implicit def mapHasMapOps[CC[X, +Y] <: immutable.MapOps[X, Y, CC, CC[X, Y]], K0, V0]: HasImmutableMapOps.Aux[CC[K0, V0], K0, V0] =
+    new HasImmutableMapOps[CC[K0, V0]] {
       type K = K0
       type V = V0
-      type CC2[X, +Y] = CC20[X, Y]
-      type C = CC20[K, V]
-      val conversion: CC20[K0, V0] => immutable.MapOps[K0, V0, CC20, CC20[K0, V0]] = c => c
+      type CC2[X, +Y] = CC[X, Y]
+      type C = CC[K, V]
+      val conversion: CC[K0, V0] => immutable.MapOps[K0, V0, CC2, C] = c => c
     }
 
   // 2. Sorted Map collections
-  implicit def sortedMapHasMapOps[CC20[X, +Y] <: immutable.Map[X, Y] with immutable.SortedMapOps[X, Y, CC20, CC20[X, Y]], K0, V0]: HasImmutableMapOps.Aux[CC20[K0, V0], K0, V0, immutable.Map, CC20[K0, V0]] =
-    new HasImmutableMapOps[CC20[K0, V0]] {
+  implicit def sortedMapHasMapOps[CC[X, +Y] <: immutable.Map[X, Y] with immutable.SortedMapOps[X, Y, CC, CC[X, Y]], K0, V0]: HasImmutableMapOps.Aux[CC[K0, V0], K0, V0] =
+    new HasImmutableMapOps[CC[K0, V0]] {
       type K = K0
       type V = V0
       type CC2[X, +Y] = immutable.Map[X, Y]
-      type C = CC20[K, V]
-      val conversion: CC20[K0, V0] => immutable.MapOps[K0, V0, immutable.Map, CC20[K0, V0]] = c => c
+      type C = CC2[K, V]
+      val conversion: CC[K0, V0] => immutable.MapOps[K0, V0, immutable.Map, CC[K0, V0]] = c => c
     }
 
 }

collections-contrib/src/main/scala/strawman/collection/decorators/HasIterableOps.scala

@@ -3,8 +3,7 @@ package decorators
 
 /**
   * Type class witnessing that a collection representation type `Repr`
-  * has elements of type `A` and has a conversion to `IterableOps[A, CC, C]`
-  * for some types `CC[_]` and `C`.
+  * has elements of type `A` and has a conversion to `IterableOps[A, _, _]`.
   *
   * This type enables simple enrichment of `Iterable`s with extension methods.
   *
@@ -15,49 +14,33 @@ trait HasIterableOps[Repr] {
   /** The type of elements (e.g. `Int`) */
   type A
 
-  /** The type constructor returned by transformation operations that might change the element type (e.g. `List`) */
-  type CC[_]
-
-  /** The type returned by transformation operations that keep the same type of elements (e.g. `List[Int]`) */
-  type C
-
-  /** A conversion from the representation type `Repr` to `IterableOps[A, CC, C]` */
-  val conversion: Repr => IterableOps[A, CC, C]
+  /** A conversion from the representation type `Repr` to `IterableOps[A, _, _]` */
+  val conversion: Repr => IterableOps[A, AnyConstr, _]
 
 }
 
 object HasIterableOps extends LowPriorityHasIterableOps {
 
-  implicit def iterableHasIterableOps[CC0[X] <: IterableOps[X, CC0, CC0[X]], A0]: HasIterableOps.Aux[CC0[A0], A0, CC0, CC0[A0]] =
-    new HasIterableOps[CC0[A0]] {
-      type A = A0
-      type CC[X] = CC0[X]
-      type C = CC0[A0]
-      val conversion: CC0[A0] => IterableOps[A0, CC0, CC0[A0]] = c => c
-    }
-
-  implicit def viewHasIterableOps[CC0[X] <: View[X], A0]: HasIterableOps.Aux[CC0[A0], A0, View, View[A0]] =
-    new HasIterableOps[CC0[A0]] {
+  implicit def iterableHasIterableOps[CC[X] <: IterableOps[X, AnyConstr, _], A0]: HasIterableOps.Aux[CC[A0], A0] =
+    new HasIterableOps[CC[A0]] {
       type A = A0
-      type CC[X] = View[X]
-      type C = View[A0]
-      val conversion: CC0[A0] => IterableOps[A0, View, View[A0]] = c => c
+      val conversion: CC[A0] => IterableOps[A0, AnyConstr, _] = c => c
     }
 
 }
 
 trait LowPriorityHasIterableOps {
 
-  type Aux[Repr, A0, CC0[_], C0] = HasIterableOps[Repr] { type A = A0; type CC[X] = CC0[X]; type C = C0 }
+  type Aux[Repr, A0] = HasIterableOps[Repr] { type A = A0 }
 
   // Makes `HasSeqOps` instances visible in `HasIterableOps` companion
-  implicit def hasSeqOpsHasIterableOps[Repr, A, CC[_], C](implicit
-    hasSeqOps: HasSeqOps.Aux[Repr, A, CC, C]
-  ): HasIterableOps.Aux[Repr, A, CC, C] = hasSeqOps
+  implicit def hasSeqOpsHasIterableOps[Repr, A](implicit
+    hasSeqOps: HasSeqOps.Aux[Repr, A]
+  ): HasIterableOps.Aux[Repr, A] = hasSeqOps
 
   // Makes `HasMapOps` instances visible in `HasIterableOps` companion
-  implicit def hasMapOpsHasIterableOps[Repr, K0, V0, CC20[_, +_] <: IterableOps[_, AnyConstr, _], C0](implicit
-    hasMapOps: HasMapOps.Aux[Repr, K0, V0, CC20, C0]
-  ): HasIterableOps.Aux[Repr, (K0, V0), Iterable, C0] = hasMapOps
+  implicit def hasMapOpsHasIterableOps[Repr, K0, V0](implicit
+    hasMapOps: HasMapOps.Aux[Repr, K0, V0]
+  ): HasIterableOps.Aux[Repr, (K0, V0)] = hasMapOps
 
 }

collections-contrib/src/main/scala/strawman/collection/decorators/HasMapOps.scala

@@ -1,12 +1,9 @@
 package strawman.collection
 package decorators
 
-import scala.annotation.unchecked.uncheckedVariance
-
 /**
   * Type class witnessing that a collection representation type `Repr`
-  * has elements of type `A` and has a conversion to `MapOps[A, CC2, C]`
-  * for some types `CC2[_, _]` and `C`.
+  * has keys of type `K`, values of type `V` and has a conversion to `MapOps[K, V, _, _]`.
   *
   * This type enables simple enrichment of `Map`s with extension methods.
   *
@@ -20,60 +17,33 @@ trait HasMapOps[Repr] extends HasIterableOps[Repr] {
   /** The type of values */
   type V
 
-  /** The type constructor returned by transformation operations that might change the types of key and value (e.g. `HashMap`) */
-  type CC2[_, +_] <: IterableOps[_, AnyConstr, _]
-
   type A = (K, V)
 
-  type CC[X] = Iterable[X]
-
-  /** A conversion from the representation type `Repr` to `MapOps[K, V, CC2, C]` */
-  val conversion: Repr => MapOps[K, V, CC2, C]
+  /** A conversion from the representation type `Repr` to `MapOps[K, V, _, _]` */
+  val conversion: Repr => MapOps[K, V, ({ type l[X, +Y] = IterableOps[_, AnyConstr, _] })#l, _]
 
 }
 
 object HasMapOps extends LowPriorityHasMapOps {
 
   // 1. Map collections
-  implicit def mapHasMapOps[CC20[X, +Y] <: MapOps[X, Y, CC20, CC20[X, Y]], K0, V0]: HasMapOps.Aux[CC20[K0, V0], K0, V0, CC20, CC20[K0, V0]] =
-    new HasMapOps[CC20[K0, V0]] {
-      type K = K0
-      type V = V0
-      type CC2[X, +Y] = CC20[X, Y]
-      type C = CC20[K, V]
-      val conversion: CC20[K0, V0] => MapOps[K0, V0, CC20, CC20[K0, V0]] = c => c
-    }
-
-  // 2. Sorted Map collections
-  implicit def sortedMapHasMapOps[CC20[X, +Y] <: Map[X, Y] with SortedMapOps[X, Y, CC20, CC20[X, Y]], K0, V0]: HasMapOps.Aux[CC20[K0, V0], K0, V0, Map, CC20[K0, V0]] =
-    new HasMapOps[CC20[K0, V0]] {
-      type K = K0
-      type V = V0
-      type CC2[X, +Y] = Map[X, Y]
-      type C = CC20[K, V]
-      val conversion: CC20[K0, V0] => MapOps[K0, V0, Map, CC20[K0, V0]] = c => c
-    }
-
-  // 3. MapView
-  implicit def mapViewHasMapOps[CC20[X, +Y] <: MapView[X, Y], K0, V0]: HasMapOps.Aux[CC20[K0, V0], K0, V0, ({ type l[X, +Y] = View[(X, Y)] })#l, View[(K0, V0)]] =
-    new HasMapOps[CC20[K0, V0]] {
+  implicit def mapHasMapOps[CC[X, +Y] <: MapOps[X, Y, ({ type l[X, +Y] = IterableOps[_, AnyConstr, _] })#l, _], K0, V0]: HasMapOps.Aux[CC[K0, V0], K0, V0] =
+    new HasMapOps[CC[K0, V0]] {
       type K = K0
       type V = V0
-      type CC2[X, +Y] = View[(X, Y)]
-      type C = View[(K0, V0)]
-      val conversion: CC20[K0, V0] => MapOps[K0, V0, ({ type l[X, Y] = View[(X, Y)] })#l, View[(K0, V0)]] = c => c
+      val conversion: CC[K0, V0] => MapOps[K0, V0, ({ type l[X, +Y] = IterableOps[_, AnyConstr, _] })#l, _] = c => c
     }
 
 }
 
 trait LowPriorityHasMapOps {
 
-  type Aux[Repr, K0, V0, CC20[_, +_] <: IterableOps[_, AnyConstr, _], C0] =
-    HasMapOps[Repr] { type K = K0; type V = V0; type CC2[X, +Y] = CC20[X, Y]; type C = C0 }
+  type Aux[Repr, K0, V0] =
+    HasMapOps[Repr] { type K = K0; type V = V0 }
 
   // Makes `HasImmutableMapOps` instances visible in `HasMapOps` companion
-  implicit def hasImmutableMapOpsHasMapOps[Repr, K0, V0, CC20[X, +Y] <: immutable.MapOps[X, Y, CC20, _], C0 <: immutable.MapOps[K0, V0, CC20, C0]](implicit
-    hasImmutableMapOps: HasImmutableMapOps.Aux[Repr, K0, V0, CC20, C0]
-  ): HasMapOps.Aux[Repr, K0, V0, CC20, C0] = hasImmutableMapOps
+  implicit def hasImmutableMapOpsHasMapOps[Repr, K0, V0](implicit
+    hasImmutableMapOps: HasImmutableMapOps.Aux[Repr, K0, V0]
+  ): HasMapOps.Aux[Repr, K0, V0] = hasImmutableMapOps
 
 }

collections-contrib/src/main/scala/strawman/collection/decorators/HasSeqOps.scala

@@ -7,7 +7,7 @@ import scala.Predef.String
 import strawman.collection.immutable.Range
 
 /** Type class witnessing that a collection representation type `Repr` has
-  * elements of type `A` and has a conversion to `SeqOps[A, CC, C]`.
+  * elements of type `A` and has a conversion to `SeqOps[A, _, _]`.
   *
   * This type enables simple enrichment of `Seq`s with extension methods which
   * can make full use of the mechanics of the Scala collections framework in
@@ -16,68 +16,49 @@ import strawman.collection.immutable.Range
   * @see [[scala.collection.decorators.HasIterableOps]]
   */
 trait HasSeqOps[Repr] extends HasIterableOps[Repr] {
-  /** A conversion from the representation type `Repr` to `SeqOps[A, CC, C]`. */
-  val conversion: Repr => SeqOps[A, CC, C]
+  /** A conversion from the representation type `Repr` to `SeqOps[A, _, _]`. */
+  val conversion: Repr => SeqOps[A, AnyConstr, _]
 }
 
 object HasSeqOps {
 
   /** A type alias for `HasSeqOps` that moves type members to type parameters */
-  type Aux[Repr, A0, CC0[_], C0] = HasSeqOps[Repr] { type A = A0; type CC[X] = CC0[X]; type C = C0 }
+  type Aux[Repr, A0] = HasSeqOps[Repr] { type A = A0 }
 
   // we want to provide implicit instances that unify all possible types `X` with a `SeqOps[A, CC, C]`
   // 1. Seq collections
-  implicit def seqHasSeqOps[CC0[X] <: SeqOps[X, CC0, CC0[X]], A0]: HasSeqOps.Aux[CC0[A0], A0, CC0, CC0[A0]] =
-    new HasSeqOps[CC0[A0]] {
+  implicit def seqHasSeqOps[CC[X] <: SeqOps[X, AnyConstr, _], A0]: HasSeqOps.Aux[CC[A0], A0] =
+    new HasSeqOps[CC[A0]] {
       type A = A0
-      type CC[X] = CC0[X]
-      type C = CC0[A]
-      val conversion: CC0[A0] => SeqOps[A0, CC0, CC0[A0]] = c => c
+      val conversion: CC[A0] => SeqOps[A0, AnyConstr, _] = c => c
     }
 
-  // 2. Seq views
-  implicit def viewHasSeqOps[CC0[X] <: SeqView[X], A0]: HasSeqOps.Aux[CC0[A0], A0, View, View[A0]] =
-    new HasSeqOps[CC0[A0]] {
-      type A = A0
-      type CC[X] = View[X]
-      type C = View[A0]
-      val conversion: CC0[A0] => SeqOps[A0, View, View[A0]] = c => c
-    }
-
-  // 3. String
-  implicit def stringHasSeqOps: HasSeqOps.Aux[String, Char, immutable.IndexedSeq, String] =
+  // 2. String
+  implicit def stringHasSeqOps: HasSeqOps.Aux[String, Char] =
     new HasSeqOps[String] {
       type A = Char
-      type CC[X] = immutable.IndexedSeq[X]
-      type C = String
-      val conversion: String => SeqOps[Char, immutable.IndexedSeq, String] = stringToStringOps
+      val conversion: String => SeqOps[Char, AnyConstr, _] = stringToStringOps
     }
 
-  // 4. StringView
-  implicit def stringViewHasSeqOps: HasSeqOps.Aux[StringView, Char, View, View[Char]] =
+  // 3. StringView
+  implicit def stringViewHasSeqOps: HasSeqOps.Aux[StringView, Char] =
     new HasSeqOps[StringView] {
       type A = Char
-      type CC[X] = View[X]
-      type C = View[Char]
-      val conversion: StringView => SeqOps[Char, View, View[Char]] = v => v
+      val conversion: StringView => SeqOps[Char, AnyConstr, _] = v => v
     }
 
-  // 5. Array
-  implicit def arrayHasSeqOps[A0]: HasSeqOps.Aux[Array[A0], A0, immutable.IndexedSeq, Array[A0]] =
+  // 4. Array
+  implicit def arrayHasSeqOps[A0]: HasSeqOps.Aux[Array[A0], A0] =
     new HasSeqOps[Array[A0]] {
       type A = A0
-      type CC[X] = immutable.IndexedSeq[X]
-      type C = Array[A0]
-      val conversion: Array[A0] => SeqOps[A0, immutable.IndexedSeq, Array[A0]] = arrayToArrayOps
+      val conversion: Array[A0] => SeqOps[A0, AnyConstr, _] = arrayToArrayOps
     }
 
-  // 6. Range collections
-  implicit def rangeHasSeqOps[Repr <: Range]: HasSeqOps.Aux[Repr, Int, immutable.IndexedSeq, immutable.IndexedSeq[Int]] =
+  // 5. Range collections
+  implicit def rangeHasSeqOps[Repr <: Range]: HasSeqOps.Aux[Repr, Int] =
     new HasSeqOps[Repr] {
       type A = Int
-      type CC[X] = immutable.IndexedSeq[X]
-      type C = immutable.IndexedSeq[Int]
-      val conversion: Repr => SeqOps[Int, immutable.IndexedSeq, immutable.IndexedSeq[Int]] = r => r
+      val conversion: Repr => SeqOps[Int, AnyConstr, _] = r => r
     }
 
 }