Improve syntax of type holes in quoted patterns

[nicolasstucki]

Current state

After #10045 we have the following 2 syntaxis to express a type hole in quote pattern.
The first is written using a $ on the type.

case '{ $x : $T } => '{ val y: T = .. .}

T and a given Type[T] are made available on the right-hand side of the pattern.

The second is provides a workaround to some limitations of the first syntax

case '{ type $T; $x : `$T` } => '{ val y: T = .. .}

Here the T is defined as a type in the pattern itself.
It allows us to write explicit bounds on such as

case '{ type $T <: Seq[Int]; ... } =>

It also allows us to have a spliced type that is used in several places

case '{ type $T; val x: Map[`$T`, `$T`]; ... } =>

On the other side we have known types from outside that are used in patterns which just name the type

def f[T: Type] = 
   ... match
     case '{ $x : T } => '{ val y: T = .. .}

Patterns are composable in the sense that a type extracted from one pattern can be used as a known type of a nested pattern.

match
  case '{ $x: $T } => 
    ... match 
      case '{ ... : T } => // T extracted from first match used in second

Goals

• Remove the second syntax variant
  • Support bounds in normal holes
  • Support multiple uses of the same splice in normal holes
• Break fake symmetry between $x and $T
• Keep support of known types as it is
• Type from a pattern should compose with other patterns

[nicolasstucki]

Syntax propoasl 1

We could extend the $ for types to have $[...] in patterns.

case '{ $x: T } => '{ val y: T = .. .} // T from outside
case '{ $x: $T } => '{ val y: T = ... } // T from within the quote 
case '{ $x: $[T] } => '{ val y: T = .. .}
case '{ $x: $[T <: Any] } => '{ val y: T = .. .}
case '{ $x: Map[$T, $T] } => '{ val y: T = .. .}
case '{ $x: $T } => 
   ... match case '{ ... : T } => // T extracted from first match used in second

+ Would fix the limitation with the type bounds 
+ Supports multiple uses
+ Supports composition
- Would not break the symmetry

[nicolasstucki]

Syntax propoasl 2

Use lower cases for type holes

case '{ $x: T } => '{ val y: T = .. .}
case '{ $x: t } => '{ val y: t = .. .}
case '{ $x: Map[t, t] } => '{ val y: t = .. .}

+ Would not break the symmetry
+ Supports multiple uses
+ Looks like but does not behave exactly as normal type variables in patterns
+ Does not compose
- No solution for type bounds

It is also uncertain how would $_ be translated into this scheme.

[nicolasstucki]

Syntax propoasl 3

Find another reserved character that is not $

[smarter]

Syntax propoasl 2
...

• No solution for type bounds

If it supports writing type t <: Int; val $x: t, I think that's good enough, it seems better than inventing a new type of syntax that only works in pattern for this stuff.

Does not compose

I would expect the following to work:

case '{ $x: t } => 
   ... match case '{ ... : `t` } => // t extracted from first match used in second

Having to use backticks isn't very nice, but at least it behaves like normal pattern variables which are well known.

[LPTK]

I have a preference for the syntax that looks like normal type pattern variables, though it's true it makes reuse in further patterns awkward.

Also, a new syntax could be created for bounding them that would work for both normal patterns and quoted patterns:

  case '{ $x: t <: String } => ... // here t <: String

  case Foo(x: t <: String) => ... // here t <: String

(??? : Any) match
  case Foo(x: t <: List[Int]) => ... // the usual error/warning: pattern type cannot be checked at runtime