The nature of something predefined. For functions, these can either be monomorphic or overloaded. An overloaded builtin is a list valid types it can be instantiated with, to the parameter and result type, with Nothing representing the overloaded parameter type.

A map of all built-ins.

The largest tag used by an intrinsic - this can be used to determine whether a VName refers to an intrinsic or a user-defined name.

Names of primitive types to types. This is only valid if no shadowing is going on, but useful for tools.

Create a name with no qualifiers from a name.

Add another qualifier (at the head) to a qualified name.

Create a type name name with no qualifiers from a VName.

The type of the value.

The type of a basic value.

Given an operator name, return the operator that determines its syntactical properties.

The modules imported by a Futhark program.

The modules imported by a single declaration.

The set of module types used in any exported (non-local) declaration.

Extract a leading ((name, namespace, file), remainder) from a documentation comment string. These are formatted as `name`@namespace[@file]. Let us hope that this pattern does not occur anywhere else.

Given a list of strings representing entries in the stack trace and the index of the frame to highlight, produce a final newline-terminated string for showing to the user. This string should also be preceded by a newline. The most recent stack frame must come first in the list.

The type of an Futhark term. The aliasing will refer to itself, if the term is a non-tuple-typed variable.

The type scheme of a value binding, comprising the type parameters and the actual type.

The type of a function with the given parameters and return type.

The set of identifiers bound in a pattern.

The set of names bound in a pattern.

A mapping from names bound in a map to their identifier.

The type of values bound by the pattern.

The type matched by the pattern, including shape declarations if present.

When viewed as a function parameter, does this pattern correspond to a named parameter of some type?

patternOrderZero pat is True if all of the types in the given pattern have order 0.

Extract all the shape names that occur in a given pattern.

Return the uniqueness of a type.

unique t is True if the type of the argument is unique.

Return the set of all variables mentioned in the aliasing of a type.

diet t returns a description of how a function parameter of type t might consume its argument.

Return the dimensionality of a type. For non-arrays, this is zero. For a one-dimensional array it is one, for a two-dimensional it is two, and so forth.

Return the shape of a type - for non-arrays, this is mempty.

Return any shape declarations in the type, with duplicates removed.

orderZero t is True if the argument type has order 0, i.e., it is not a function type, does not contain a function type as a subcomponent, and may not be instantiated with a function type.

Extract the parameter types and return type from a type. If the type is not an arrow type, the list of parameter types is empty.

foldFunType ts ret creates a function type (Arrow) that takes ts as parameters and returns ret.

The type names mentioned in a type.

Extract all the shape names that occur in a given type.

The size of values of this type, in bytes.

peelArray n t returns the type resulting from peeling the first n array dimensions from t. Returns Nothing if t has less than n dimensions.

stripArray n t removes the n outermost layers of the array. Essentially, it is the type of indexing an array of type t with n indexes.

arrayOf t s u constructs an array type. The convenience compared to using the Array constructor directly is that t can itself be an array. If t is an n-dimensional array, and s is a list of length n, the resulting type is of an n+m dimensions. The uniqueness of the new array will be u, no matter the uniqueness of t.

Convert any type to one that has rank information, no alias information, and no embedded names.

Remove aliasing information from a type.

Replace no aliasing with an empty alias set.

t `setAliases` als returns t, but with als substituted for any already present aliasing.

t `addAliases` f returns t, but with any already present aliasing replaced by f applied to that aliasing.

Set the uniqueness attribute of a type. If the type is a record or sum type, the uniqueness of its components will be modified.

Change the shape of a type to be just the rank.

Change all size annotations to be AnyDim.

Perform a traversal (possibly including replacement) on sizes that are parameters in a function type, but also including the type immediately passed to the function. Also passes along a set of the parameter names inside the type that have come in scope at the occurrence of the dimension.

Where does this dimension occur?

Figure out which of the sizes in a binding type must be passed explicitly, because their first use is as something else than just an array dimension.

Figure out which of the sizes in a parameter type must be passed explicitly, because their first use is as something else than just an array dimension. mustBeExplicit is like this function, but first decomposes into parameter types.

Create a record type corresponding to a tuple with the given element types.

Does this type corespond to a tuple? If so, return the elements of that tuple.

Does this record map correspond to a tuple?

Construct a record map corresponding to a tuple.

Increasing field names for a tuple (starts at 0).

Sort fields by their name; taking care to sort numeric fields by their numeric value. This ensures that tuples and tuple-like records match.

Sort the constructors of a sum type in some well-defined (but not otherwise significant) manner.

Is this a TypeParamType?

Is this a TypeParamDim?

Combine the shape information of types as much as possible. The first argument is the orignal type and the second is the type of the transformed expression. This is necessary since the original type may contain additional information (e.g., shape restrictions) from the user given annotation.

Match the dimensions of otherwise assumed-equal types.

No information functor. Usually used for placeholder type- or aliasing information.

A type with no aliasing information but shape annotations.

An expression with no type annotations.

An identifier with no type annotations.

A type declaration with no expanded type.

An index with no type annotations.

An expression with no type annotations.

A module expression with no type annotations.

A module type expression with no type annotations.

A type parameter with no type annotations.

A pattern with no type annotations.

A function declaration with no type annotations.

A declaration with no type annotations.

A spec with no type annotations.

A Futhark program with no type annotations.

A case (of a match expression) with no type annotations.