Types
This document is a living document and may not represent the current implementation of Flux. Any section that is not currently implemented is commented with a [IMPL#XXX] where XXX is an issue number tracking discussion and progress towards implementation.
A type defines the set of values and operations on those values. Types are never explicitly declared as part of the syntax except as part of a builtin statement. Types are always inferred from the usage of the value. Type inference follows a Hindley-Milner style inference system.
Union types
A union type defines a set of types. In the examples below, a union type is specified as follows:
T = t1 | t2 | ... | tn
where t1
, t2
, …, and tn
are types.
In the example above a value of type T
is either of type t1
, type t2
, …, or type tn
.
Basic types
All Flux data types are constructed from the following types:
Null types
The null type represents a missing or unknown value. The null type name is null
. There is only one value that comprises the null type and that is the null value. A type t
is nullable if it can be expressed as follows:
t = {s} | null
where {s}
defines a set of values.
Boolean types
A boolean type represents a truth value, corresponding to the preassigned variables true
and false
. The boolean type name is bool
. The boolean type is nullable and can be formally specified as follows:
bool = {true, false} | null
Numeric types
A numeric type represents sets of integer or floating-point values.
The following numeric types exist:
uint the set of all unsigned 64-bit integers | null
int the set of all signed 64-bit integers | null
float the set of all IEEE-754 64-bit floating-point numbers | null
All numeric types are nullable.
Time types
A time type represents a single point in time with nanosecond precision. The time type name is time
. The time type is nullable.
Timestamp format
Flux supports RFC3339 timestamps:
YYYY-MM-DD
YYYY-MM-DDT00:00:00Z
YYYY-MM-DDT00:00:00.000Z
Duration types
A duration type represents a length of time with nanosecond precision. The duration type name is duration
. The duration type is nullable
Durations can be added to times to produce a new time.
Examples of duration types
1ns // 1 nanosecond
1us // 1 microsecond
1ms // 1 millisecond
1s // 1 second
1m // 1 minute
1h // 1 hour
1d // 1 day
1w // 1 week
1mo // 1 calendar month
1y // 1 calendar year
3d12h4m25s // 3 days, 12 hours, 4 minutes, and 25 seconds
String types
A string type represents a possibly empty sequence of characters. Strings are immutable and cannot be modified once created. The string type name is string
. The string type is nullable.
An empty string is not a null value.
The length of a string is its size in bytes, not the number of characters, since a single character may be multiple bytes.
Bytes types
A bytes type represents a sequence of byte values. The bytes type name is bytes
.
Regular expression types
A regular expression type represents the set of all patterns for regular expressions. The regular expression type name is regexp
. The regular expression type is not nullable.
Composite types
These are types constructed from basic types. Composite types are not nullable.
Array types
An array type represents a sequence of values of any other type. All values in the array must be of the same type. The length of an array is the number of elements in the array.
Record types
A record type represents a set of unordered key and value pairs. The key must always be a string. The value may be any other type, and need not be the same as other values within the record.
Keys in a record may only be referenced statically.
Type inference determines the properties that are present in a record. If type inference determines all the properties in a record, it is said to be “bounded.” Not all keys may be known in the type of a record, in which case the record is said to be “unbounded.” An unbounded record may contain any property in addition to the properties it is known to contain.
Function types
A function type represents a set of all functions with the same argument and result types.
IMPL#249 Specify type inference rules.
Generator types
A generator type represents a value that produces an unknown number of other values. The generated values may be of any other type, but must all be the same type.
IMPL#658 Implement Generators types.
Polymorphism
Flux functions can be polymorphic, meaning a function can be applied to arguments of different types. Flux supports parametric, record, and ad hoc polymorphism.
Parametric polymorphism
Parametric polymorphism is the notion that a function can be applied uniformly to arguments of any type. For example:
f = (x) => x
f(x: 1)
f(x: 1.1)
f(x: "1")
f(x: true)
f(x: f)
The identifiers, a
and b
, in the body of the add
function are used as both int
and float
types.
Record polymorphism
Record polymorphism is the notion that a function can be applied to different types of records. For example:
john = {name:"John", lastName:"Smith"}
jane = {name:"Jane", age:44}
// John and Jane are records with different types.
// We can still define a function that can operate on both records safely.
// name returns the name of a person
name = (person) => person.name
name(person:john) // John
name(person:jane) // Jane
device = {id: 125325, lat: 15.6163, lon: 62.6623}
name(person:device) // Type error, "device" does not have a property name.
Records of differing types can be passed to the same function as long as they contain the necessary properties. The necessary properties are determined by the use of the record.
Ad hoc polymorphism
Ad hoc polymorphism is the notion that a function can be applied to arguments of different types with different behavior depending on the type.
add = (a, b) => a + b
// Integer addition
add(a: 1, b: 1)
// String concatenation
add(a: "str", b: "ing")
// Addition not defined for boolean data types
add(a: true, b: false)
Type constraints
Type constraints are to implement static ad hoc polymorphism. For example, the following function is defined only for Addable
types:
add = (a, b) => a + b
Passing a record to add()
results in compile-time type error because records are not addable.
// Records are not Addable and will result in an error.
add(a: {}, b: {})
Constraints are never explicitly declared but rather inferred from the context.
Addable constraint
Addable types are those the binary arithmetic operator +
accepts. Integer, Uinteger, Float, and String types are Addable
.
Subtractable constraint
Subtractable types are those the binary arithmetic operator -
accepts. Integer, Uinteger, and Float types are Subtractable
.
Divisible constraint
Divisible types are those the binary arithmetic operator \
accepts. Integer, Uinteger, and Float types are Divisible
.
Numeric Constraint
Integer, Uinteger, and Float types are Numeric
.
Comparable Constraint
Comparable types are those the binary comparison operators <
, <=
, >
, or >=
accept. Integer, Uinteger, Float, String, Duration, and Time types are Comparable
.
Equatable Constraint
Equatable types are those that can be compared for equality using the ==
or !=
operators. Boolean, Integer, Uinteger, Float, String, Duration, Time, Bytes, Array, and Record types are Equatable
.
Nullable Constraint
Nullable types are those that can be null. Boolean, Integer, Uinteger, Float, String, Duration, and Time types are Nullable
.
Record Constraint
Records are the only types that fall under this constraint.
Negatable Constraint
Negatable types ore those the unary arithmetic operator -
accepts. Integer, Uinteger, Float, and Duration types are Negatable
.
Timeable Constraint
Duration and Time types are Timeable
.