Keyword arguments are always matched first unless the procedure has parameters declared with the uneval or evaln modifiers. Maple makes a pass through the entire sequence of arguments looking for keyword=value equations where the keyword matches a declared keyword parameter of the procedure.

Whenever a matching keyword parameter is encountered, the right-hand side of the equation becomes the value for that parameter, and the equation is removed from further consideration as an argument. If more than one keyword argument matches a keyword parameter, only the last one takes effect.

Keyword parameter names (the keyword part) are Maple symbols like any other. If that symbol is in use as a variable, then using it in a keyword argument may not work as expected, since the variable may evaluate. To ensure that this does not happen, it's best to always use unevaluation quotes around the keyword part of a keyword argument:

f := proc( x::integer, { y::integer := 1 }, $ ) x * y end:

y := sin(z):

f(3,y=2);

Error, invalid input: too many and/or wrong type of arguments passed to f; first unused argument is sin(z) = 2

f(3,'y'=2);

$6$

When calling a procedure that accepts a keyword argument from within another procedure that has a parameter with the same name as the keyword argument, it is necessary to use both unevaluation quotes and the scope resolution operator, :-, to ensure that the global keyword is used instead of the value of the parameter:

f := proc( x::integer, { y::integer := 1 }, $ ) x * y end:

g := proc( y::rational )
    f(numer(y), ':-y'=denom(y))
end:

g(3/2);

$6$

After all arguments matching keyword parameters have been processed, matching of required positional and optional or expected ordered parameters is carried out. If any parameter had an evaln or uneval modifier, all parameters up to the rightmost of these will already have received arguments, so further matching begins with the next positional or ordered parameter after that.

Matching is done by traversing the parameter declarations from left to right. As each parameter is examined, an attempt is made to match it to the next unused argument as follows:

1. If the parameter has no type declaration, the argument matches trivially, and becomes the value for that parameter.

2. If the parameter has a type declaration, but no default value, the argument may or may not match. If it matches, the argument becomes the value for that parameter. If it does not match, an exception is raised. For example:

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

3. If the parameter has a type declaration and a default value, the argument may or may not match. If it matches, the argument becomes the value for that parameter. If it does not match, the parameter receives its default value, and the argument remains available for matching a subsequent parameter.

In cases 2 and 3 above, if the parameter's type uses the seq modifier, Maple continues to match additional arguments against the parameter until one is encountered that is not of the right type. A seq parameter never results in an exception, because even if no arguments match, a valid sequence has been produced (the empty sequence).

At the end of this process, if there are any arguments left over, they are either put into the _rest sequence, or, if the procedure was declared with the end-of-parameters marker, $, an exception is raised:

Error, invalid input: 2 positional arguments passed to f but only 1 positional parameter specified; first unused argument is a^2+b

If on the other hand all the arguments were used up, but there are parameters remaining to be assigned values, these receive their default values if they have one. Otherwise, they have no value, and attempting to use them within the procedure raises an exception.

Note: The actual order in which some of these actions occur is slightly more complicated than described. Specifically, when an argument is assigned to a typed positional parameter (i.e. one with no default value), the type check is not carried out until argument processing is completed, since the type may depend on the value of a later parameter.

f := proc( x, y::integer, z::string := "hello" )
    x, y, z, [_rest]
end proc:

f();

Error, invalid input: f uses a 1st argument, x, which is missing

f(2);

Error, invalid input: f uses a 2nd argument, y (of type integer), which is missing

f(2,3);

$2,3,''hello'',\left[\right]$

f(2,3,"bonjour");

$2,3,''bonjour'',\left[\right]$

f(2,3,4);

$2,3,''hello'',\left[4\right]$

f(2,3,4,"bonjour");

$2,3,''hello'',\left[4\,''bonjour''\right]$

For more information on parameters, see

1. Parameter Declarations

2. Parameter Modifiers

3. Using Parameters in Procedures

4. Argument Processing