Question

Below is code that I’m trying to use to illustrate pattern matching :

package patternmatching

object patterntest {

    abstract class Expr
    case class Var(name: String) extends Expr
    case class Number(num: Double) extends Expr
    case class UnOp(operator: String , arg: Expr) extends Expr
    case class BinOp(operator: String, left: Expr, right: Expr) extends Expr

    def simplifyTop(expr: Expr): Expr = expr match {
      case UnOp("-", UnOp("-", e)) => e //double negation
      case BinOp("+", e, Number(0)) => e  //adding zero
      case BinOp("*", e, Number(1)) => e //Mutiplying by one
      case _ => expr
    }


   def main(args: Array[String]) {
      UnOp("-" , UnOp("-", e))
    }

}

How can I test each of the patterns ? The line UnOp(“-” , UnOp(“-“, e))
within the main method gives an error :

not found: value e

Answer 1

First, replace the main method with the following one:

def main(args: Array[String]) {
  val sample = UnOp("-" , UnOp("-", Number(0)) // no more undefined variable
  val simplified = simplifyTop(sample)
  println(simplified)
}

It will probably print something like Number(0) which is a match to the first case expression.

Personally, I like to think that cases classes constructs values and pattern match deconstructs them. In this process of deconstructing values with patter match you can also bind the pieces to variables. After a match has occurred you use these variables.

For example, in simplifyTop the BinOp("+", e, Number(0)) will match when expr is a BinOp, its operator field has value “+” and right field has value “Number(0)”, the left field can have any instance of Expr and its value will be bound to the variable e.

Another example would be case BinOp("+", Number(l), Number(r)) => Number(l+r), this case would not only extract – the deconstruction in Scala jargon – the outer value of type BinOp but also its inner parts, which are Numbers.