- Concepts of Programming Languages

Subtyping

Instructor:

Learning Objectives

What should the type relationship between parameterized types be?

• Identify read and write restrictions on parametric types

Checked Casts

• Recall lecture on safety

class A { int x; }
class B extends A { float y; }
class C extends A { char c; }
void f (B b) {
  A a = b;       // upcast always safe
}
void g (A a) {
  B b = (B) a;   // downcast must be checked
}
f (new B()); // OK
g (new C()); // ClassCastException

What makes upcasting safe? What makes downcasting unsafe?

Subtyping

Subtyping Order: Top

• Subtyping relation <: is a partial order on types
  • reflexive: X<:X
  • transitive: if Duck<:Bird and Bird<:Animal then Duck<:Animal

• Some PLs have a Top type: X<:Top for all X (greater than all other types)
• In Java: java.lang.Object above reference types
• In Scala: scala.Any above all types, scala.AnyRef above reference types

  val xs:List[AnyRef] = List ("hello", List(1))
  val ys:List[Any]    = List ("hello", 1)
  

Subtyping Order: Bottom

• Most PLs do not have a Bottom<:X for all X (less than all other types)

• In Scala Type Hierarchy: Nothing is Bottom type

• What is Bottom useful for?

• Important for typing uses of Nil

  val nil:List[String] = Nil
  // Best type possible
  val xs1:List[String] = "hello" :: nil
  val xs2:List[Any]    = 1 :: nil
  

  val nil:List[Nothing] = Nil
  // Best type possible
  val xs1:List[String] = "hello" :: nil 
  val xs2:List[Int]    = 1 :: nil 
  

• Nil : List[Nothing] and List[Nothing] <: List[X], so
  (X :: List[Nothing]) : List[X]

Type-Invariant Containers

abstract class Animal { def name: String }
case class Bird(name: String) extends Animal
case class Cat(name: String) extends Animal
case class Box[X](var content: X)

Type-Invariant Containers

What would go wrong if we allow assignment?

val birdBox = Box(Bird("Feathers"))
var animalBox: Box[Animal] = birdBox // does not compile

• val animal: Animal = animalBox.content  // ok, we can read bird as an animal
  

• animalBox.content = Cat("Fluffy") // we can put a cat into an animal box
  

• val bird: Bird = birdBox.content     // but now the bird box contains a cat!
  

• Writing to aliased container would create type violations!

Type-Covariant Containers

What if we disallow modifying boxes?

case class ImmutableBox[+X](val content: X)

• Create and alias boxes

  val birdBox = ImmutableBox(Bird("Feathers"))
  val animalBox: ImmutableBox[Animal] = birdBox // compiles
  val animal = animalBox.content                // reading ok
  animalBox.content = Cat("Fluffy") // immutable, cannot write
  

• ImmutableBox is covariant in X

• Covariance type annotation +X can only be applied to read-only structures

Covariant Boxes

What is the practical relevance?

def printAnimalName(b: ImmutableBox[Animal]) =
  println(b.content.name)

• Print some concrete boxes

  val birdBox = ImmutableBox(Bird("Feathers"))
  val catBox  = ImmutableBox(Cat("Fluffy"))
  printAnimalName(birdBox)
  printAnimalName(catBox)
  

Scala Lists are Covariant

What is the practical relevance?

def printAnimalNames(animals: List[Animal]) =
  for a <- animals do println(a.name)

• Print some concrete lists

  val birds: List[Bird] = List(Bird("Feathers"), Bird("Chirpy"))
  val cats: List[Cat]   = List(Cat("Fluffy"), Cat("Whiskers"))
  printAnimalNames(birds)
  printAnimalNames(cats)
  

• List must be covariant to allow printAnimalNames with concrete arguments of type List[Bird] and List[Cat]!

Scala Arrays are Invariant

def printAnimalNames(animals: Array[Animal]) =
  for a <- animals do println(a.name)
val birds: Array[Bird] = Array (Bird("Feathers"), Bird("Chirpy"))
printAnimalNames(birds)

• Compile error

  printAnimalNames(birds)
                   ^^^^^  
                   Found: (birds : Array[Bird])
                   Required: Array[Animal]
  

• Scala and Java arrays are readable and writable

  • Scala arrays are invariant: compile error when writing to alias
  • Java arrays are covariant: runtime exception when writing to alias

Covariant Wildcard

How can we still print arrays generically?

• Use a covariant wildcard to make array read-only

  def printAnimalNames(animals: Array[? <: Animal]) =
    for a <- animals do println(a.name)
  val birds: Array[Bird] = Array (Bird("Feathers"), Bird("Chirpy"))
  printAnimalNames(birds) // compiles
  

• No way to write to Array[? <: Animal]

  animals(0) = Cat("Fluffy")
               ^^^^^^^^^^^^^
               Found:    Cat
               Required: animals.T
  

What about Writing?

def putCat(box: Box[Cat]) =
  box.content = Cat("Fluffy")

• Unable to pass in a box of animal

  val animalBox: Box[Animal] = Box(Cat("Whiskers"))
  putCat(animalBox)
         ^^^^^^^^^
         Found:    (animalBox : Box[Animal])
         Required: Box[Cat]
  

• Because the animal box could be a bird box

  val animalBox: Box[Animal] = Box(Bird("Feathers"))
  putCat(animalBox)
  

Contravariance

What if we disallow reading?

class MutableBox[-X](content: X):
  private var x: X = content
  def put(elem: X) : Unit = x = elem

• Create and alias boxes

  def putCat(box: MutableBox[Cat]) = box.put(Cat("Fluffy"))  
  val animalBox: MutableBox[Animal] = new MutableBox(Cat("Whiskers"))
  putCat(animalBox)
  

• MutableBox is contravariant in X

• Contravariance type annotation -X can only be applied to write-only structures

Contravariance allows Degraded Read

class MutableBox[-X](content: X):
  private var x: X = content
  def put(elem: X) : Unit = x = elem
  def get : Any = x
def putCat(box: MutableBox[Cat]) = box.put(Cat("Fluffy"))

• Create box and modify it

  val animalBox: MutableBox[Animal] = new MutableBox(Bird("Feathers"))
  var animal: Any = animalBox.get
  putCat(animalBox)
  animal = animalBox.get
  

Contravariant Wildcard

def addFluffy(cats: List[Cat]) = 
  Cat("Fluffy") :: cats

• Add to a list of cats

  val cats: List[Cat] = List(Cat("Whiskers"))
  val moreCats: List[Cat] = addFluffy(cats) // ok
  

• Add to a list of animals

  val animals: List[Animal] = List(Bird("Feathers"), Cat("Whiskers"))
  addFluffy(animals)
            ^^^^^^^
            Found:    (animals : List[Animal])
            Required: List[Cat]
  

Contravariant Wildcard

def addFluffy(cats: List[? >: Cat]) = 
  Cat("Fluffy") :: cats

• Contravariant wildcard ? >: X

• Add to a list of animals

  val animals: List[Animal] = List(Bird("Feathers"), Cat("Whiskers"))
  val more: List[Any] = addFluffy(animals)
  

• Can we do better than List[Any]?

Contravariant Type Parameter

• Use a contravariant type parameter rather than a wildcard

def addFluffy[X >: Cat](cats: List[X]) = 
  Cat("Fluffy") :: cats

• Add to a list of animals

  val animals: List[Animal] = List(Bird("Feathers"), Cat("Whiskers"))
  val moreAnimals: List[Animal] = addFluffy(animals)
  

Summary

• Subtype polymorphism: B<:A (B is a subtype of A)
• Parametric polymorphism: T[X] parameterize class T with type parameter X

• Covariant, contravariant, and invariant parametric types for B<:A

  	Covariant	Contravariant	Invariant
  	Readable	Writable	Read-write
  Relationship	T[B] <: T[A]	T[A] <: T[B]	T[A]<>T[B]
  Box	ImmutableBox[X]	MutableBox[X]	Box[X]
  Collection	List[X]		Array[X]
  Annotations	T[+X]	T[-X]	T[X]
  Functions	Unit=>X	X=>Unit	X=>X

Java Arrays are Covariant

public static void main (String[] args) {
  B[] bs = new B[] { new B (), new B () };
  A[] as = bs;      // OK, because covariant
  as[0] = new A (); // ArrayStoreException
  bs[0].g(); 
}

$ javac Driver.java 
$ java Driver
Exception in thread "main" java.lang.ArrayStoreException: A
  at Driver.main(Driver.java:5)

• Every assignment to object array dynamically checked!

Why?

• For example, to sort

  static void sort(Object[] xs) { ... }
  String[] ss = ...;
  sort(ss); // requires covariance
  

static <X extends Comparable<? super X>> void sort(X[] xs) { ... }

def sort[X <: Comparable[? >: X]] (xs: Array[X]) = ...

• Use

  class A implements Comparable<A>{}
  class B extends A {}
  B[] bs = ...;
  sort(bs); // B's are comparable as A's
  

Variance Annotations Example

trait Source[+X] { def get    () : X    } // Covariant: read-only
trait Sink  [-X] { def put (x:X) : Unit } // Contravariant: write-only

class Ref   [ X] (var contents:X)         // Invariant: read-write
  extends Source[X] with Sink[X]:
    def get ()    = contents
    def put (x:X) = contents = x

Variance Annotations Example

trait Function[-X,+Y] { def apply(x:X) : Y    } // Contravariant in X, covariant in Y

• Covariant use

  // List[Int] <: Seq[Int], so Function[Int,List[Int]] <: Function[Int,Seq[Int]]
  val increment: Function[Seq[Int],Seq[Int]] = new Function[Seq[Int],List[Int]]:
    def apply(x: Seq[Int]) : List[Int] = x.map(_ + 1).toList
  // Int <: Any, so Function[Seq[Int],Int] <: Function[Seq[Int],Any]
  val length: Function[Seq[Int],Any] = new Function[Seq[Int],Int]:
    def apply(x: Seq[Int]) : Int = x.length
  

• Contravariant use

  def chain(f: Function[List[Int],Seq[Int]], g: Function[Seq[Int],Any]) =
    (x:List[Int]) => g(f(x))
  chain(increment, length)
  

Variance Annotations

trait Producer[+Y]    { def apply ()    : Y    } // Covariant
trait Consumer[-X]    { def apply (x:X) : Unit } // Contravariant
trait Function[-X,+Y] { def apply (x:X) : Y    } // Both
trait Operator[X]     { def apply (x:X) : X    } // Invariant

trait Producer[-Y]    { def apply ()    : Y    }
                            ^
error: contravariant type Y occurs in covariant position

trait Consumer[+X]    { def apply (x:X) : Unit }
                                   ^
error: covariant type X occurs in contravariant position