CS 152 - Lecture 8

Cay S. Horstmann

Scala Classes

• A simple class:

  class Point(val x: Double, val y: Double) {
    def move(dx: Double, dy: Double) = new Point(x + dx, y + dy)
    def distanceFromOrigin = math.sqrt(x * x + y * y)
    override def toString = "(" + x + ", " + y + ")"
  }

• Constructor with two arguments.

  val myFirstPoint = new Point(3, 4)

• Five methods: x, y, move, distanceFromOrigin, toString
• Need override when overriding methods (here Object.toString)
• No () for parameterless accessor methods

Construction Parameters

• val parameter gives rise to instance variable and accessor

  Point(val x, val y)
  

• Parameter without val gives rise to instance variable without accessor.

  class Rand(gen: java.util.Random) { // No val
    def value = gen.nextInt()
  }

• Can also have private instance variable

  class Rand {
    private val gen = new java.util.Random(42)
    def value = gen.nextInt()
  }
  

• Calling superclass constructor:

  class LabeledPoint(x: Double, y: Double, val label: String)
    extends Point(x, y)
  

Scala Objects

• Scala object = class with only one instance
• Extend the App trait (similar to an interface) for an application object:

  object Main extends App {
    println("My first Scala App")
  }

• A class can have a companion object with methods that are similar to static methods in Java. Examples:

  List.tabulate
  Source.fromURL
  

• In Scaladoc, click on the circle with C or T to switch to the companion object, denoted with O
• math.ceil is not defined in an object—it's in the scala.math package

Case Classes

• Special kind of class, optimized for matching

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

• Example: Binary tree with values only in the leaves

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

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

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

  

Pattern Matching

• selectorExpr match { 
     case pattern => expr 
     ... 
     case pattern => expr 
  }

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

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

• Variables l, r, v are bound to the values in the case class instances; you can use them in the expressions.

  def sum(t : SimpleTree) : Int = t match { 
    case Node(l, r) => sum(l) + sum(r) 
    case Leaf(v) => v 
  }

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

  case _

Syntax Trees

• Tree that represents the syntax of a program (or a program part)
• Example: Expression tree for 3 + 4 * x

  

• Model in Scala:

  class Expr
  case class Number(value : Int) extends Expr
  case class Variable(name : String) extends Expr
  case class Operator(left : Expr, right : Expr, 
    f: (Int, Int) => Int) extends Expr

  Operator(Number(3), Operator(Number(4), Variable("x"), _ * _), _ + _)

• Next lecture: How to parse 3 + 4 * x into Scala value

Syntax Tree Evaluation

• Compute value of expression
• Need values of free variables
• Use a Map[String, Int]
• Scala immutable map refresher:
  • Map(key1 -> value1, key2 -> value2, ...) yields map with given key/value pairs
  • map + (key -> value) yields map with new key/value pair
  • map(key) yields value of key (must exist)
  • map.get(key) yields Option, either Some(value)or None

• def eval(expr : Expr, symbols : Map[String, Int]) : Int = 
    expr match {
      case Number(num) => num
      case Variable(name) => symbols(name)
      case Operator(left, right, f) => f(eval(left, symbols), eval(right, symbols))
    }

Functions with Variable Arguments

• Want to call a function as:

  val result = sum(1, 7, 2, 9)
  val result2 = sum(3, 1, 4, 1, 5, 9, 2, 6)

• Define the argument type as Int*

  def sum(args: Int*) = args.reduce(_ + _)

• Argument is wrapped into a Seq[Int]
• If you already have a Seq[Int], you cannot pass it directly.
• Use : _* ascription:

  val s = sum(1 to 5: _*) // Consider 1 to 5 as an argument sequence
  

• Necessary in recursive definitions:

  def recursiveSum(args: Int*) : Int = {
    if (args.length == 0) 0
    else args.head + recursiveSum(args.tail : _*)
  }

Lab

• You work with a buddy
• One of you writes the code (coder), the other types up answers (scribe)
• When you get stuck, ask your buddy first!
• Switch roles each lab. The previous scribe is the coder for this lab.
• The scribe submits lab work in lab7/report.txt inside the Git repo. Include the coder's name in the report!
• If the coder wants to submit something, that's cool too. Do whatever is easy.

Step 1

Add the classes Expr, Number, Variable, Operator to a Main.scala file, inside a Main object. Add the eval method to the Main object. In the body of the Main object, construct the tree

print it and and evaluate it with a symbol table in which x is 5. What is the code of your Main.scala file?

Step 2

Now we want to process variable definitions (which we will write as val x = expr in the next lecture). For now, we will assume that they are already parsed into instances of

case class Definition(name : String, expr : Expr)

For example, a definition val x = 2 would be a Definition("x", Number(2)). A definition changes the symbol table. In a functional setting, that means we need to return a new table that contains all bindings in the old table and the new binding. For example,

val def1 = Definition("x", Number(2))
val def2 = Definition("y", Variable("x"))
val sym0 = Map[String, Int]()
val sym1 = eval(def1, sym0) // "x" -> 2
val sym2 = eval(def2, sym1) // "x" -> 2, "y" -> 2
System.out.println(sym2)

Implement this eval method. What is the code of your method? (You can get the fields of a definition as defi.name, defi.expr.)

Note: This eval method requires you to call the eval method that we defined for expressions, but it is a different method—it consumes a definition and a symbol table, yielding another symbol table.