Depth Subtyping

 

Assume we have two classes, which have a subtype relationship:

1
2
 
class Person { name: string }
class Employee extends Person { department: string }

It’s valid to use an Employee instance where a Person instance is expected.

1
2
3
4
5
6
 
// @flow
class Person { name: string }
class Employee extends Person { department: string }

var employee: Employee = new Employee;
var person: Person = employee; // OK

However, it is not valid to use an object containing an Employee instance where an object containing a Person instance is expected.

1
2
3
4
5
6
7
 
// @flow
class Person { name: string }
class Employee extends Person { department: string }

var employee: { who: Employee } = { who: new Employee };
// $ExpectError
var person: { who: Person } = employee; // Error
Cannot assign `employee` to `person` because `Employee` [1] is incompatible with `Person` [2] in property `who`. [incompatible-type]

This is an error because objects are mutable. The value referenced by the employee variable is the same as the value referenced by the person variable.

1
 
person.who = new Person;

If we write into the who property of the person object, we’ve also changed the value of employee.who, which is explicitly annotated to be an Employee instance.

If we prevented any code from ever writing a new value to the object through the person variable, it would be safe to use the employee variable. Flow provides a syntax for this:

1
2
3
4
5
6
7
8
 
// @flow
class Person { name: string }
class Employee extends Person { department: string }

var employee: { who: Employee } = { who: new Employee };
var person: { +who: Person } = employee; // OK
// $ExpectError
person.who = new Person; // Error!
Cannot assign `new Person` to `person.who` because property `who` is not writable. [cannot-write]

The plus sign indicates that the who property is “covariant.” Using a covariant property allows us to use objects which have subtype-compatible values for that property. By default, object properties are invariant, which allow both reads and writes, but are more restrictive in the values they accept.

Read more about property variance.

← Nominal & Structural Typing Width Subtyping →

Was this guide helpful? Let us know by sending a message to @flowtype.