::
the :: operator
Calling Sequence
Parameters
Description
Thread Safety
Examples
x :: T
x
-
any expression
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 assignment made to it are treated as if the left-hand 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 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:
f⁡2
4
f⁡3.4
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:
kernelopts⁡assertlevel=2:
f⁡3
9
f⁡4
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 or declaring a local variable with :: asserts that the value being assigned is of the specified type.
x::'integer'≔3.4
Error, assertion failed in assignment, expected integer, got 3.4
f := proc( x ) local y::integer; y := x end proc:
f⁡4.5
Error, (in f) assertion failed in assignment, expected integer, got 4.5
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:
an integer
not an integer
The :: operator is inert if used out of context.
x≔2
x::'integer'
2::?
x::'integer'andx<3
true
Expressions involving the :: operator are of type `::`.
type⁡x::symbol,`::`
evalb⁡x::string::`::`
See Also
boolean
evalb
if
parameter
procedure
while
Download Help Document
What kind of issue would you like to report? (Optional)