Programmation appliquée en Scala

A Better switch

• Equivalent of switch

  val ch: Char = ...
  ch match {
    case '+' => println("Positive")
    case '-' => println("Negative")
    case _ => println("Zero")
  }

• No break, no fallthrough—only the first match is executed
• case _ is equivalent of default
• Like if, match is an expression:

  val sign = ch match {
    case '+' => 1
    case '-' => -1
    case _ => 0
  }

Variables and Guards

• Variables

  case ch => An expression using ch

• Think of case _ as a special case with unused variable
• Guards

  case ch if Character.isDigit(ch) => ...

• Caution: Variables must start with a lowercase letter.

  case Pi => ... // Matches constant Pi
  case ch => ... // Matches variable ch

Type Patterns

• Use case variable : Type

  obj match {
    case x: Int => x
    case s: String => Integer.parseInt(s)
    case _: BigInt => Int.MaxValue
    case _ => 0
  }

• Caution: If you omit the variable, you can match the companion object!

  obj match {
    case _: BigInt => ... // Matches if obj is a BigInt instance
    case BigInt => ... // Matches if obj is the BigInt companion object
  

What Value Can x Never Be?

x match {
  case Foo => 1
  case y: Foo => 2
  case foo => 3
  case _ => 4
}

1. 1
2. 2
3. 3
4. 4

Case Classes

• Optimized for pattern matching
• Get automatic methods apply, unapply, toString, equals, hashCode, copy
• Each constructor parameter becomes a val
• Example:

  abstract class Amount
  case class Dollar(value: Double) extends Amount
  case class Currency(value: Double, unit: String) extends Amount
  case object Nothing extends Amount
  

• Use in pattern match:

  amt match {
    case Dollar(v) => "$" + v
    case Currency(x, "CHF") => x + " swiss francs"
    case Nothing => ""
  }

Example: Option

• Option[T] is a safe alternative to “T or null”
• Case class Some[T] that wraps a value
• Case object None that indicates that there is no value.
• Example: Map[K, V].get returns an Option[V], either Some(v) or None
• Can use pattern matching to process

  val scores = Map("Alice" -> 1, "Bob" -> 2)
  scores.get("Alice") match {
    case Some(score) => println(score)
    case None => println("No score")
  }

• Or use getOrElse:

  println(scores.get("Alice").getOrElse("No score"))
  

• For maps, it's simpler to use the getOrElse of the map:

  println(scores.getOrElse("Alice", "No score"))
  

Extracting Matches

• Can extract values into variables or test for values:

  pair match {
    case (x, 0) => ... // Matches if pair._2 is 0
  }

• Use _ to match any value

  case Array(x, _) => ...

• Use _* to match a sequence (such as the tail of an array):

  case Array(0, _*) => ...
  case Array(1, x@_*) => ... // Binds x to tail

• For Seq, can instead use

  case 0 +: x

Extractors

• In factory method Classname(args), apply turns args into an object
• Opposite: extracting construction args

  val p = ... // some Point
  val Point(x, y) = p
  

• Also in pattern matching:

  p match {
    case Point(x, y) => ...
  }

• Doesn't construct a point!
• Defines x and y that, when passed to Point, make p
• Define unapply method:

  object Point {
    def unapply(input: Point) = Some((input.x, input.y))
    ...
  }
  

• Return a tuple ...
• ...wrapped into an Option, in case the match fails

How Many Are Valid?

val t1 = Tuple2(3, 4)
val t2 = new Tuple2(3, 4)
val t3 = Tuple2.apply(3, 4)
val t4 = new Tuple2.apply(3, 4)
val Tuple2(x, y) = t1
val Tuple2(a, b) = Tuple2.unapply(t1)
val t5 = Tuple2.unapply(t1)

1. 4
2. 5
3. 6
4. Something else

Infix Extractors

• Can use infix notation when unapply yields a pair:

  case x Point y => ...
  

• That's silly, of course. It's meant for lists and such:

case head :: tail => ...

• :: is a class!
• Particularly useful when matching more than one:

  case first :: second :: rest => ...
    // Same as case ::(first, ::(second, rest))

Lab

• You work with a buddy
• One of you (the coder) writes the code, the other (the scribe) types up answers
• When you get stuck, ask your buddy first!
• Switch coder/scribe roles each lab
• The coder submits the worksheet. Include the scribe's name in the worksheet!
• The scribe submits answers. Include the coder's name in the report!

Part 1: The Option Type

1. In this part, you will reimplement the Option type for Double values. Provide Option, Some, and None. What are they?
2. Write a function inv that maps x into its inverse (1 / x), returning an Option. Return None when x is zero. What is your function? What happens when you call inv(2)? inv(0)?
3. Define a method isEmpty that returns true for None and false for Some.
4. Now define a method get that returns the value wrapped in Some and throws a NoSuchElementException if there is no value. There are two ways of defining methods on an Option. You can either define a method in Option, using pattern matching. Or you can leave the method abstract in Option and override it in Some and None. In this step, use whichever approach you didn't use in the preceding step.
5. Define a method getOrElse that returns the value wrapped in Some and a default if there is no value. Do this by calling isEmpty/get

Part 2: Lists

1. In this part, you will implement a List type for Double values. A list is either Nil or a node with a head that's a Double and a tail that's again a List. Such a node is traditionally called a Cons node. Define the types List, Nil, and Cons.
2. Now write a function (outside any of these classes) that computes the sum of all elements in a list, using recursion and pattern matching. Test it with Cons(3, Cons(4, Cons(5, Nil))).
3. That's an ugly way of making lists. Instead, define a method of List called :: that lets you make a list as 3.0 :: 4.0 :: 5.0 :: Nil. What special rule for operators (briefly mentioned in Unit 7) makes this work?
4. Have a close look how 3.0 :: 4.0 :: 5.0 :: Nil is printed in the worksheet. Fix it by defining toString so that it shows up as 3.0 :: 4.0 :: 5.0 :: Nil.
5. Right now, to use pattern matching in lists, you write

   case Cons(h, t) => ...

   It would be prettier to write

   case h :: t => ...

   That's achieved by renaming the class Cons into ::. Do that, and fix up the sum function to match. Don't change the name of the :: method. There is both a :: method (used for construction) and a :: class (for extraction). You may run into a problem in your definition of the :: method. If you do, fix it by adding new.
6. Why didn't you have to define an unapply method in the preceding step?

Part 3: Expressions

1. An expression is either a number or an operation. Make case classes Num and Op so that one can make expressions such as

   Op("+", Op("*", Num(2), Num(3)), Num(4))

   Hint: You need a common superclass, like this:

   abstract class Expr
   case class Op(...) extends Expr

2. Write a function eval that evaluates an expression such as the one given above. Use pattern matching and recursion:

   def eval(e: Expr): Int = e match { ... }
   

Homework

Do this as individual work, not with your partner

When all done, email the signed zip files to Fatemeh.Borran@heig-vd.ch

• Problem 1
• Problem 2
• Problem 3
• Problem 4
• Problem 5