A structured type is a Maple expression other than a symbol that can be interpreted as a type. A typical example would be set(name=algebraic). This specifies a set of equations whose left-hand sides are (variable) names, and whose right-hand sides are of type algebraic.

This file first gives a formal grammatical description of the valid structured types, then provides notes on some of the special types, and lastly gives examples.

In the formal definition below, read ``::='' to mean ``is defined to be'', ``|'' to mean ``or'', and ``*'' to mean ``zero or more occurrences of''.

Square brackets [] are used to check for a fixed argument sequence.  The type [name, set] matches a list with exactly two arguments: a name followed by a set.

Set brackets {} are used for alternation.  The type {set(name), list(integer)} matches either a set of names, or a list of integers.

The type anything matches any expression except a sequence.

The type identical(expr) matches the expression expr identically. If there is more than one expr (i.e. identical(expr1,expr2,...)), then this type matches any one of the exprN identically.

The type anyfunc(t1, ..., tn) matches any function with n arguments of type . Thus, type(f, anyfunc(t1,...,tn)) is equivalent to the logical conjunction type(f, function) and type([op(f)], [t1,...,tn]).

The type patfunc(t1,..., tn, t) matches any function with  or more arguments where the first  are of type , and the remaining arguments are of type t.

The type patfunc[reverse](t,t1,...,tn) matches any function with  or more arguments where the last  are of type , and the preceding arguments are of type .

The type specfunc(t, n) matches the function  with 0 or more arguments of type .  Thus, type(f, specfunc(t, n)) is equivalent to the logical conjunction type(f, function) and op(0,f) = n and type([op(f)], list(t)). Instead of a single name n, a set of names may be passed as the second parameter to the specfunc type constructor.  In this case, an expression matches if it is a function call with any of the names in the set as the 0-th operand. Thus, type(f,specfunc(t,{n1,n2,...,nk})) is equivalent to type(f,specfunc(t,n1)) or type(f,specfunc(t, n2)) or ... or type(f,specfunc(t,nk)).

The type specop(t, n) matches an operator expression or function with zeroth operand  and operands of type . It is similar to the specfunc type constructor, but also matches expressions, for example, sums, products, and relations, as well as functions. As for the specfunc type constructor, the second parameter may be a set of names rather than just a single name.

The type typefunc(t, T) matches a function of type  with 0 or more arguments of type .  Thus, type(f, typefunc(t, T)) is equivalent to the logical conjunction type(f, function) and type([op(0,f)], [T]) and type([op(f)], list(t)).

Analogous to specfunc, anyfunc, typefunc, patfunc, and patfunc[reverse], the type constructors specindex, anyindex, typeindex, patindex, and patindex[reverse] can be used to test for expressions with indices of prescribed types and the type constructors patlist and patlist[reverse] can be used to test for lists with elements of prescribed types.

The type type &under func describes expressions expr for which func(expr) is of type type. The second form of this type takes an arbitrary number of extra arguments for func; in particular, type &under (func, arg1, arg2, ...) describes expressions expr for which func(expr, arg1, arg2, ...) is of type type.