This modifier changes an optional ordered parameter to an expected ordered parameter, indicating that an argument in the function call can be omitted only if all further arguments are also omitted. If there is an argument available, it must match the declared type of the parameter or an exception is raised.

Using expects with either a required parameter or a keyword parameter is redundant, and produces a warning.

f := proc(b::expects(integer) := 100.1) b^2 end proc:

f();

$10020.01$

f(3);

$9$

f(4.5);

Error, invalid input: f expects its 1st argument, b, to be of type integer, but received 4.5

Note that when a parameter is not passed, the default value is evaluated.  If the evaluated result is different than the original input, then the result is checked against the declared type.  Use the computed value as the default if you need to work around this situation.  Using uneval quotes around the default value will bypass this issue, but may lead to a result that is not fully evaluated.

In the following example sqrt(2) evaluates to 2^(1/2) and therefore goes through the type check and fails because it is not an integer.

g := proc(b::expects(integer) := sqrt(2)) b^2 end proc:

g();

Error, invalid input: g expects default value for its 1st parameter, b, to be of type integer, but received 2^(1/2)

h := proc(b::expects(integer) := 2^(1/2)) b^2 end proc:

h();

$2$

The seq modifier allows the parameter to match multiple arguments. When a parameter with a declared type of seq(memberType) is encountered, it consumes all arguments starting from the next available one until an argument not of type memberType is encountered.

Note: It is entirely possible for no arguments to match the memberType. In that case, the parameter takes on one of two values:

If the parameter is a required positional parameter, it takes on the value NULL, which is Maple's name for the empty sequence.

If the parameter is an optional ordered parameter, it takes on the specified default value.

Because seq matches even when no arguments match the memberType, this modifier cannot be used together with the expects modifier. Expecting zero or more of something is always satisfied.

The seq modifier cannot be used with a keyword parameter.

Care must be taken when working with the value of a seq parameter because it might have just one element in it. Such a value is no longer a sequence, thus indexing it will not select the element. The safest way to use a seq parameter is to turn it into a list as soon as possible (for example xList := [xSeq];).

f := proc( x::seq(integer), other::seq(anything) )
    local max, n;
    max := -infinity;
    for n in [x] do
        if n > max then max := n end if
    end do;
    max, [other]
end:

f(4,7,8,2,1);

$8,\left[\right]$

f(4,7,"not an integer",8,2,1);

$7,\left[''not\; an\; integer''\,8\,2\,1\right]$

The type seq(uneval) matches all remaining arguments, and returns them as a sequence thereof, remaining unevaluated. For more information, see The uneval Modifier below.

Usually, the type of a parameter is predetermined when the procedure is written. When Maple matches arguments to parameters, it does not evaluate the parameter's type, since this is not expected to yield anything different than what was written.

There are cases where this is too restrictive, and the depends modifier tells Maple that the parameter's type is dependent on something else which may change, and that it is to be evaluated each time it is used for argument matching. Most commonly, the dependency is on another parameter. For example, one might want to write a procedure to find the roots of a polynomial.

one_sol := proc( p::depends(polynom(integer,v)), v::symbol )
    local sols;
    sols := [ solve(p=0,v) ];
    if sols = [] then
        error "no solution"
    else
        sols[1]
    end if
end proc:

one_sol(x^2+3*x+5,x);

$-\frac{3}{2}+\frac{\mathrm{I}\sqrt{11}}{2}$

one_sol(x^2+3*x+5,y);

Error, invalid input: one_sol expects its 1st argument, p, to be of type polynom(integer,y), but received x^2+3*x+5

This procedure expects as its first parameter, p, a polynomial in the variable specified by the second parameter, v. If the depends modifier were omitted, the procedure would only accept polynomials in the global variable, v.

The depends modifier can only be used with required parameters. It cannot be used for optional or expected ordered parameters, nor keyword parameters. If the depends modifier is used together with the seq modifier, it must appear inside the other modifier. That is, the declaration must be written: seq(depends(type)).

Note: The type in the depends modifier must evaluate to a proper Maple type. It cannot evaluate to anything containing additional modifiers.

Unlike all the other modifiers discussed so far, the uneval modifier takes no arguments. What uneval does is prevent evaluation of the corresponding argument at function call time, as if the argument had been enclosed in unevaluation quotes, ('...').

Like evaln, uneval can only be used for required positional parameters. It also cannot be used in conjunction with any other modifiers, or in a parameter declaration after one with the seq modifier.

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

a, b := 3, 4.5:

f(a+b);

${\left(a+b\right)}^2$

eval((7));

$56.25$

The combined type specification, seq(uneval), matches all remaining arguments and returns a sequence of all of them, unevaluated. Note that this declaration must appear as the last specification of the procedure parameter.

f := proc(x, y::seq(uneval)) print(x); print(y) end proc:

a, b := 3.14, 'b';

$a,b≔3.14,b$

f(a+b,1,2);

$3.14+b$

$1,2$

f(1,2,a+b);

$1$

$2,a+b$

This modifier can be used in two different forms, evaln or evaln(valueType). A parameter declared with the evaln modifier expects an argument that can be evaluated to a name (like the Maple function evaln would do). If a valueType was specified, the resulting name is expected to have a value matching that type.

In effect, declaring a parameter with the evaln modifier is equivalent to enclosing the argument with an evaln call at function call time, and allows procedures to be written where the user of the procedure does not have to remember to do so.

The evaln modifier may only be used for required positional parameters.

The only supported case of using evaln with other modifiers is depends(evaln(valueType)), which declares that valueType depends on some other parameter(s). The depends(evaln) combination is not permitted, since it is meaningless.

A parameter using either form of evaln may not appear after any parameter using the seq modifier.

Note: Use of an evaln or uneval modifier alters the usual argument processing sequence. Keyword arguments are not recognized until after all required positional parameters up to and including the rightmost one with such a modifier have been assigned arguments.

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

a, b := 3, 4.5:

f(a);

$a^2$

f(b);

Error, invalid input: f expects its 1st argument, x, to be of type evaln(integer), but received b := 4.5

f(a+b);

Error, illegal use of an object as a name

accumulate := proc(r::evaln(numeric), n::numeric)
    r := eval(r) + n
end proc:

accumulate(total,2);

Error, invalid input: accumulate expects its 1st argument, r, to be of type evaln(numeric), but received total := total

total := 0;

$\mathrm{total}≔0$

accumulate(total,2);

$2$

accumulate(total,3.5);

$5.5$

total;

$5.5$

Coercion refers to the ability to pass one type of data to a procedure and have it receive a different type.  The passed data is coerced or converted to the new type behind the scenes.  The user of the procedure benefits by being able to use a larger variety of data types, which may all look alike.  The author of the procedure benefits by being able to focus on handling only the best data type suited to the task.

Coercion can be enabled in a procedure in one of two ways.  

For a complete discussion of data type coercion, see the coercion help page.

For more information on parameters, see

1. Parameter Declarations

2. Parameter Modifiers

3. Using Parameters in Procedures

4. Argument Processing