Match quoted tuple prepend

[Adam-Vandervorst]

Compiler version

3.1.2-RC1-bin-20211025-968dd1b-NIGHTLY

Minimized code

import scala.quoted.*

def printallImpl[T <: NonEmptyTuple](xs: Expr[T])(using Quotes): Expr[Unit] =
  xs match
    case '{ $head *: (${tail}: Tuple) } =>
      '{ print($head); print(" *: "); println($tail) }
    case '{ ($fst, $snd) } =>
      '{ print($fst); print(", "); println($snd) }

inline def printall[T <: NonEmptyTuple](inline xs: T) = ${ printallImpl('{xs}) }

@main def example = printall((1, 2))

Output

1, 2

Expectation

1 *: Tuple(2)

I expect '{ $head *: (${tail}: Tuple) } to catch something matching '{ ($fst, $snd) }, but I'm new to this area.

[nicolasstucki]

The natural assumption you probably made is that (1, 2) is equivalent to 1 *: 2 *: EmptyTuple. This is unfortunately not the case on the term level. Thought on types it is true (1, 2) is of type Int *: Int *: EmptyTuple.

The reason behind this is that to keep compatibility with Scala 2 we need to keep the old TupleN (from 1 to 22) types and constructors. This implies that (1, 2) is actually Tuple2(1, 2). To make old tuples work with the new tuples we make Tuple2[T1, T2] a subtype of T1 *: T2 *: EmptyTuple. We also have to add the operations of Tuple using inline definitions which makes things a bit more complex.

At some point in the future, when we drop Scala 2 backward compatibility we will be able to simplify this.

An alternative to match against the type instead of the constructor.

    case '{ $tuple : Int *: Tuple } =>

or

    case '{ type tail <: Tuple; $tuple : fst *: `tail` } =>

Though then you cannot extract the elements and would need to call head to get them at runtime.

As long as we have TupleN we will need to match offer its constructors and aliases. See https://github.com/lampepfl/dotty/blob/master/library/src/scala/quoted/FromExpr.scala#L174-L181

[nicolasstucki]

I take it NonEmptyTuple and TupleN are unrelated?

They are by transitivity through the *:
Tuple2[Int, Int] <:< (Int *: Int *: EmptyTuple) <:< NonEmptyTuple <:< Tuple

Thought in your case you only know the it is a NonEmptyTuple and not which specific tuple supbtype type.

[nicolasstucki]

Does this mean one can not unroll an operation over a tuple (which is starting to become a quest)?

Currently, the way to do it is to first check the type of the tuple and then use the FromExpr[TupleN[..]].

tupExpr match 
  case '{ EmptyTuple } => 
  case '{ ${Expr(tup)}: Tuple1[T1] } =>  // `Expr(..)` uses `FromExpr[Tuple1[T1]]`
  case '{ ${Expr(tup)}: Tuple2[T1, T2] } => // `Expr(..)` uses `FromExpr[Tuple2[T1, T2]]`
  case '{ ${Expr(tup)}: Tuple3[T1, T2, T3] } => // `Expr(..)` uses `FromExpr[Tuple3[T1, T2, T3]]`
  ..

We need to do this because we need to know statically the types of T1, T2, ... to be able to get the FromExpr[T1], FromExpr[T2], ...

[Adam-Vandervorst]

Alright, thanks for your replies.
I'll shelve the ideas for the trait-based testing; this would likely exceed 22 tests.
I really expected to be able to do something like

def mapImpl[T <: Tuple : Type, B : Type]
           (xs: Expr[T], f: Expr[[A] => (A) => B])
           (using Quotes): Expr[Tuple.Map[T, [_] =>> B]] =
  xs match
    case '{ EmptyTuple } => '{ EmptyTuple }
    case '{ type t <: Tuple; $head *: (${tail}: `t`) } => 
         '{ ($f($head) *: ${mapImpl[t, B](tail, f)}) }

but in hindsight

def map[T <: Tuple, B]
       (xs: T, f: [A] => (a: A) => B): Tuple.Map[T, [_] =>> B] =
  xs match
    case EmptyTuple => EmptyTuple
    case (head *: tail): (h *: t) => f(head) *: map[t, B](tail, f)

doesn't even typecheck without any macro's (and fails on inline #12770).

[Adam-Vandervorst]

What I want to do here is really similar to the unroll proposal by @soronpo.
I.e. using static type capabilities on a (possibly heterogeneous) container (example).

[Adam-Vandervorst]

Revisiting this with the idea I could require the user to use 1 *: 2 *: EmptyTuple for this instead of (1, 2) (which would be suboptimal but worth it for the added convenience in the library) I wrote (omitting casts):

def mapImpl[T <: Tuple : Type, F[_] : Type]
           (xs: Expr[T], f: Expr[[A] => (A) => F[A]])
           (using Quotes): Expr[Tuple.Map[T, F]] =
  import quotes.reflect._

  xs match
    case '{ EmptyTuple } => '{ EmptyTuple }
    case '{ type tail <: Tuple; $h *: (${t}: `tail`) } =>
         '{ $f($h) *: ${mapImpl[tail, F](t, f)} }
    case '{ $x } =>
      println(x.show)
      '{ EmptyTuple }

which falls through to the print even when using the former notation.
The print shows:

{
  val Tuple_this: scala.Tuple$package.EmptyTuple.type = scala.Tuple$package.EmptyTuple
  val `Tuple_this₂`: scala.*:[scala.Int, scala.Tuple$package.EmptyTuple] = (scala.runtime.Tuples.cons(2, Tuple_this).asInstanceOf[scala.*:[scala.Int, scala.Tuple$package.EmptyTuple.type]]: scala.*:[scala.Int, scala.Tuple$package.EmptyTuple])

  (scala.runtime.Tuples.cons(1, `Tuple_this₂`).asInstanceOf[scala.*:[scala.Int, scala.*:[scala.Int, scala.Tuple$package.EmptyTuple]]]: scala.*:[scala.Int, scala.*:[scala.Int, scala.Tuple$package.EmptyTuple]])
}

revealing runtime.Tuples.cons on the value level, is this why the match fails?
Is there a way around this/a way I can match against/access scala.runtime values?
This makes me wonder, does "Though then you cannot extract the elements and would need to call head to get them at runtime." apply in general?