The unit type () is inhabited by just a single value, namely (). See also the voidstd/core/types/void: V type and the boolstd/core/types/bool: V type.

A pair of values a and b.

A triple of values.

A quadruple of values.

A quintuple of values.

The total effect represents the absence of any effect.

The effect constructor extends an effect with another effect.

The alloc effect signifies a function may allocate in a heap h.

An any type. Used for extern calls.

The type of booleans has two inhabitants: Truestd/core/types/True: bool and Falsestd/core/types/False: bool.

Explicitly box values using the Boxstd/core/types/Box: forall<a> (unbox : a) -> box<a> constructor.

Internal. Internal type for tail recursion module cons (TRMC) optimization. Holds the address to a field of type a in a constructor.

A unicode character. Characters are unicode codepoints. This is different from a unicode grapheme which represents a single displayed symbol and can consists of multiple codepoints due to combining characters and marks. (see also the std/text/unicode module).

Internal. Internal type for tail recursion module cons (TRMC) optimization.

The divergence effect: a divergent function may not terminate.

The predicate edivstd/core/types/ediv: (X, V, E) -> P<x,a,e> signifies that if the type a contains a reference to effect constant x then the effect e must contain the divergent effect (divstd/core/types/div: X). This constraint is generated for operations on first-class effects where code can diverge through operations.

The choice type represents one of two possible types a or b.

A 32-bit IEEE 754 single precision floating point value. Provides currently no operations and currently only used for storage and for interaction with external code.

A 64-bit IEEE 754 double precision floating point value. See also std/num/float64 for more operations on float64std/core/types/float64: Vs.

The globalstd/core/types/global: H heap is a special heap constant to denote the global shared heap.

Handled effects are lifted to an atomic effect using the handledstd/core/types/handled: HX -> X type constructor.

Linear effects are lifted to an atomic effect using the handled1std/core/types/handled1: HX1 -> X type constructor.

Explicitly heap allocate using the Hbox constructor.

The predicate hdivstd/core/types/hdiv: (H, V, E) -> P<h,a,e> signifies that if the type a contains a reference to h, then the effect e must contain the divergent effect (divstd/core/types/div: X). This constraint is generated when reading from the heap (see !) and is necessary to catch cases where code can diverge by storing self referential functions in the heap.

An arbitrary precision signed integer.

A 16-bit signed integer (represented in two's complement). Provides no operations and used only for storage and interaction with external code.

A 32-bit signed integer (represented in two's complement). See the std/num/int32 module for operations on 32-bit integers.

A 64-bit signed integer (represented in two's complement). See the std/num/int64 module for operations on 64-bit integers.

A 8-bit signed integer (represented in two's complement). Provides no operations and used only for storage and interaction with external code.

A signed two's complement integer equal to an intptr_t in C, i.e. it has the same bit-size as a native pointer (void*). Provides no operations but is used mostly for interaction with external code. The Javascript backend uses int64 for this.

A local variable var<s,a> points to a value of type a in local scope s.

The maybestd/core/types/maybe: V -> V type is used to represent either a value (Juststd/core/types/Just: forall<a> (value : a) -> maybe<a>(x)) or Nothingstd/core/types/Nothing: forall<a> maybe<a>. This type is often used to represent values that can be null.

The non-determism effect.

Internal: Optional is used by the compiler to pass optional arguments. It is usually displayed as :?a for some type a.

An enumeration to represent order.

The read effect: signifies that a function may read from from heap h.

A reference refstd/core/types/ref: (H, V) -> V<h,a> points to a value of type a in heap h.

Internal type used for in-place update of unique pattern matches.

A signed two's complement integer equal to a signed size_t in C, i.e. it can hold the byte size of any object, in particular the maximum possible byte size of a vector or string. Provides no operations but is used mostly for interaction with external code. The Javascript backend uses int32 for this.

Stateful functions can manipulate heap h using allocations, reads and writes.

A string is a sequence of unicode character points (char). The encoding of a string is internal and there is no constant-time indexing of characters in a string. Use the sslice type for efficient matching and retrieving sub-strings from string.

The type of immutable arrays is called vectorstd/core/types/vector: V -> V.

The write effect: signifies that a function may write to heap h.

Internal: used to pass locals by reference.

The identity function returns its argument unchanged.

Internal: if local mutation is unobservable, the localstd/core/types/local: H -> X effect can be erased by using the local-scopestd/core/types/local-scope: forall<a,e> (action : forall<h> () -> <local<h>|e> a) -> e a function. See also: State in Haskell, by Simon Peyton Jones and John Launchbury.

If a heap effect is unobservable, the heap effect can be erased by using the runstd/core/types/run: forall<e,a> (action : forall<h> () -> <alloc<h>,read<h>,write<h>|e> a) -> e a fun. See also: State in Haskell, by Simon Peyton Jones and John Launchbury.

Unsafe. Mark a function parameter as decreasing to suppress the non-termination effect (divstd/core/types/div: X).

Unsafe. This function pretends the give action is terminating.

Unsafe. This function pretends the give action was deterministic.

Unsafe. This function calls a function and pretends it did not have any effect at all.