Imported From: https://issues.scala-lang.org/browse/SI-7819?orig=1
Reporter: Shelby Moore III (shelby)

@retronym said:
Please try again on the mailing list to see if you can find the history of this choice. [scala-language] would be suitable.

I don't know myself, but if I had to guess I would say it would be so you could reason about the associativy by thinking of match as a regular method:

object Test {
  def `match`(a: PartialFunction[Any, Any]) = 0

  def op(t: Test.type) = t

  this op this match { case x => x }

  this op this `match` { case x => x }
}

qbin/scalac -Xprint:parser sandbox/test.scala
[[syntax trees at end of                    parser]] // test.scala
package <empty> {
  object Test extends scala.AnyRef {
    def <init>() = {
      super.<init>();
      ()
    };
    def `match`(a: PartialFunction[Any, Any]) = 0;
    this match {
      case (x @ _) => x
    };
    def op(t: Test.type) = t;
    this.op(this) match {
      case (x @ _) => x
    };
    this.op(this).`match`(<empty> match {
      case (x @ _) => x
    })
  }
}

Shelby Moore III (shelby) said (edited on Sep 10, 2013 7:05:40 PM UTC):
One thing I really like about getting rid of the ternary operator ( ? : ), that the silent bug of not enclosing in paired parenthesis the first operand or the entire ternary (when you need it) is avoided. The first operand comes after the if and when employed as an operand itself, an if-else clause is forced to be enclosed in parenthesis by the grammar. Unfortunately match has the first problem of the ternary (but not the second due to the required braces).