Subtypes

East has a strong, static type system to enable safety and speed. However, static type systems have a reputation for being challenging to use and adding overhead to development. East has affordances to make the static type system easier to use, including a structural type system and flow typing (or type inference).

Other way East makes life easier for developers is by accepting a subtype of any expected type, and unifying the types of returned from branching code. The system is designed so that programmers only need to consider the possible values flowing through their program, without the static type system getting in the way.

Subtyping

In many cases a value of a particular type is expected in a certain part of an expression. A simple example is the predicate in an IfElse statement, which must be a BooleanType value. More complex cases arise when adding entries to an array or updating values in a compound data structure.

In these cases the expected type might be quite complex. When you create an expression the type will be automatically inferred. Sometimes a type might be "narrower" or a subtype of the expected type. If an expression can create only a subset of the allowable values, the resulting program will function.

A type T1 is a subtype of type T2 if and only if all values of type T1 are also values of T2. That also means each type is a subtype of itself!

Here you run learn several situations where subtyping may occur.

Nullable types

A type like Nullable(IntegerType) will accept either null or an integer. A null value will be accepted whether it has type NullType or Nullable(IntegerType). Similarly, an integer value of type IntegerType is also acceptable. Thus, NullType and IntegerType are both subtypes of Nullable(IntegerType).

More generally, NullType and T are both subtypes of Nullable(T).

Struct types

Structs are only compatible if they have the same number and names of fields (in exactly the same order).

To determine if a struct is a subtype of another each field type needs to be a subtype of the corresponding field type.

Variant types

There are two things to consider with variant subtypes.

First are the cases. If a variant type only has subset of the cases of another, then it may be a subtype.

Secondly, for the overlapping cases the associated data of the first variant type must be a subtype of the second variant type.

Array types

The type ArrayType(T1) is a subtype of ArrayType(T2) if and only if T1 is a subtype of T2.

All arrays are given a static type upon construction. Any expression for a value placed into an array (via NewArray, Insert or Update) can be subtype of the array's value type.

Set types

Currently the key type of a set is restricted to StringType, so subtyping does not affect sets.

Dictionary types

Currently the key type of a dictionary is restricted to StringType, so subtyping does not relate to the keys of a dictionary.

The type DictType(K, T1) is a subtype of DictType(K, T2) if and only if T1 is a subtype of T2.

All dictionaries are given a static type upon construction. Any expression for a value placed into a dictionary (via NewDict, Insert or Update) can be subtype of the dictionary's value type.

Type unification

Another thing that East does automatically is type unification. When two or more code branches (like the true and false branches of IfElse) produce different East types, the types are unified. To do so "narrowest" type for which each branch is a subtype is sought.

Consider for example IfElse(predicate, "abc", null). The first branch returns a string. The second branch returns null. The type Nullable(StringType) covers all possible return values.

Another example is IfElse(predicate, Some("abc"), None). The first branch return a variant with case some and a string value, or VariantType({ some: StringType }). The second branch returns a variant with case none and a null value, or VariantType({ none: NullType }). The type VariantType({ none: NullType, some: StringType, }) includes all possible values from both branches (which is the same type as OptionType(StringType)). Note that the EDK will automatically order the variant cases by their case name. This means that the expressions IfElse(predicate, Some("abc"), None) and IfElse(predicate, None, Some("abc")) return compatible types that obey the same ordering relationships. (Other programming languages use nominal sum types to avoid this issue.)

Finding the minimal such type is relatively straightforward. You can descend through the data structures recursively, merging NullType with any type to make it nullable, and merging the different possible cases of variants.

Next steps

Continue to the next section to understand how to use and manipulate dynamically-sized collections of data with East and Elara using arrays, sets and dictionaries.