Flow-sensitive typing

In programming language theory, flow-sensitive typing (or flow typing) is a type system where the type of an expression depends on its position in the control flow.

In statically typed languages, a type of an expression is determined by the types of the sub-expressions that compose it. However, in flow-sensitive typing, an expression's type may be updated to a more specific type if it follows a statement that validates its type. The type is determined by using type inference and type information is carried using algebraic data types.

Example

 1 // Object? means the variable "name" is of type Object or else null
 2 void hello(Object? name) {
 3     if (is String name) {
 4         // "name" now has type String in this block
 5         print("Hello, ``name``!");
 6         // and it is possible to call String methods on the variable
 7         print(" String.size is ``name.size``");
 8     }
 9     else if (exists name) {
10         // "name" now has type Object in this block
11         print("Hello, object ``name``!");
12     }
13     else {
14         print("Hello, world!");
15     }
16 }
17 
18           
19 hello(null);
20 hello(1);
21 hello("John Doe");

Hello, world!
Hello, object 1!
Hello, John Doe!
 String.size is 8

 1 fun hello(obj: Any) {
 2     // A type cast fails if `obj` is not a String
 3     obj as String
 4 
 5     // Since the type cast did not fail, `obj` must be a String!
 6     val l = obj.length
 7 
 8     println("'$obj' is a string of length $l")
 9 }
10           
11 hello("Mooooo")

Benefits

This technique coupled with type inference reduces the need for writing type annotations for all variables or to do type casting, like is seen with dynamic languages that use duck typing. It reduces verbosity and makes up for terser code, easier to read and modify.

It can also help language implementers to provide faster implementations for dynamic languages by statically predicting the type of objects.^[1]

Finally, it increases type safety and can prevent problems due to null pointers, labeled by C.A.R. Hoare—the null reference inventor—as "the billion dollar mistake"^[2]

Implementations

Whiley, created by David J. Pearce, was the first language to make use of flow-sensitive typing in 2009.^[3][4]

Since this introduction, other languages have made use of it, namely Ceylon,^[5] Kotlin,^[6][7] TypeScript^[8] and Facebook Flow.^[9]

External references