Edit this page on GitHub

Pattern Bindings

In Scala 2, pattern bindings in val definitions and for expressions are loosely typed. Potentially failing matches are still accepted at compile-time, but may influence the program's runtime behavior. From Scala 3.2 on, type checking rules will be tightened so that warnings are reported at compile-time instead.

Bindings in Pattern Definitions

val xs: List[Any] = List(1, 2, 3)
val (x: String) :: _ = xs   // error: pattern's type String is more specialized
                            // than the right-hand side expression's type Any

This code gives a compile-time warning in Scala 3.2 (and also earlier Scala 3.x under the -source future setting) whereas it will fail at runtime with a ClassCastException in Scala 2. In Scala 3.2, a pattern binding is only allowed if the pattern is irrefutable, that is, if the right-hand side's type conforms to the pattern's type. For instance, the following is OK:

val pair = (1, true)
val (x, y) = pair

Sometimes one wants to decompose data anyway, even though the pattern is refutable. For instance, if at some point one knows that a list elems is non-empty one might want to decompose it like this:

val first :: rest = elems   // error

This works in Scala 2. In fact it is a typical use case for Scala 2's rules. But in Scala 3.2 it will give a warning. One can avoid the warning by marking the right-hand side with an @unchecked annotation:

val first :: rest = elems: @unchecked   // OK

This will make the compiler accept the pattern binding. It might give an error at runtime instead, if the underlying assumption that elems can never be empty is wrong.

Pattern Bindings in for Expressions

Analogous changes apply to patterns in for expressions. For instance:

val elems: List[Any] = List((1, 2), "hello", (3, 4))
for (x, y) <- elems yield (y, x) // error: pattern's type (Any, Any) is more specialized
                                 // than the right-hand side expression's type Any

This code gives a compile-time warning in Scala 3.2 whereas in Scala 2 the list elems is filtered to retain only the elements of tuple type that match the pattern (x, y). The filtering functionality can be obtained in Scala 3 by prefixing the pattern with case:

for case (x, y) <- elems yield (y, x)  // returns List((2, 1), (4, 3))

Syntax Changes

Generators in for expressions may be prefixed with case.

Generator      ::=  [‘case’] Pattern1 ‘<-’ Expr


The new syntax is supported in Scala 3.0. However, to enable smooth cross compilation between Scala 2 and Scala 3, the changed behavior and additional type checks are only enabled under the -source future setting. They will be enabled by default in version 3.2 of the language.