Programmation appliquée en Scala

Classes

• A simple class:

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

• Three methods: move, distanceFromOrigin, toString
• Need override when overriding methods (here Object.toString)
• No () for parameterless accessor methods
• Two instance variables x, y with getters, call p.x, p.y
• This is an immutable class—can't change the val fields
  • move yields a new object!
• Unrelated aside: string interpolation

  s"Hello, ${x}!"

  fills the value of the expression {x} into the string

Constructors

• A “primary constructor” called as new Point(3, 4)
• An “auxiliary constructor” called as new Point()
• Could have eliminated the auxiliary constructor by using default args:

  class Point(val x: Double = 0, val y: Double = 0)

• Can have arbitrary code in class body—part of primary constructor

  class Point(val x: Double, val y: Double) {
    println(s"Welcome to (${x}, ${y})")
      // Printed whenever a new point is constructed
    ...
  }

Classes—Differences from Java/C++

• Prefer immutable classes
• Use var for mutable instance variables

  class Point(var x: Double, var y: Double)

• “Uniform access principle:” In the expression p.x, you don't know whether x is a field or a method
• No fear of getters/setters
• Can also have private var or val, without getter/setters

  class BankAccount {
    private val balance = 0.0
    ...
  }

• Primary constructor parameters don't require val/var:

  class Point(x: Double, y: Double)
    // No accessors for x, y

  If x, y are used beyond the constructor, they become private instance variables.

How Many Instance Variables?

class Mystery(val x: Double, y: Double) {
  val z = x + y
  def foo = x + z
}

1. 1
2. 2
3. 3
4. Something else

More About Methods

• Infix notation: x op y is the same as x.op(y)
• Example: 1 to 10 map (3 * _) filter (_ % 5 == 2)
• Identifiers (method names, etc.) can be sequences of symbols

  class Point(...) {
    ...
    def *(factor: Double) = new Point(x * factor, y * factor)
  }

• p.*(2) or in infix p * 2
• If an operator ends in :, it is right-associative. E.g. if we want to define power operator ab, use a **: b

  a **: b **: c 

  is

  a **: (b **: c)

  See Unit 8 for a more natural example.
• apply method can be invoked with (...) notation. We've seen this with maps. map(key) is map.apply(key)

Objects

1. Use object for singletons, static methods

   object Accounts {
     private var lastNumber = 0
     def newUniqueNumber() = { lastNumber += 1; lastNumber }
       // Aside: Use () since it mutates state
   }

2. An object extending App is like main:

   object MyApp extends App {
      println(s"Hello, ${args(0)}!")
   }

Companion Objects

• “Companion object” of class = object with the same name in the same source file

  class Point { ... }
  object Point { ... }
  

• Have access to each other's private features
• Common to have apply in companion object for factory methods

  object Point {
    def apply(x: Double, y: Double) = new Point(x, y)
  }

• Client doesn't call new:

  val p = Point(3, 4) * factor
    // prettier than new Point(3, 4)
  

Traits

• A class can extend multiple traits
• Forces extending classes to provide certain features...
• ...which may have default implementations in the trait
• Trait methods can invoke others in a prior layer
• Traits cannot have construction parameters
  • Technically, this is the only difference between classes and traits

• trait Logger {
    def log(msg: String) { println(msg) }
  }
  
  class Point extends Logger {
    def move(dx: Double, dy: Double) = {
      log(s"Moving (${x} ${y}) by ${dx} ${dy}")
      new Point(x + dy, y + dy)
    }
    ...
  }
  
  trait TimestampLogger extends Logger {
    override def log(msg: String) {
      super.log(s"${new java.util.Date()} ${msg}")
    }
  }
    
  trait ShortLogger extends Logger {
    val maxLength = 15
    override def log(msg: String) {
      super.log(
        if (msg.length <= maxLength) msg 
        else msg.substring(0, maxLength - 3) + "...")
    }
  }
    
  val pt = new Point(3, 4) with TimestampLogger with ShortLogger
  pt.move(5, 6) // Prints Wed Mar 11 20:17:01 CET 2015 Moving (3.0 ... 
  

Reversing The Mixin Order

val pt2 = new Point(3, 4) with ShortLogger with TimestampLogger {
  override val maxLength = 20
}
pt2.move(5, 6)

What does it log?

1. Wed Mar 11 20:17:01 CET 2015 Moving (3.0 ...
2. Wed Mar 11 20:17:...
3. Wed Mar 11 20:17:01 CET 2015 Moving (3.0, 4.0 ...
4. Wed Mar 11 2...

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: It's About Time

1. Write a class Time with read-only fields hours and minutes, a method toString, and a method before(other: Time): Boolean that checks whether this time comes before the other. A Time object should be constructed as new Time(h, m), where h is between 0 and 23 and m between 0 and 59. If they aren't, call throw new IllegalArgumentException
2. Construct a couple of Time objects and test your before method.
3. Make it so that a full hour can be constructed as new Time(hrs). There are two different ways—what are they?

Part 2: Uniform Access

1. In a new worksheet, reimplement the Time class from the preceding exercise so that the internal representation is the number of minutes since midnight (between 0 and 24 × 60 – 1). Do not change the public interface.

   Do not use var or val in the primary constructor!

   class Time(hours: Int, minutes: Int) {
     private val minutesSinceMidNight = ...
     ...
   }

   Supply parameterless methods hours, minutes

2. Now we'll make this a little harder. In the original class, make hours and minutes into mutable fields, so that the following is ok:

   val start = new Time(13, 0)
   start.minutes = 15
   

   What did you have to do?
3. Do the same for the reimplemented class. You need to provide a setter method with the special name property_=:

   def minutes_=(newValue: Int) { ... }

4. In the original implementation, as changed in part 2b, it would have been possible to corrupt the field values by calling

   start.minutes = -100

   How can you avoid that in the modified implementation?
5. Explain what “uniform access” means in this context. What changes does a programmer using the Time class have to make when switching from the original to the reimplemented class?
6. Why are getters and setters less evil in Scala than in Java?

Part 3: Operators

Do the following with either the original or the reimplemented Time class (your choice).

• Change the before method of part 1 so that one can call

  if (t1 < t2) ...

• Add a method - that, given a Time object, yields the number of minutes between them (between -1439 and 1439).
• Make it so that a Time object can be constructed without calling new.