Address review comments on Tuple.scala

Author: odersky

library/src/scala/NamedTuple.scala

@@ -184,8 +184,8 @@ object NamedTuple:
    *  @syntax markdown
    */
   type Zip[X <: AnyNamedTuple, Y <: AnyNamedTuple] =
-    Tuple.Conforms[Names[X], Names[Y]] match
-      case true =>
+    Names[X] match
+      case Names[Y] =>
         NamedTuple[Names[X], Tuple.Zip[DropNames[X], DropNames[Y]]]
 
   /** A type specially treated by the compiler to represent all fields of a

library/src/scala/Tuple.scala

@@ -118,6 +118,7 @@ object Tuple:
   // even though it only matches non-empty tuples.
   // Avoids bounds check failures from an irreducible type
   // like `Tuple.Head[Tuple.Tail[X]]`
+  // Other types that don't reduce for empty tuples follow the same principle.
   type Head[X <: Tuple] = X match
     case x *: _ => x
 
@@ -273,22 +274,6 @@ object Tuple:
    */
   type Union[T <: Tuple] = Fold[T, Nothing, [x, y] =>> x | y]
 
-  /** A type level Boolean indicating whether the tuple `X` conforms
-   *  to the tuple `Y`. This means:
-   *   - the two tuples have the same number of elements
-   *   - for corresponding elements `x` in `X` and `y` in `Y`, `x` matches `y`.
-   *  @pre  The elements of `X` are assumed to be singleton types
-   */
-  type Conforms[X <: Tuple, Y <: Tuple] <: Boolean = Y match
-    case EmptyTuple =>
-      X match
-        case EmptyTuple => true
-        case _ => false
-    case y *: ys =>
-      X match
-        case `y` *: xs => Conforms[xs, ys]
-        case _ => false
-
   /** A type level Boolean indicating whether the tuple `X` has an element
    *  that matches `Y`.
    *  @pre  The elements of `X` are assumed to be singleton types
@@ -350,25 +335,14 @@ object Tuple:
 
   extension [X <: Tuple](inline x: X)
 
-    /** The index (starting at 0) of the first element in the type `X` of `x`
-     *  that matches type `Y`.
+    /** The index (starting at 0) of the first occurrence of y.type in the type `X` of `x`
+     *  or Size[X] if no such element exists.
      */
-    inline def indexOfType[Y] = constValue[IndexOf[X, Y]]
+    transparent inline def indexOf(y: Any): Int = constValue[IndexOf[X, y.type]]
 
-    /** A boolean indicating whether there is an element in the type `X` of `x`
-     *  that matches type `Y`.
+    /** A boolean indicating whether there is an element `y.type` in the type `X` of `x`
      */
-    inline def containsType[Y] = constValue[Contains[X, Y]]
-
-    /* Note: It would be nice to add the following two extension methods:
-
-      inline def indexOf[Y: Precise](y: Y) = constValue[IndexOf[X, Y]]
-      inline def containsType[Y: Precise](y: Y) = constValue[Contains[X, Y]]
-
-    because we could then move indexOf/contains completely to the value level.
-    But this requires `Y` to be inferred precisely, and therefore a mechanism
-    like the `Precise` context bound used above, which does not yet exist.
-    */
+    transparent inline def contains(y: Any): Boolean = constValue[Contains[X, y.type]]
 
   end extension
 
@@ -380,7 +354,7 @@ object Tuple:
     using eqHead: CanEqual[H1, H2], eqTail: CanEqual[T1, T2]
   ): CanEqual[H1 *: T1, H2 *: T2] = CanEqual.derived
 
-  object helpers:
+  private object helpers:
 
     /** Used to implement IndicesWhere */
     type IndicesWhereHelper[X <: Tuple, P[_] <: Boolean, N <: Int] <: Tuple = X match

tests/pos/named-tuples-strawman-2.scala

@@ -52,7 +52,7 @@ object TupleOps:
     case EmptyTuple => Y *: EmptyTuple
 
   inline def appendIfDistinct[X <: Tuple, Y](xs: X, y: Y): AppendIfDistinct[X, Y] =
-    (if xs.containsType[Y] then xs else xs :* y).asInstanceOf[AppendIfDistinct[X, Y]]
+    (if xs.contains(y) then xs else xs :* y).asInstanceOf[AppendIfDistinct[X, Y]]
 
   /** `X` with all elements from `Y` that do not occur in `X` appended */
   type ConcatDistinct[X <: Tuple, Y <: Tuple] <: Tuple = Y match
@@ -137,10 +137,10 @@ object NamedTupleOps:
   val x1: IndexOf[Names, "first"] = constValue
   val _: 0 = x1
 
-  val x2: IndexOf[Names, "age"] = names.indexOfType["age"]
+  val x2: IndexOf[Names, "age"] = names.indexOf("age")
   val _: 2 = x2
 
-  val x3: IndexOf[Names, "what?"] = names.indexOfType["what?"]
+  val x3: IndexOf[Names, "what?"] = names.indexOf("what?")
   val _: 3 = x3
 
   type Releases = "first" *: "middle" *: EmptyTuple
@@ -149,7 +149,7 @@ object NamedTupleOps:
   val releases: Releases = ("first", "middle")
   val releaseValues: ReleaseValues = (1.0, true)
 
-  val x4 = values.updateOrAppend(names.indexOfType["age"], 11)
+  val x4 = values.updateOrAppend(names.indexOf("age"), 11)
     //updateOrAppend[Values](values)[IndexOf[Names, "age"], 11](indexOf[Names](names)["age"]("age"), 11)
   val _: ("Bob", "Miller", 11) = x4
   assert(("Bob", "Miller", 11) == x4)

tests/pos/tuple-ops.scala

@@ -2,18 +2,6 @@ import language.experimental.namedTuples
 import Tuple.*
 
 def test =
-  val x1: Conforms[(1, 2), (1, 2)] = ???
-  val _: true = x1
-
-  val x2: Conforms[(1, 2), (1, 3)] = ???
-  val _: false = x2
-
-  val x3: Conforms[(1, 2), (1, 2, 4)] = ???
-  val _: false = x2
-
-  val x4: Conforms[(1, 2, 4), (1, 2)] = ???
-  val _: false = x2
-
   summon[Disjoint[(1, 2, 3), (4, 5)] =:= true]
   summon[Disjoint[(1, 2, 6), (4, 5)] =:= true]
   summon[Disjoint[(1, 2, 6), EmptyTuple] =:= true]
@@ -23,12 +11,6 @@ def test =
   summon[Contains[(1, 2, 3), 2] =:= true]
   summon[Contains[(1, 2, 3), 4] =:= false]
 
-  summon[Conforms[(1, 2, 3), (1, 2, 3)] =:= true]
-  summon[Conforms[(1, 2, 3), (1, 2)] =:= false]
-  summon[Conforms[(1, 2, 3), (1, 2, 4)] =:= false]
-  summon[Conforms[(1, 2, 3), (Int, 2, 3)] =:= true]
-//  summon[Conforms[(Int, 2, 3), (1, 2, 3)] =:= true] // error, reduction gets stuck
-
   summon[Disjoint[(1, 2, 3), (4, 2)] =:= false]
   summon[Disjoint[("a", "b"), ("b", "c")] =:= false]
   summon[Disjoint[(1, 2, 6), Tuple1[2]] =:= false]