How does isDefinedAt method work when case statements are used? - scala

Question

In this explanation of partial functions in scala, an case statement is used as follows:
val divide2: PartialFunction[Int, Int] = {
case d: Int if d != 0 => 42 / d
}
Then it says:
Although this code doesn’t explicitly implement the isDefinedAt
method, it works exactly the same as the previous divide function
definition
The previous divide function explicitly defines apply and isDefined methods as follows:
val divide = new PartialFunction[Int, Int] {
def apply(x: Int) = 42 / x
def isDefinedAt(x: Int) = x != 0
}
I see that the compiler is doing some sort of magic here, but I'm curious about the nature of the mechanism: is the guard in the case (if d != 0) extracted into body of isDefined at the background? What about multiple case statements with their own guards? The domain of the function is defined in the case statement(s), so that must be how the compiler is building the implementation of isDefined behind the scenes.
Am I right?

Answer 1

First of all, the explanation is wrong, since both the presented examples don't work the same:
scala> val a: PartialFunction[Int, Int] = {
| case i if i != 0 => 42 / i
| }
a: PartialFunction[Int,Int] = <function1>
scala> val b = new PartialFunction[Int, Int] {
| def apply(i: Int) = 42 / i
| def isDefinedAt(i: Int) = i != 0
| }
b: PartialFunction[Int,Int] = <function1>
scala> a(0)
scala.MatchError: 0 (of class java.lang.Integer)
at scala.PartialFunction$$anon$1.apply(PartialFunction.scala:253)
at scala.PartialFunction$$anon$1.apply(PartialFunction.scala:251)
at $anonfun$1.applyOrElse(<console>:7)
at $anonfun$1.applyOrElse(<console>:7)
at scala.runtime.AbstractPartialFunction$mcII$sp.apply$mcII$sp(AbstractPartialFunction.scala:36)
... 33 elided
scala> b(0)
java.lang.ArithmeticException: / by zero
at $anon$1.apply$mcII$sp(<console>:8)
... 33 elided
But the core of it is true, the compiler converts the code in the case clauses to a boolean expression for the isDefinedAt method and then the function itself as the apply method (hence the MatchError if the value is not defined)
For a general example, a function like this:
val a = PartialFunction[A, B] {
case <clause A> => <action A>
case <clause B> => <action B>
}
Is compiled as:
val a = new PartialFunction[A, B] {
def isDefinedAt(a: A) = a match {
case <clause A> => true
case <clause B> => true
case _ => false
}
def apply(a: A) = a match {
case <clause A> => <action A>
case <clause B> => <action B>
}
}
Here is the spec that defines this behavior.

Answer 2

I believe it's working because of the available case supported by the pattern matching definition.
The divide2 method has one matching case: x != 0 given x of type Int, therefore, if your value is anything else than that, it should return false.