the :: operator
x :: T
a type specification
The :: operator serves several purposes in Maple, all related to types.
When used in a procedure parameter declaration, the left-hand side of the operator specifies the parameter name, and the right-hand 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 left-hand 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 assignments made to it are treated as if the left-hand side of the assignment were written using the :: declaration.
If a local variable was declared with a type, and the left-hand side of an assignment to that local variable also specifies a type, then the value being assigned must satisfy both types.
The :: operator can also be used to assert a type on the control variable(s) of a for loop. For example, when iterating over the contents of a container such as a list, the :: operator can assert that each entry is of a specified type.
In the condition of an if or while statement, :: serves as a type testing operator. In this context, x::T is equivalent to type(x,T).
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 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 right-hand side represents a type or a type-like concept. For example, see RealRange.
An expression using the :: operator is of type `::`.
The :: operator is thread-safe as of Maple 15.
For more information on thread safety, see index/threadsafe.
A common use of :: is to declare the type of procedure parameters.
f := proc( x::integer ) x^2 end proc:
Error, invalid input: f expects its 1st argument, x, to be of type integer, but received 3.4
The :: operator can assert the return type of a procedure.
f := proc( x::integer ) :: odd; x^2 end proc:
Error, (in f) assertion failed: f expects its return value to be of type of odd, but computed 16
Using :: on the left-hand side of an assignment, declaring a local variable with ::, or adding :: to a loop variable, asserts that the value being assigned is of the specified type.
x::integer ≔ 3.4
Error, assertion failed in assignment to x, expected integer, got 3.4
f := proc( x ) local y::integer;
y := x
Error, (in f) assertion failed in assignment to y, expected integer, got 4.5
Error, assertion failed in assignment to loop variable z, expected integer, got 1.2
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("not an integer")
not an integer
The :: operator is inert if used out of context.
x ≔ 2
The :: operator is not inert if used within a Boolean expression.
Expressions involving the :: operator are of type `::`.
The ability to apply the :: operator to the control variable(s) of a for loop is new in Maple 2021.
The :: operator was updated in Maple 2021.
Download Help Document