Why can Unit be assigned to a Tuple without compilation error? - scala

Question

Check this REPL session, under Scala 2.12.10:
scala> val a = 3 match { case 3 => 1 case 4 => println("why") }
a: AnyVal = 1
scala> val a: Int = 3 match { case 3 => 1 case 4 => println("why") }
<console>:11: error: type mismatch;
found : Unit
required: Int
val a: Int = 3 match { case 3 => 1 case 4 => println("why") }
scala> val (a, b) = 3 match { case 3 => (1, 2) case 4 => println("why") }
a: Any = 1
b: Any = 2
scala> val (a: Int, b) = 3 match { case 3 => (1, 2) case 4 => println("why") }
a: Int = 1
b: Any = 2
scala> val (a, b) = 4 match { case 3 => (1, 2) case 4 => println("why") }
why
scala.MatchError: () (of class scala.runtime.BoxedUnit)
... 36 elided
I would expect the snippets with tuples to not compile as if Unit is ever returned from the second match, then you always get a runtime error. Why does Unit match successfully to Tuple2 in the compiler view?

Answer 1

Unit cannot be assigned to a Tuple
val t: (Int, Int) = () // Error: type mismatch; found: Unit required: (Int, Int)
However the following syntax represents proper pattern matching
val (a: Int, b: Int) = ...
which in your case desugars to something like so
val x: Any = 3 match {
case 3 => (1, 2)
case 4 => println("why")
}
val a: Int = x match {
case t: (_, _) if t._1.isInstanceOf[Int] => t._1.asInstanceOf[Int]
}
val b: Int = x match {
case t: (_, _) if t._2.isInstanceOf[Int] => t._2.asInstanceOf[Int]
}
Notice those asInstanceOf[Int] which convince compiler static type of a and b is Int, however what would happen at runtime is a different story. For example, consider
val t: (Int, Int) = println("why").asInstanceOf[(Int, Int)]
which compiles but fails a runtime.
Analysing -Xprint:jvm output of
lazy val (a: Int, b: Int) = (): Any
we have approximately
val t: Tuple2 = {
val x1: Any = ()
if (x1.isInstanceOf[Tuple2]) {
val x2: Tuple2 = x1.asInstanceOf[Tuple2]
val a: Any = x2._1
val b: Any = x2._2
if (a.isInstanceOf[Int]) {
val x3: Int = scala.Int.unbox(a) // in effect asInstanceOf[Int]
if (b.isInstanceOf[Int]) {
val x4: Int = scala.Int.unbox(b) // in effect asInstanceOf[Int]
new Tuple2(x3, x4)
} else throw new MatchError(x1)
} else throw new MatchError(x1)
} else throw new MatchError(x1)
}
def a: Int = t._1
def b: Int = t._2
whilst
lazy val (a: Int, b: Int) = ()
does not compile, hence if expression on the right of =, in pattern value definition, types to Any it makes all the difference.

Answer 2

Since your partial function can return either a Tuple2[Int, Int] or a Unit, the compiler considers its return type to be the "smallest common supertype" of those two types, that is Any :
scala> val x = 4 match { case 3 => (1, 2) case 4 => println("why") }
why
x: Any = ()
Notice how the return value is x: Any = () and not x: Unit = ().
What you're doing when extracting the tuple is equivalent to this, which compiles (since Any is a supertype of Tuple2), but produces a MatchError:
scala> val (a, b) = ().asInstanceOf[Any]
scala.MatchError: () (of class scala.runtime.BoxedUnit)
... 28 elided