Path Dependent Types in Scala

| Comments

Often confusing to newer Scala developers, “Inner classes” in Scala do not behave the way they do in many other languages. Thus, they can be perceived to be ‘inconsistent’ from expectations in their behavior.

It isn’t possible, given the following class definition:

1
2
3
4
class Outer {
  class Inner
  def put(inner: Inner): Unit = ()
}

To instantiate the Inner class directly:

1
2
3
4
scala> new Outer.Inner
<console>:12: error: not found: value Outer
       new Outer.Inner
           ^

Instead, we need an instance of Outer to create an Inner instance:

1
2
3
4
val outer1 = new Outer
val inner1 = new outer1.Inner
val outer2 = new Outer
val inner2 = new outer2.Inner

In other words, the path to an Inner instance depends upon the Outer instance. Note as well that there is no true relationship between outer1.Inner and outer2.Inner:

1
2
3
4
5
6
7
scala> outer1.put(inner1)

scala> outer1.put(inner2)
<console>:16: error: type mismatch;
 found   : outer2.Inner
 required: outer1.Inner
       outer1.put(inner2)

The put method on outer1 will not accept just any arbitrary instance of Inner: It must receive one derived from its own instance. ”Great“, you may say, ”but where is this useful?”. In the end, a powerful use of Path Dependent types is creating a tighter coupling between two related classes, in which the compiler can help us avoid mistakes.

Imagine, if you will, a (relatively simple) model of Airplane, Seat, and Passenger:

1
2
3
4
5
6
7
case class Passenger(firstName: String, lastName: String, middleInitial: Option[Char])

class Airplane(flightNumber: Long) {
  case class Seat(row: Int, seat: Char)

  def seatPassenger(passenger: Passenger, seat: Seat): Unit = ()
}

Given two separate Airplanes, it should be impossible to accidentally sit on the wrong plane!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
scala> val flt102 = new Airplane(102)
flt102: Airplane = Airplane@4b8d604b

scala> val flt506 = new Airplane(506)
flt506: Airplane = Airplane@4dc27487

scala> val kelland = Passenger("Mike", "Kelland", None)
kelland: Passenger = Passenger(Mike,Kelland,None)

scala> val mcadams = Passenger("Brendan", "McAdams", Some('W'))
mcadams: Passenger = Passenger(Brendan,McAdams,Some(W))

scala> val nash = Passenger("Michael", "Nash", None)
nash: Passenger = Passenger(Michael,Nash,None)

scala> val flt102Seat1A = new flt102.Seat(1, 'A')
flt102Seat1A: flt102.Seat = Seat(1,A)

scala> val flt506Seat21A = new flt506.Seat(21, 'A')
flt506Seat21A: flt506.Seat = Seat(21,A)

scala> val flt506Seat20F = new flt506.Seat(20, 'F')
flt506Seat20F: flt506.Seat = Seat(20,F)

If three members of the BoldRadius team are headed on journeys, but only two are boarding the same flight… what if we are so wrapped up in conversation that one of us tries boarding the wrong plane?

1
2
3
4
5
6
7
8
9
scala> flt506.seatPassenger(nash, flt506Seat20F)

scala> flt506.seatPassenger(mcadams, flt506Seat21A)

scala> flt506.seatPassenger(kelland, flt102Seat1A)
<console>:19: error: type mismatch;
 found   : flt102.Seat
 required: flt506.Seat
       flt506.seatPassenger(kelland, flt102Seat1A)

Excellent! The compiler catches that while Michael Nash and myself are headed out on the same flight, Mike Kelland isn’t. When Mike tries to board the wrong flight… the type system prevents it.

In short, we can use the Path Dependent Type logic to prevent crossing over into runtime bugs – if we’re smart about our domain design.

Comments