Declaring an empty pattern matching function - scala

Question

How do I declare an empty/case-less pattern matching function to satisfy a type definition? I'm happy with the function just throwing a runtime exception if it's ever called.
I'm working through the Scala tutorial for Java programmers, in which I have a working function that performs variable substitution on a mathematic expression presented as a tree given a String => Int map. I want to call the same code path even when no variables should exist (in this case after taking a derivative of the expression), but I can't find a concise way to satisfy the type requirements. Here's the full code I have that works but feels wrong:
abstract class Tree
case class Sum(l: Tree, r: Tree) extends Tree
case class Var(n: String) extends Tree
case class Const(v: Int) extends Tree
object CalculatorPatternsPrime {
def eval(tree: Tree, env: String => Int): Int = tree match {
case Sum(l, r) => eval(l, env) + eval(r, env)
case Var(n) => env(n)
case Const(v) => v
}
def eval(tree: Tree): Int = eval(tree, { case "ignore" => -1 })
def derive(tree: Tree, v: String): Tree = tree match {
case Sum(l, r) => Sum(derive(l, v), derive(r, v))
case Var(n) if (n == v) => Const(1)
case _ => Const(0)
}
def main(args: Array[String]): Unit = {
val env: String => Int = { case "x" => 5 case "y" => 7 }
val tree = Sum(
Sum(Const(7), Var("y")),
Sum(Var("x"), Var("x"))
)
println(eval(tree, env))
println(derive(tree, "x"))
println(eval(derive(tree, "x")))
}
}
As you can see I have a dummy { case "ignore" => -1 } to make the type system happy, and the code works fine but I feel like there must be a better way to do this. Here are two alternatives I've considered:
Just writing out a full method body to eval(tree: Tree) instead of trying to call eval(tree: Tree, env: String => Int) but this duplicates the code handling the Sum and Const cases.
Making env an optional/union type and letting it throw an NPE.
What is the idiomatic approach here?

Answer 1

There are a few ways to go about this:
First, as jwvh noted, you can eliminate the single-argument eval by using a default argument for the second parameter in the two-argument eval.
The question then arises, what should that default argument be?
env is a String => Int, which is shorthand for Function1[-A, +R]: contravariant in the argument type and covariant in the result type. For our purposes, this means that any function which accepts a supertype of String (including String) and results in a subtype of Int (including Int) will work.
Since you've said you're OK with throwing, this is a reasonable default function:
{ a: Any => throw new AssertionError(s"shouldn't have looked up $a in the environment") }
Assuming that some other component of the system is ensuring that if there's a Var expression in the tree passed to eval, there's always an appropriate entry in the environment, this might be the most honest thing to do: something important in your system isn't maintaining an invariant, so trying to reason about it in your system might just make things worse.
That function works because it has the type Any => Nothing, which is a subtype of String => Int: you can pass it a String (String is a subtype of Any) and it will never have a result that's not an Int or a subtype of an Int (it doesn't have a result).
As an alternative, you could also use PartialFunction.empty as a default, which will throw a MatchError if it's ever called. This fits using a partial function literal (which is what a bare { case... } block is).
So I would have either (both have type Env = String => Int)
val emptyEnv: Env = { a: Any => throw new AssertionError(s"shouldn't have looked up $a in the environment") }
or
val emptyEnv: Env = PartialFunction.empty
And then define eval as:
def eval(tree: Tree, env: Env = emptyEnv): Int
As a side note, I would strongly recommend making Tree sealed:
sealed abstract class Tree
Which limits where classes extending Tree can be defined and gives you a stronger guarantee that invariants about Trees are enforced.