Several new structured types (see type/structure) have been introduced.

Types specop and anyop

The new types specop and anyop (see type/structure) are similar to the types specfunc and anyfunc, except that they recognize an extended range of structured forms involving infix operators in addition to functional forms.

type( F( 2, 3 ), 'specop( anything, F )' );

$\mathrm{true}$

type( a + b, 'specop( anything, `+` )' );

$\mathrm{true}$

Types typefunc and patfunc

The new type typefunc (see type/structure) is similar to the type specfunc, except that the type of the function name is checked rather than the name itself.

type( f[1](x), typefunc(name,indexed) );

$\mathrm{true}$

The new type patfunc (see type/structure) is similar to the type anyfunc, except that only the first $n-1$ specified argument types are matched with the initial $n-1$ arguments of the functional form, and the last specified argument type is only matched with each of the remaining arguments, if they exist. The variation of this type patfunc[reverse] matches the last $n-1$ argument types with the first specified argument type matching any preceding arguments.

type( f(1,2,opt1,opt2), patfunc(numeric,numeric,name) );

$\mathrm{true}$

Types for indexed forms

The new types specindex, anyindex, typeindex, and patindex (see type/structure) recognize various indexed forms and are analogous to the types specfunc, anyfunc, typefunc, and patfunc .

type(a[1,2],specindex(integer,a));

$\mathrm{true}$

type(a(p)[1,2],typeindex(integer,function));

$\mathrm{true}$

Type patlist

The new type patlist (see type/structure) recognizes a particular list form, analogous to the functionality of type patfunc.  It matches the first $n-1$ specified types with the initial list operands and the last specified type with any remaining list operands. The variation of this type patlist[reverse] matches the last $n-1$ operand types with the first specified operand type matching any preceding list operands.

type( [3,"A","B"], patlist(integer,string) );

$\mathrm{true}$

A new command subtype has been added that can determine the subtyping relationship between some pairs of types. A type A is a subtype of a type B if every expression of type A is also of type B. While primarily intended for comparing the types of procedures and modules, it can determine subtyping relationships among many structured and built-in types.

subtype( 'vector( 2, integer )', 'vector( rational )' );

$\mathrm{true}$

subtype( 'polynom', '{ string, algebraic }' );

$\mathrm{true}$

subtype( 'procedure[ ratpoly ]( rational )', 'procedure[ algebraic ]( integer )' );

$\mathrm{true}$

subtype( 'procedure( integer )', 'procedure( algebraic )' );

$\mathrm{false}$

The new type satisfies may be used to embed arbitrary predicates in Maple's structured type system. This has two important consequences:

- it avoids having to pollute the global type namespace with inappropriate types, and

- it allows you to leverage the namespace management facilities provided by Maple's module system to implement ``local types''.

Since indets does not accept arbitrary predicates as its second (optional) argument, type satisfies may be used to construct ``one of'' types that need not be permanently installed in the type system (where they do not belong).

indets( F( G( x, y ), H( y ) ), 'satisfies'( rcurry( has, 'x' ) ) );

$\left\{x\,F\left(G\left(x\,y\right)\,H\left(y\right)\right)\,G\left(x\,y\right)\right\}$

A module can define computed types embracing arbitrary predicates (which need not be exported!) using type satisfies.

m := module()
    export    mytype;
    local    mypredicate;
    mytype := 'satisfies'( mypredicate );
    mypredicate := e -> type( e, 'odd' ) and numtheory[ 'issqrfree' ]( e );
end module:

type( 7, m:-mytype );

$\mathrm{true}$

type( 9, m:-mytype );

$\mathrm{false}$

type( 9, mytype ); # no global type namespace pollution

Error, type `mytype` does not exist

New RootOf types

The new types abstract_rootof and specified_rootof distinguish between RootOf data structures that represent, respectively, all the roots of an equation and a specific root of an equation.

a := RootOf( x^2-x-2, index=1 );

$a≔\mathrm{RootOf}\left({\mathrm{\_Z}}^2-\mathrm{\_Z}-2\,\mathrm{index}=1\right)$

type( a, abstract_rootof );

$\mathrm{false}$

type( a, specified_rootof );

$\mathrm{true}$

Type attributed

The new type attributed tests whether an expression has attributes or specified attributes.

type( sin, 'attributed( protected )' );

$\mathrm{true}$

setattribute( x, green ):

type( x, attributed );

$\mathrm{true}$

Type record

Records, which are simply modules without locals and having the option record, are recognized by the new type record. It performs the same type checking as type `module` does, but requires the module to be a record as well.

Type `local` and `global`

The types `local` and `global` check whether a symbol is either a local variable or a global variable.

type( x, `global` );

$\mathrm{true}$

type( convert( x, `local` ), `global` );

$\mathrm{false}$

type( convert( x, `local` ), `local` );

$\mathrm{true}$