Reorder operations to be same between term and type level

Author: EugeneFlesselle

library/src/scala/Tuple.scala

@@ -21,18 +21,22 @@ sealed trait Tuple extends Product:
   inline def toIArray: IArray[Object] =
     runtime.Tuples.toIArray(this)
 
-  /** Return a copy of `this` tuple with an element appended */
-  inline def :* [This >: this.type <: Tuple, L](x: L): This :* L =
-    runtime.Tuples.append(x, this).asInstanceOf[Append[This, L]]
-
   /** Return a new tuple by prepending the element to `this` tuple.
    *  This operation is O(this.size)
    */
   inline def *: [H, This >: this.type <: Tuple](x: H): H *: This =
     runtime.Tuples.cons(x, this).asInstanceOf[H *: This]
 
+  /** Return a copy of `this` tuple with an element appended */
+  inline def :* [This >: this.type <: Tuple, L](x: L): This :* L =
+    runtime.Tuples.append(x, this).asInstanceOf[Append[This, L]]
+
+  /** Return the size (or arity) of the tuple */
+  inline def size[This >: this.type <: Tuple]: Size[This] =
+    runtime.Tuples.size(this).asInstanceOf[Size[This]]
+
   /** Get the i-th element of this tuple.
-   * Equivalent to productElement but with a precise return type.
+   *  Equivalent to productElement but with a precise return type.
    */
   inline def apply[This >: this.type <: Tuple](n: Int): Elem[This, n.type] =
     runtime.Tuples.apply(this, n).asInstanceOf[Elem[This, n.type]]
@@ -41,19 +45,38 @@ sealed trait Tuple extends Product:
   inline def head[This >: this.type <: Tuple]: Head[This] =
     runtime.Tuples.apply(this, 0).asInstanceOf[Head[This]]
 
-  /** Get the initial part of the tuple without its last element */
-  inline def init[This >: this.type <: Tuple]: Init[This] =
-    runtime.Tuples.init(this).asInstanceOf[Init[This]]
+  /** Get the tail of this tuple.
+   *  This operation is O(this.size)
+   */
+  inline def tail[This >: this.type <: Tuple]: Tail[This] =
+    runtime.Tuples.tail(this).asInstanceOf[Tail[This]]
 
   /** Get the last of this tuple */
   inline def last[This >: this.type <: Tuple]: Last[This] =
     runtime.Tuples.last(this).asInstanceOf[Last[This]]
 
-  /** Get the tail of this tuple.
-   * This operation is O(this.size)
+  /** Get the initial part of the tuple without its last element */
+  inline def init[This >: this.type <: Tuple]: Init[This] =
+    runtime.Tuples.init(this).asInstanceOf[Init[This]]
+
+  /** Given a tuple `(a1, ..., am)`, returns the tuple `(a1, ..., an)` consisting
+   *  of its first n elements.
    */
-  inline def tail[This >: this.type <: Tuple]: Tail[This] =
-    runtime.Tuples.tail(this).asInstanceOf[Tail[This]]
+  inline def take[This >: this.type <: Tuple](n: Int): Take[This, n.type] =
+    runtime.Tuples.take(this, n).asInstanceOf[Take[This, n.type]]
+
+  /** Given a tuple `(a1, ..., am)`, returns the tuple `(an+1, ..., am)` consisting
+   *  all its elements except the first n ones.
+   */
+  inline def drop[This >: this.type <: Tuple](n: Int): Drop[This, n.type] =
+    runtime.Tuples.drop(this, n).asInstanceOf[Drop[This, n.type]]
+
+  /** Given a tuple `(a1, ..., am)`, returns a pair of the tuple `(a1, ..., an)`
+   *  consisting of the first n elements, and the tuple `(an+1, ..., am)` consisting
+   *  of the remaining elements.
+   */
+  inline def splitAt[This >: this.type <: Tuple](n: Int): Split[This, n.type] =
+    runtime.Tuples.splitAt(this, n).asInstanceOf[Split[This, n.type]]
 
   /** Return a new tuple by concatenating `this` tuple with `that` tuple.
    *  This operation is O(this.size + that.size)
@@ -63,10 +86,6 @@ sealed trait Tuple extends Product:
   inline def ++ [This >: this.type <: Tuple](that: Tuple): This ++ that.type =
     runtime.Tuples.concat(this, that).asInstanceOf[Concat[This, that.type]]
 
-  /** Return the size (or arity) of the tuple */
-  inline def size[This >: this.type <: Tuple]: Size[This] =
-    runtime.Tuples.size(this).asInstanceOf[Size[This]]
-
   /** Given two tuples, `(a1, ..., an)` and `(a1, ..., an)`, returns a tuple
    *  `((a1, b1), ..., (an, bn))`. If the two tuples have different sizes,
    *  the extra elements of the larger tuple will be disregarded.
@@ -85,24 +104,11 @@ sealed trait Tuple extends Product:
   inline def map[F[_]](f: [t] => t => F[t]): Map[this.type, F] =
     runtime.Tuples.map(this, f).asInstanceOf[Map[this.type, F]]
 
-  /** Given a tuple `(a1, ..., am)`, returns the tuple `(a1, ..., an)` consisting
-   *  of its first n elements.
-   */
-  inline def take[This >: this.type <: Tuple](n: Int): Take[This, n.type] =
-    runtime.Tuples.take(this, n).asInstanceOf[Take[This, n.type]]
-
-  /** Given a tuple `(a1, ..., am)`, returns the tuple `(an+1, ..., am)` consisting
-   *  all its elements except the first n ones.
-   */
-  inline def drop[This >: this.type <: Tuple](n: Int): Drop[This, n.type] =
-    runtime.Tuples.drop(this, n).asInstanceOf[Drop[This, n.type]]
-
-  /** Given a tuple `(a1, ..., am)`, returns a pair of the tuple `(a1, ..., an)`
-   *  consisting of the first n elements, and the tuple `(an+1, ..., am)` consisting
-   *  of the remaining elements.
-   */
-  inline def splitAt[This >: this.type <: Tuple](n: Int): Split[This, n.type] =
-    runtime.Tuples.splitAt(this, n).asInstanceOf[Split[This, n.type]]
+  /** A tuple consisting of all elements of this tuple that satisfy the predicate `p`. */
+  inline def filter[This >: this.type <: Tuple, P[_ <: Union[This]] <: Boolean]
+                   (p: (x: Union[This]) => P[x.type]): Filter[This, P] =
+    val arr = this.toArray.filter(x => p(x.asInstanceOf[Union[This]]))
+    Tuple.fromArray(arr).asInstanceOf[Filter[This, P]]
 
   /** Given a tuple `(a1, ..., am)`, returns the reversed tuple `(am, ..., a1)`
    *  consisting all its elements.
@@ -114,14 +120,16 @@ sealed trait Tuple extends Product:
   inline def reverseOnto[This >: this.type <: Tuple, Acc <: Tuple](acc: Acc): ReverseOnto[This, Acc] =
     (this.reverse ++ acc).asInstanceOf[ReverseOnto[This, Acc]]
 
-  /** A tuple consisting of all elements of this tuple that satisfy the predicate `p`. */
-  inline def filter[This >: this.type <: Tuple, P[_ <: Union[This]] <: Boolean]
-                   (p: (x: Union[This]) => P[x.type]): Filter[This, P] =
-    val arr = this.toArray.filter(x => p(x.asInstanceOf[Union[This]]))
-    Tuple.fromArray(arr).asInstanceOf[Filter[This, P]]
-
 object Tuple:
 
+  /** Type of a tuple with an element appended */
+  type Append[X <: Tuple, +Y] <: NonEmptyTuple = X match
+    case EmptyTuple => Y *: EmptyTuple
+    case x *: xs => x *: Append[xs, Y]
+
+  /** An infix shorthand for `Append[X, Y]` */
+  infix type :*[X <: Tuple, +Y] = Append[X, Y]
+
   /** The size of a tuple, represented as a literal constant subtype of Int */
   type Size[X <: Tuple] <: Int = X match
     case EmptyTuple => 0
@@ -142,15 +150,15 @@ object Tuple:
   type Head[X <: Tuple] = X match
     case x *: _ => x
 
+  /** The type of a tuple consisting of all elements of tuple X except the first one */
+  type Tail[X <: Tuple] <: Tuple = X match
+    case _ *: xs => xs
+
   /** The type of the last element of a tuple */
   type Last[X <: Tuple] = X match
     case x *: EmptyTuple => x
     case _ *: xs => Last[xs]
 
-  /** The type of a tuple consisting of all elements of tuple X except the first one */
-  type Tail[X <: Tuple] <: Tuple = X match
-    case _ *: xs => xs
-
   /** The type of the initial part of a tuple without its last element */
   type Init[X <: Tuple] <: Tuple = X match
     case _ *: EmptyTuple => EmptyTuple
@@ -177,14 +185,6 @@ object Tuple:
   /** The pair type `(Take(X, N), Drop[X, N]). */
   type Split[X <: Tuple, N <: Int] = (Take[X, N], Drop[X, N])
 
-  /** Type of a tuple with an element appended */
-  type Append[X <: Tuple, +Y] <: NonEmptyTuple = X match
-    case EmptyTuple => Y *: EmptyTuple
-    case x *: xs => x *: Append[xs, Y]
-
-  /** An infix shorthand for `Append[X, Y]` */
-  infix type :*[X <: Tuple, +Y] = Append[X, Y]
-
   /** Type of the concatenation of two tuples `X` and `Y` */
   // Can be covariant in `Y` since it never appears as a match type scrutinee.
   type Concat[X <: Tuple, +Y <: Tuple] <: Tuple = X match
@@ -194,18 +194,25 @@ object Tuple:
   /** An infix shorthand for `Concat[X, Y]` */
   infix type ++[X <: Tuple, +Y <: Tuple] = Concat[X, Y]
 
-  /** The index of `Y` in tuple `X` as a literal constant Int,
-   *  or `Size[X]` if `Y` is disjoint from all element types in `X`.
+  /** The type of the tuple consisting of all element values of
+   *  tuple `X` zipped with corresponding elements of tuple `Y`.
+   *  If the two tuples have different sizes,
+   *  the extra elements of the larger tuple will be disregarded.
+   *  For example, if
+   *  ```
+   *     X = (S1, ..., Si)
+   *     Y = (T1, ..., Tj)  where j >= i
+   *  ```
+   *  then
+   *  ```
+   *     Zip[X, Y] = ((S1, T1), ..., (Si, Ti))
+   *  ```
+   *  @syntax markdown
    */
-  type IndexOf[X <: Tuple, Y] <: Int = X match
-    case Y *: _ => 0
-    case _ *: xs => S[IndexOf[xs, Y]]
-    case EmptyTuple => 0
-
-  /** Fold a tuple `(T1, ..., Tn)` into `F[T1, F[... F[Tn, Z]...]]]` */
-  type Fold[X <: Tuple, Z, F[_, _]] = X match
-    case EmptyTuple => Z
-    case x *: xs => F[x, Fold[xs, Z, F]]
+  type Zip[X <: Tuple, Y <: Tuple] <: Tuple = (X, Y) match
+    case (x *: xs, y *: ys) => (x, y) *: Zip[xs, ys]
+    case (EmptyTuple, _) => EmptyTuple
+    case (_, EmptyTuple) => EmptyTuple
 
   /** The type of tuple `X` mapped with the type-level function `F`.
    *  If `X = (T1, ..., Ti)` then `Map[X, F] = `(F[T1], ..., F[Ti])`.
@@ -214,6 +221,18 @@ object Tuple:
     case EmptyTuple => EmptyTuple
     case x *: xs => F[x] *: Map[xs, F]
 
+  /** Converts a tuple `(F[T1], ..., F[Tn])` to `(T1,  ... Tn)` */
+  type InverseMap[X <: Tuple, F[_]] <: Tuple = X match
+    case F[x] *: xs => x *: InverseMap[xs, F]
+    case EmptyTuple => EmptyTuple
+
+  /** Implicit evidence. IsMappedBy[F][X] is present in the implicit scope iff
+   *  X is a tuple for which each element's type is constructed via `F`. E.g.
+   *  (F[A1], ..., F[An]), but not `(F[A1], B2, ..., F[An])` where B2 does not
+   *  have the shape of `F[A]`.
+   */
+  type IsMappedBy[F[_]] = [X <: Tuple] =>> X =:= Map[InverseMap[X, F], F]
+
   /** The type of tuple `X` flat-mapped with the type-level function `F`.
    *  If `X = (T1, ..., Ti)` then `FlatMap[X, F] = `F[T1] ++ ... ++ F[Ti]`
    */
@@ -241,44 +260,6 @@ object Tuple:
       case true => x *: Filter[xs, P]
       case false => Filter[xs, P]
 
-  /** A tuple consisting of those indices `N` of tuple `X` where the predicate `P`
-   *  is true for `Elem[X, N]`. Indices are type level values <: Int.
-   */
-  type IndicesWhere[X <: Tuple, P[_ <: Union[X]] <: Boolean] =
-    helpers.IndicesWhereHelper[X, P, 0]
-
-  /** The type of the tuple consisting of all element values of
-   *  tuple `X` zipped with corresponding elements of tuple `Y`.
-   *  If the two tuples have different sizes,
-   *  the extra elements of the larger tuple will be disregarded.
-   *  For example, if
-   *  ```
-   *     X = (S1, ..., Si)
-   *     Y = (T1, ..., Tj)  where j >= i
-   *  ```
-   *  then
-   *  ```
-   *     Zip[X, Y] = ((S1, T1), ..., (Si, Ti))
-   *  ```
-   *  @syntax markdown
-   */
-  type Zip[X <: Tuple, Y <: Tuple] <: Tuple = (X, Y) match
-    case (x *: xs, y *: ys) => (x, y) *: Zip[xs, ys]
-    case (EmptyTuple, _) => EmptyTuple
-    case (_, EmptyTuple) => EmptyTuple
-
-  /** Converts a tuple `(F[T1], ..., F[Tn])` to `(T1,  ... Tn)` */
-  type InverseMap[X <: Tuple, F[_]] <: Tuple = X match
-    case F[x] *: xs => x *: InverseMap[xs, F]
-    case EmptyTuple => EmptyTuple
-
-  /** Implicit evidence. IsMappedBy[F][X] is present in the implicit scope iff
-   *  X is a tuple for which each element's type is constructed via `F`. E.g.
-   *  (F[A1], ..., F[An]), but not `(F[A1], B2, ..., F[An])` where B2 does not
-   *  have the shape of `F[A]`.
-   */
-  type IsMappedBy[F[_]] = [X <: Tuple] =>> X =:= Map[InverseMap[X, F], F]
-
   /** A tuple with the elements of tuple `X` in reversed order */
   type Reverse[X <: Tuple] = ReverseOnto[X, EmptyTuple]
 
@@ -287,11 +268,30 @@ object Tuple:
     case x *: xs => ReverseOnto[xs, x *: Acc]
     case EmptyTuple => Acc
 
+  /** Fold a tuple `(T1, ..., Tn)` into `F[T1, F[... F[Tn, Z]...]]]` */
+  type Fold[X <: Tuple, Z, F[_, _]] = X match
+    case EmptyTuple => Z
+    case x *: xs => F[x, Fold[xs, Z, F]]
+
   /** Given a tuple `(T1, ..., Tn)`, returns a union of its
    *  member types: `T1 | ... | Tn`. Returns `Nothing` if the tuple is empty.
    */
   type Union[T <: Tuple] = Fold[T, Nothing, [x, y] =>> x | y]
 
+  /** The index of `Y` in tuple `X` as a literal constant Int,
+   *  or `Size[X]` if `Y` is disjoint from all element types in `X`.
+   */
+  type IndexOf[X <: Tuple, Y] <: Int = X match
+    case Y *: _ => 0
+    case _ *: xs => S[IndexOf[xs, Y]]
+    case EmptyTuple => 0
+
+  /** A tuple consisting of those indices `N` of tuple `X` where the predicate `P`
+   *  is true for `Elem[X, N]`. Indices are type level values <: Int.
+   */
+  type IndicesWhere[X <: Tuple, P[_ <: Union[X]] <: Boolean] =
+    helpers.IndicesWhereHelper[X, P, 0]
+
   /** 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