Represent the type of a function that accepts a list of objects with type t and returns a single object with type t:

Represent a declaration of a polymorphic function with this type:

Compile a program using the polymorphic function:

Compile another program using the polymorphic function with a different concrete type:

Represent the type of a function that takes any packed array and returns an array of higher rank:

Declare a function with that type and call that function on a concrete example:

Represent the type of a function that is polymorphic in its output:

Compile a function with the type:

Represent the type of a function that only accepts integers:

Represent a function with the type:

Compile a program that calls the function on an integer type:

Compilation fails when the function is given a non-integer type:

Represent the type of a function that only accepts packed arrays with a rank less than 3:

Represent a function with the type:

Compile a program that applies the function to a packed array with rank 2:

Compilation fails when the inputted packed array has rank 3:

The constraint in a declaration can be used to distinguish between versions of a function.

Here are two declarations of the same function: one is for "Integers" and one is for "UnsignedIntegers":

The only constraint that matches is that for "Integers":

Here both constraints match and the narrowest declaration (that for "UnsignedMachineIntegers") is used:

CompilerInformation can be useful to see how types such as "Integer64" work with abstract types such as "Integers".

Constraints can also be given with a list of alternatives.

This declaration can apply to both "Integer64" and "Real64":

The declaration works for "Integer64":

The declaration also works for "Real64":

Constraints with a list of alternatives can use types with variables:

The declaration works for "Integer64":

It also works for a "PackedArray" type:

It is quite useful to give a declaration without having to go to the trouble of declaring an abstract type. These declarations can be helpful to give the shape of the types being used even if they are not completely known.