Pattern Match "return" value

Question

Why is it not possible to chain pattern matching constructs? For instance, the following is legal, if nonsensical,

val a = ADT(5)

val b = a match {
  case ADT(a) if a > 4 => ADT(a * 3)
  case ADT(a) => ADT(a + 1)
} 
b match {
  case ADT(a) if a > 13 => doSomething(a)
  case _ => {}
}

but the following is not:

a match {
  case ADT(a) if a > 4 => ADT(a * 3)
  case ADT(a) => ADT(a + 1)
} match {
  case ADT(a) if a > 13 => doSomething(a)
  case _ => {}
}

I suspect it's because I shouldn't be doing it in the first place, but in principle I don't see why it's not legal.

Answer 1

Yes it should work, because (almost) everything in Scala is an expression and every expression can be used as a pattern match.

In this case the pattern match is an expression, so it can be used by another "chained" pattern match. But the compiler doesn't like it.

Giving the compiler a little hint with parentheses helps:

case class ADT(value: Int)

val a = ADT(5)

(a match {
  case ADT(a) if a > 4 => ADT(a * 3)
  case ADT(a) => ADT(a + 1)
}) match {
  case ADT(a) if a > 13 => println(a)
  case _ => {}
}

Answer 2

Your intuition is correct; it's not nonsense—normally you would be able to chain infix operators in such a way, without parentheses (as other users have suggested). Indeed, match used to be implemented as a method—and worked as an infix operator (left-associative by default)—so your alternate syntax would have worked. However, in Scala 2.5 match was made a special language construct instead of a method. I don't know why that was done, but that's the reason: match is not an infix operator despite seeming so.