Review

• Scala is a functional + OO language on the JVM
• val/var
• Everything is an expression with a value (may be Unit)
• Use : Type notation
• Types can often be inferred
• def fun(params) = expr (Don't forget the =)
• Lisp-style lists: List[T], head, tail, ::, isEmpty, Nil

Warm-up exercise: What does this function do?

def mystery(lst : List[Int], n : Int) : List[Int] = 
   if (lst.isEmpty) n :: Nil else lst.head :: mystery(lst.tail, n)

http://ActiveLecture.org

Case Classes

• Special kind of class, but we don't care about that right now

• case class ClassName(field1 : Type1, field2 : Type2, ...) extends Superclass

• Example: Binary tree with values only in the leaves

  class Tree
  case class Leaf(value : Int) extends Tree
  case class Node(left : Tree, right : Tree) extends Tree 

  

Case Class Instances

• Construct instances with ClassName(arg1, arg2, ...)
• Example:

  Node(Node(Leaf(3), Leaf(2)), Leaf(7))

• Draw this in ActiveLecture.org

Pattern Matching

• selectorExpr match { 
     case pattern1 => expr1 
     ... 
     case patternn => exprn 
  }

• Many possibilities for the patterns; we care about case classes

• tree match {
     case Node(l, r) => expr1
     case Leaf(v) => expr2
  }

• The variables l, r, v are bound to the values in the case class instances; you can use them in the expressions (see the lab)
• Sometimes, it is useful to bind the entire match. Use the @ notation

  case n@Node(l, r)

• Matches are tried in order. To have a default, use the “wildcard” pattern at the end

  case _

Example: Polynomials

class Poly
case class Const(value: Double) extends Poly
case class X extends Poly
case class Sum(left: Poly, right: Poly) extends Poly
case class Prod(left: Poly, right: Poly) extends Poly

def deriv(p: Poly): Poly = p match {
   case Const(v) => Const(0)
   case X() => Const(1)
   case Sum(f, g) => Sum(deriv(f), deriv(g))
   case Prod(f, g) => Sum(Prod(f, deriv(g)), Prod(deriv(f), g))
}

deriv(Sum(Prod(X(),X()),X()))
res: Poly = Sum(Sum(Prod(X(),Const(1.0)),Prod(Const(1.0),X())),Const(1.0))

Homework Tips

• You can find a definition of lambda expressions in the Scala language specification (which is a good thing to download anyway)
• While you are at it, download Scala by Example
• The case classes in the reference are what you want, but their eval function is not useful for our purpose. It evaluates a lambda expression from an “environment”—a map of free variables to values. We want to reduce the lambda expression, not plug in values for free variables.
• Scala by Example has a different lambda calculus example that is not useful for us now. It does type inference, which we will study later in this course.

Lab

• Lab instructions on the schedule page
• Submit report to Google group (link on schedule page)