CSC 347 - Concepts of Programming Languages

Subtyping

Instructor: Stefan Mitsch

Learning Objectives

What should the type relationship between parameterized types be?

• Understand 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

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

Subtyping Order: Top

• 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
• In Scala: scala.AnyRef above reference types

import java.io.FileInputStream
val xs:List[AnyRef] = List ("hello", FileInputStream ("a.txt"))
val ys:List[Any]    = List ("hello", 1)

Subtyping Order: Bottom

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

• Recall Scala type hierarchy
• In Scala: Bottom is scala.Nothing
• Important for typing uses of Nil
  • Nil:List[Nothing]
  • List[Nothing]<:List[X]

val mynil1:List[Int]     = Nil
val    xs1:List[Any]     = "hello"::mynil1 // Best type possible
val mynil2:List[Nothing] = Nil
val    xs2:List[String]  = "hello"::mynil2 // Best type possible

Scala Lists

class A {  def f () = 1 }
class B extends A:
  override def f () = 2
           def g () = 3
var as:List[A] = List (A(), B()) // OK, because B <: A
var bs:List[B] = List (B(), B()) // OK

as = bs    // ok?
as(1).f()  // result: 2

Scala Arrays

class A {  def f () = 1 }
class B extends A:
  override def f () = 2
           def g () = 3
var as:Array[A] = Array (A(), B()) // OK
var bs:Array[B] = Array (B(), B()) // OK

as = bs
     ^
error: type mismatch;
       found   : Array[B]
       required: Array[A]
  Note: B <: A, but class Array is invariant in type T.
  You may wish to investigate a wildcard type such as '? <: A'

Why?

Invariance

class A {  def f () = 1 }
class B extends A:
  override def f () = 2
           def g () = 3
var as:Array[A] = Array (A(), B()) // OK
var bs:Array[B] = Array (B(), B()) // OK

as = bs        // ERROR, because Array[B] NOT <: Array[A]
as(0) = A()    // OK, because as:Array[A]
bs(0).g()      // Unsafe access

• Covariance only safe for read only structure

Wildcard?

class A {  def f () = 1 }
class B extends A:
  override def f () = 2
           def g () = 3
var as:Array[? <: A] = Array (A(), B()) // OK
var bs:Array[B]      = Array (B(), B()) // OK

as = bs         // OK, because Array[B] <: Array[? <: A]
as(0) = A()
        ^
error: type mismatch;
       found   : A
       required: ?1.T where ?1 is an unknown value of type Array[? <: A]

• Covariance only safe for read only structure, no way to write an array of type Array[? <: A]

Wildcard?

class A {  def f () = 1 }
class B extends A:
  override def f () = 2
           def g () = 3
var as:Array[A]      = Array (A(), B()) // OK
var bs:Array[? >: B] = Array (B(), B()) // OK

bs = as        // OK, because Array[A] <: Array[? >: B]
bs(0) = B()    // OK
bs(0).g()      // Unsafe access
      ^
error: value g is not a member of Array[? >: B]#T

• Contravariance safe for write only structure, degrade the type of read

Wildcard?

class A {  def f () = 1 }
class B extends A:
  override def f () = 2
           def g () = 3
var as:Array[A]      = Array (A(), B()) // OK
var bs:Array[? >: B] = Array (B(), B()) // OK

bs = as        // OK, because Array[A] <: Array[? >: B]
bs(0) = B()    // OK
bs(0)          // OK

val res1: Array[? >: B]#T = B@d271a54

• Contravariance safe for write only structure, degrade the type of read

Java Arrays Covariant

public class Driver {
  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)

• Java arrays are covariant
• 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]] (Array[X] xs) = ...

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

Three Types

class A {}           // Animal
class B extends A {} // Bird
class D extends B {} // Duck

Variance Annotations

trait Source[+X] { def get    () : X    } // Covariant 
trait Sink  [-X] { def put (x:X) : Unit } // Contravariant
class Ref   [ X] (var contents:X)         // Invariant
  extends Source[X] with Sink[X] {
    def get ()    = contents
    def put (x:X) = contents = x
}

val ref : Ref   [B] = Ref[B] (B())
val src : Source[A] = ref
val snk : Sink  [D] = ref

val d = D()
snk.put(d)
val r = ref.get()
val s = src.get()

val d: D = D@595713f3
val r: B = D@595713f3
val s: A = D@595713f3

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

Variance when B<:A

Summary

• Subtype polymorphism: A<:B (A is a subtype of B)
• Parametric polymorphism: T[X] parameterize class T with type parameter X
• Outside the scope of this course
  • Bounded polymorphism (Java, C#, Scala, Flow)
  • Java's use-site variance and wildcards
  • Adhoc polymorphism, typeclasses, implicit params
  • Check out Scala and Typescript