Concepts of Programming Languages

Dynamic/Static Types

Instructor: Stefan Mitsch

Types

• Types define offsets

  
  struct Node { int value; Node* next; }
  Node* getNext (Node* x) {
    return x->next;  
  }
                

• Types determine valid operations

  
  class Main () {
    public static void main (String[] args) {
      System.out.println( 1 - 2 );
      System.out.println( "dog" - "cat" );
    }
  }
                

Type enforcement

• Statically, track types with compiler
  • Compile time
  • Early
• Dynamically, store type with object
  • Run time
  • Late

Types in C

• C does not enforce types. Why have them?
• Only to compute offsets

struct Node { int value; Node* next; }
Node* getNext (Node* x) {
  return x->next;
}
          

Example: Scheme / Dynamic

• Dynamic type checking detects a failure
• How do we know this is dynamic?
• Type checker invoked before execution starts?

#;> (- 5 "hello")
Error in -: expected type number, got '"hello"'.
          

Example: Scheme / Dynamic

• Defer computation to function body
• Failure is when f runs
• Conclusion: no type checking before execution

#;> (define (f) (- 5 "hello"))
#;> (f)
Error in -: expected type number, got '"hello"'.
          

Java is Static

• javac rejects code with (5 - "hello")

$ javac Typing01.java
Typing01.java:5: error: bad operand types for binary operator '-'
    System.out.println ("Result = " + (a - b));
                                         ^
  first type:  int
  second type: String
          

class Typing01 {
  public static void main (String[] args) {
    int a = 5;
    String b = "hello";
    System.out.println ("Result = " + (a - b));
  }
}
          

Java is Dynamic

• We can make the error dynamic by casting

$ java Typing01
ClassCastException: class String cannot be cast to class Integer
	at Typing01.main(Typing01.java:5)
          

class Typing01 {
  public static void main (String[] args) {
    int a = 5;
    String b = "hello";
    System.out.println ("Result = " + (a - (int)(Object)b));
  }
}
          

Variables in Static Languages

• In static languages, variables also have types

$ javac Typing06.java 
Typing06.java:4: error: incompatible types: String cannot be converted to int
    a = "hello";
        ^
          

class Typing06 {
  public static void main (String[] args) {
    int a = 5;
    a = "hello";
  }
}
          

Static to Dynamic

• We can convert any static error into a dynamic one

$ java Typing06      
ClassCastException: class String cannot be cast to class Integer
	at Typing06.main(Typing06.java:4)
          

class Typing06 {
  public static void main (String[] args) {
    int a = 5;
    a = (int)(Object)"hello";
  }
}
          

Java var

• Java infers the most precise type possible for a var

$ javac Typing06.java
Typing06.java:4: error: incompatible types: String cannot be converted to int
    a = "hello";
        ^
          

class Typing06 {
  public static void main (String[] args) {
    var a = 5;
    a = "hello";
  }
}
          

Variables in Dynamic Languages

• Variables do not have types in dynamic languages
• Only values have types.

#;> (define (main)
       (define a 5)
       (set! a "hello")
       (display a)
    )
#;> (main)
"hello"
          

Tradeoffs

• Dynamic:
  • more flexible
  • usually conceptually simpler
  • faster compilation
  • easier runtime code generation/modification
• Static:
  • compile-time detection of errors
  • no unit tests for type checking
  • automatic documentation
  • faster runtime (dynamic checks, optimization)
  • less memory consumption at runtime

Static Type Checking

• Static types are conservative

  
    int f (int i, String s) {
      return true ? i : s;
    }
                

• Static types may use type inference

  
    var x = 1;
                

• Static types may be separate from the program, as in Flow