Infix sequence wildcard pattern

[som-snytt]

Scala used to support:

List(42) match { case h List () => }

which is "multiarg infix" expression syntax in a pattern context.

Folks would still like to deconstruct variable-length things using infix notation.

One syntactic solution exploits the new sequence wildcard syntax:

List(42) match { case h List (Nil: _*) => }

The intention is to use Nil.equals, but this is not the current semantics even where the wildcard is permitted:

scala> List(42) match { case h List () => }
1 |List(42) match { case h List () => }
  |                             ^^
  |             Values of types Unit and Int cannot be compared with == or !=

scala> List(42) match { case List(h, Nil: _*) => }
1 |List(42) match { case List(h, Nil: _*) => }
  |                              ^^^
  |                              Found:    collection.immutable.Nil.type
  |                              Required: Int

From the linked ticket:

scala>   class Unapplyer {
     |     def unapplySeq(seq: Seq[Int]): Option[(Int, Seq[Int])] =
     |       if (seq.isEmpty) None else Some((seq.head, seq.tail))
     |   }
// defined class Unapplyer

scala> val unapplyer = new Unapplyer
val unapplyer: Unapplyer = Unapplyer@6de610c6

scala> Seq(1, 2, 3) match { case unapplyer(h, rest: _*) => (h, rest) }
val res0: (Int, Seq[Int]) = (1,List(2, 3))

scala> Seq(1, 2, 3) match { case h unapplyer (rest: _*) => (h, rest) }
1 |Seq(1, 2, 3) match { case h unapplyer (rest: _*) => (h, rest) }
  |                                             ^
  |            `_*` can be used only for last argument of method application.
  |            It is no longer allowed in operands of infix operations.

scala> Seq(42) match { case h unapplyer () => h }
1 |Seq(42) match { case h unapplyer () => h }
  |                                 ^^
  |             Values of types Unit and Int cannot be compared with == or !=

Hypothetical syntax:

scala> Seq(42) match { case unapplyer(h, Nil: _*) => }
1 |Seq(42) match { case unapplyer(h, Nil: _*) => }
  |                                  ^^^
  |                                  Found:    collection.immutable.Nil.type
  |                                  Required: Int

scala> Seq(42) match { case h unapplyer (Nil: _*) => }
1 |Seq(42) match { case h unapplyer (Nil: _*) => }
  |                                       ^
  |            `_*` can be used only for last argument of method application.
  |            It is no longer allowed in operands of infix operations.

Currently required verbosity:

scala> Seq(42) match { case unapplyer(h, rest: _*) if rest.isEmpty => }

scala> Seq(42) match { case unapplyer(h, rest: _*) if Nil == rest => }

The "infix sequence wildcard in binary infix pattern" feature can be considered orthogonal to "non-binary (multiarg) infix pattern":

scala> Seq(1, 2, 3) match { case h unapplyer (x, y) => (h, x, y) }
1 |Seq(1, 2, 3) match { case h unapplyer (x, y) => (h, x, y) }
  |                                      ^^^^^^
  |           cannot test if value of type Int is a reference of class Tuple2

Accepting Nil: _* is an additional feature but necessary for this request to be useful for the common case of extracting one element only. Note that the Scala 2 syntax is not suitable because it introduces a new name:

scala> Seq(1, 2, 3) match { case unapplyer(h, Nil @ _*) => Nil }
val res1: Seq[Int] = List(2, 3)

The old syntax error suggests that a special case might be required, since sequence wildcard is not a Simple Pattern.

scala> Seq(1, 2, 3) match { case h unapplyer (Nil @ _*) => }
                                                      ^
       error: bad simple pattern: bad use of _* (sequence pattern not allowed)

Transfers scala/bug#12110

[som-snytt]

Scala 3 post-pandemic:

scala> object X { def unapplySeq[A](as: Seq[A]): Option[(A, Seq[A])] = if (as.isEmpty) None else Some((as.head, as.tail)) }
// defined object X

scala> List(42) match { case h X (t*) => (h, t) case _ => ??? }
val res0: (Int, Seq[Int]) = (42,List())

scala> List(42, 17) match { case h X (t*) => (h, t) case _ => ??? }
val res1: (Int, Seq[Int]) = (42,List(17))

scala> List(42) match { case h X (_*) => h case _ => ??? }
val res2: Int = 42

scala> List(42, 17) match { case h X (Nil*) => (h, t) case _ => ??? }
-- Error:
1 |List(42, 17) match { case h X (Nil*) => (h, t) case _ => ??? }
  |                                   ^
  |                                   `*` must follow pattern variable