The nature of something predefined. 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.

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.

Find all the identifier references in a string.

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

The set of identifiers bound in a pattern.

The type of values bound by the pattern.

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

The type of a pattern, including shape annotations.

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

Remove all shape annotations from a pattern, leaving them unnamed instead.

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 any shape declarations in the type, with duplicates removed.

The result of applying the arguments of the given types to a function with the given return type, consuming its parameters with the given diets.

Is the type concrete, i.e, without any type variables or function arrows?

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.

The type names mentioned in a type.

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

Construct a ShapeDecl with the given number of zero-information dimensions.

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. The function returns Nothing in case an attempt is made to create an array of functions.

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 tuple, the uniqueness of its components will be modified.

Change the size annotations of a type.

Set the dimensions of an array. If the given type is not an array, return the type unchanged.

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

Change all size annotations to be AnyDim.

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

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

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

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

A type with no aliasing information but shape annotations.

An array element type with no aliasing information.

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 Futhark program with no type annotations.

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