CS 152 - Lecture 16

Cay S. Horstmann

What Are Types?

• Type = set of values + permitted operations on these values
• Example: int in Java. Set of numbers between Integer.MIN_VALUE and Integer.MAX_VALUE. Operations +, -, *, etc.
• Used for
  • IDE help
  • Code generation
  • Error handling

Types in Java/Scala

• 8 primitive types: int short long byte char float double boolean
• Every other type is a reference type
• Classes
• Interfaces
• Arrays
• These are types of variables. Values cannot have interface type, but they can be null. (Null type)
• Additional Types in Scala
  • Tuple types (String, Int)
  • Function types (String, String) => Int

Strong Typing

• Strong typing: Compiler and run-time system guarantee that no type error can occur in a program
• Example: Compiler catches "Hello".println(). String has no such method
• Not all Java errors are caught at compile-time.

  String[] words = { "Hello", "World" };
  Object[] objs = words; // compiles: Can convert String[] to Object[]
  objs[0] = new Watermelon(); // compiles. Can convert Watermelon to Object
  // Oops: Now words[0] is a Watermelon!

  Causes ArrayStoreException at run-time.

• C/C++ are not strongly typed:

  int luckyNumbers[] = { 17, 29 };
  double* values = (double*) luckyNumbers; // compiles
  double x = values[0]; // may not be a legal floating-point value

Static and dynamic typing

• Static typing: All type errors are caught at compile-time; program will never raise a type error at run-time.
• Java is mostly, but not fully statically typed: NullPointerException, ArrayStoreException
• Some languages are much more dynamic than Java. Ex. JavaScript

  val x = "Hello"
   ...
  x = new Duck();
   ...
  x.quack()

  Variables have no types, but values do. Errors caught at run-time ("Duck typing").

• Scala is like Java

  val x = "Hello" // x is inferred to be String

Parameterized Types in Scala

• Simple example:

  class Pair[T](val first: T, val second: T)

• Scala can infer type from construction parameters:

  val p1 = new Pair(17, 29) // Pair[Int]
  val p2 = new Pair("Hello", "World") // Pair[String]

• Can also have generic functions

  def firstTwo[T](a : Array[T]) = new Pair(a(0), a(1))

Type Bounds

• In Scala, generic functions are type-checked when they are defined, not when they are instantiated
• The following won't compile:

  def min[T](p : Pair[T]) = if (p.first < p.second) p.first else p.second

• No guarantee that

  p.first < p.second

  is defined—depends on whether T has <

• Trait Ordered[T] ensures that t < t2 operator exists for t ∈ T
• Use type bound

  def min[T <: Ordered[T]](p : Pair[T]) = if (p.first < p.second) ...

• Now we know that p.first < p.second is valid

• Technical problem when using Java types: Int is always converted to Scala RichInt, and RichInt <: Ordered[Int].
• Use <% instead of <: if you want to allow conversions

  def min[T <% Ordered[T]](p : Pair[T]) = if (p.first < p.second) ...

Variance

• Suppose Student <: Person (i.e. every student is a person). Should an array of students be a subtype of “array of Person objects”?
• In Java, the answer is YES. Virtual machine monitors every array store and throws an exception when an object of the wrong type is stored.
• Scala: By default, generic types are invariant. That is, no relationship between G[S] and G[T]
• Ex. No relationship between Array[Student] and Array[Person]
• Some Scala types are covariant. For example, immutable lists:

  class List[+T]

  Now List[Student] <: List[Person]

• In general, G[+T] means that S <: T ⇒ G[S] <: G[T]
• Similar, contravariance

  trait Function1 [-T1, +R]

  Function1[Person, String] <: Function1[Student, String]

Immutable List Example

abstract class GList[+T] {
  def isEmpty : Boolean
  def head : T 
  def tail : GList[T]
}

case class GEmpty[T]() extends GList[T] {
  override def isEmpty : Boolean = true
  override def head = error("No head")
  override def tail = error("No tail")
}

case class GNonEmpty[T](hd : T, tl : GList[T]) extends GList[T] {
  override def isEmpty : Boolean = false
  override def head = hd
  override def tail = tl
}

• Note that the list has no mutator—no issue with storing a bad value
• If you add a bad value, you just get a list of a weaker type

  scala> val foo = GNonEmpty("foo", GEmpty[String]())
  foo: GNonEmpty[String] = GNonEmpty(foo,GEmpty())
  
  scala> val bar = GNonEmpty(1, foo)
  bar: GNonEmpty[Any] = GNonEmpty(1,GNonEmpty(foo,GEmpty()))

Positional Safety Checks

• Problem with covariance: stores
• But stores are not the only problem

  class BadStack extends Stack[Double] { 
     override def push(e : Double) = { super.push(sqrt(e)) } 
  } 

• Of course BadStack <: Stack[Double]
• Is Stack[Double] <: Stack[AnyRef]? It better not be:

  Stack[AnyRef] bad = new BadStack(); 
  bad.push("Yikes!"); // calls sqrt("Yikes!")

• Scala: Cannot use covariant T in “contravariant positions”

  Ex. Can't have parameters of covariant T

  class Stack[+T] {
     def pop() : T = ... // OK
     def push(newValue : T) { ... } // ERROR--T is parameter type
     def isEmpty = ...
  }

Lower Bounds

• Can fix push variance problem by making push into a generic method

• class Stack[+T] {
    def push[N >: T](newValue : N) : Stack[N] = new NonEmptyStack[N](newValue, this)
    ...
  }

• T no longer appears as a parameter type of push (parameter is N)
• Lower bound is a covariant position
• Reasonable behavior: Push a supertype object, and you get a more general stack
• Now you can't override push in BadStack

What about Java?

• Java has generic types such as List<T>, Comparator<T>
• As in Scala, there is no intrinsic relationship between List<Person>, List<Student>
• In Java has no covariant or contravariant types.
• Java uses wildcards for use-site variance:

  public static void add(List<Person> people, List<? extends Person> morePeople)
  public static void sort(List<Person> people, Comparator<? super Person> comp)
  

• That was a good tradeoff in 2004
  • Java collections are mutable
• Not so much in 2014

  • public interface Function<T, R> {
       default <V> Function<T,V> andThen​(Function<? super R,? extends V> after)
       ...
    }

  • In Scala, Function1[-T1, +R]

Lab

Step 1: Invariance

We'll start with these classes. Add them to a Scala file.

class Person(val name : String) {
  override def toString = getClass.getName + "[name=" + name + "]" 
}

class Student(name : String, val id : Int) extends Person(name) {
  override def toString = super.toString + "[id=" + id + "]" 
}

object Main extends App {
  val harry = new Person("Harry Smith")
  val sally = new Person("Sally Jones")
  val diana = new Student("Diana Lee", 1729)
  val frank = new Student("Frank Miller", 2525)
}

1. Add a line of code to demonstrate that Student <: Person, that is, a Student object can be converted to the Person type.
2. Add a line of code to demonstrate that an Array[Student] can not be converted to Array[Person].
3. What happens if you try List instead of Array? Why?
4. What happens when you add a Person to a List[Student]? Does it work? If so, what is the type of the result?

Step 2: Co- and Contravariance

1. Add the generic class

   class MyPair[T](val first: T, val second: T)

   Is MyPair(Student) a subtype of MyPair(Person)? How did you determine the answer? (Note: There is already a Pair[S, T] in Scala.)

2. What change do you have to make to the MyPair class to fix the issue of the preceding question? (Hint: It's a very small change.)
3. Add the following method to the MyPair class:

   def sum(f : Function1[T, Int]) = f(first) + f(second)

   Make objects (with explicit types for extra clarity)

   val f : Function1[Student, Int] = { x : Student => x.id }
   val g : Function1[Person, Int] = { x : Person => x.name.length }
   val p : MyPair[Student] = new MyPair(diana, frank) 

   Can you call p.sum(f)? p.sum(g)? If so, what are the results?

4. It's not surprising that p.sum(f) works. p is a MyPair[Student] and f is a Function1[Student, Int]. But why does p.sum(g) work, even though the types don't match?

Step 3: Type Bounds

1. Add the following method to the MyPair class:

   def max = if (first < second) second else first

   Why won't the code compile?

2. How do you fix the MyPair class so that the max function compiles?
3. Make some sample code to compute new MyPair(17, 29).max. Did it compile? If not, what fix did you need to make?
4. Now try forming a MyPair of two Person objects. What happens?
5. How can you fix this?
6. Now make a MyPair[Student] and weep.