Type annotations for patterns

[jiribenes]

Currently, we can't write the : Int part of

expr match {
  case Cons(x: Int, _) => x // doesn't parse, "Expected ) but got :"
  ...
}

similarly, we can't use it in if (expr is Some(x: String)) and val Some(b: Bool) = expr.

This is especially annoying for tuple parameters

// argument list works
def f { g: (Int, String) => Unit }: Unit = g(0, "")
f { (x: Int, y) => () } // works (and reports an error if the annotation is wrong)

// tuple does not
def f { g: ((Int, String)) => Unit }: Unit = g((0, ""))
f { case (x: Int, y) => () } // doesn't parse, "Expected ) but got :"

However, I do not want to use it for runtime matching like in Scala:

// not this, please
expr match {
  case n: Int => ...
  case s: String => ...
  case _ => panic("ohno")
}

[jiribenes]

One specific case where this bothers me is when using for:

for { "abc".each } { c =>
  <> // ^ Effects need to be fully known, but effect emit[A]'s type parameter(s) A could not be inferred.
}

You can annotate the type in two places:

1. on the for as a type parameter, which I generally find ugly

    for[Char] { "abc".each } { c =>
      <>
    }

2. on the binder itself:

   for { "abc".each } { (c: Char) =>
     <>
   }

However, for tuples (like you get when iterating over pairs of things, such as (key, value) pairs from a Map)

for { [(0, "a"), (1, "b"), (2, "c")].each } { case (i, s) =>
  <> // ^ Effects need to be fully known, but effect emit[Tuple2[A, B]]'s type parameter(s) A, B could not be inferred.
}

you can only use the variant 1:

for[(Int, String)] { [(0, "a"), (1, "b"), (2, "c")].each } { case (i, s) =>
  <> // ^ Effects need to be fully known, but effect emit[Tuple2[A, B]]'s type parameter(s) A, B could not be inferred.
}

but not variant 2 [!]:

for { [(0, "a"), (1, "b"), (2, "c")].each } { case (i: Int, s: String) => // parse error: "Expected ) but got :"
  <> 
}

[jiribenes]

A first step would be to actually parse annotated patterns -- I think an optional annotation in the "variable" case should be enough.

effekt/effekt/shared/src/main/scala/effekt/Parser.scala

Lines 1003 to 1021 in b64b15a

	def matchPattern(): MatchPattern =
	nonterminal:
	peek.kind match {
	case `__` => skip(); IgnorePattern(span())
	case _ if isVariable =>
	idRef() match {
	case id if peek(`(`) => TagPattern(id, many(matchPattern, `(`, `,`, `)`).unspan, span())
	case IdRef(Nil, name, span) => AnyPattern(IdDef(name, span), span)
	case IdRef(_, name, _) => fail("Cannot use qualified names to bind a pattern variable")
	}
	case _ if isVariable =>
	AnyPattern(idDef(), span())
	case _ if isLiteral => LiteralPattern(literal(), span())
	case `(` => some(matchPattern, `(`, `,`, `)`) match {
	case Many(p :: Nil , _) => fail("Pattern matching on tuples requires more than one element")
	case Many(ps, _) => TagPattern(IdRef(List("effekt"), s"Tuple${ps.size}", span().synthesized), ps, span())
	}
	case k => fail("pattern", k)
	}