
Parameters


x



any expression

T



a type specification





Description


•

The $::$ operator serves several purposes in Maple, all related to types.

•

When used in a procedure parameter declaration, the lefthand side of the operator specifies the parameter name, and the righthand side specifies the expected type of the argument.

•

The return type of a procedure can be declared by following the procedure's parameter declaration sequence by $::T$. In this context, $::$ serves as an assertion that the procedure returns a value of the specified type, T. If assertions are enabled, returning a value not matching the type will raise an exception.

•

When used as the lefthand side of an assignment statement or as the first argument to the assign function, $x::T$ asserts that the value being assigned to x is of type T.

•

A local variable can be declared with a type by using the $::$ operator. Within the procedure in which the variable is declared, any assignment made to it are treated as if the lefthand side of the assignment were written using the $::$ declaration.

•

In the condition of an if or while statement, $::$ serves as a type testing operator. In this context, $x::T$ is equivalent to $\mathrm{type}\left(x\,T\right)$.

•

The $::$ operator also acts as a type test when used as an argument to any of the Boolean operators, and, or, not, xor, implies, or the $\mathrm{evalb}$ function.

•

In any other context, $::$ evaluates its arguments, but does not itself evaluate any further. Thus, it can be used as a data structure or part of a larger data structure. Although it is not required, it is customary to use $::$ as a data structure only when the righthand side represents a type or a typelike concept. For example, see RealRange.

•

An expression using the $::$ operator is of type $\mathrm{::}$.



Thread Safety


•

The :: operator is threadsafe as of Maple 15.



Examples


A common use of :: is to declare the type of procedure parameters.
>

f := proc( x::integer ) x^2 end proc:

The :: operator can assert the return type of a procedure.
>

f := proc( x::integer ) :: odd; x^2 end proc:

>

$\mathrm{kernelopts}\left(\mathrm{assertlevel}=2\right)\:$

Using :: on the lefthand side of an assignment or declaring a local variable with :: asserts that the value being assigned is of the specified type.
>

$x::\'\mathrm{integer}\'\u22543.4$

>

f := proc( x ) local y::integer;
y := x
end proc:

In the condition of an if (or while) statement, the :: operator is equivalent to using the type function.
>

f := proc( x )
if x::integer then
print("an integer")
else
print("not an integer")
end if
end proc:

${''not\; an\; integer''}$
 (4) 
The :: operator is inert if used out of context.
>

$x::\'\mathrm{integer}\'$

>

$x::\'\mathrm{integer}\'\phantom{\rule[0.0ex]{0.3em}{0.0ex}}{\textstyle \mathbf{and}}\phantom{\rule[0.0ex]{0.3em}{0.0ex}}x<3$

Expressions involving the :: operator are of type `::`.
>

$\mathrm{type}\left(x::\mathrm{symbol}\,\mathrm{`::`}\right)$

>

$\mathrm{evalb}\left(\left(x::\mathrm{string}\right)::\mathrm{`::`}\right)$



