In most cases, the operator assignment a ,= b is equivalent to a = a,b, forming an expression sequence from the values of a and b, and assigning it back to variable a.

In the special case where the value of the left hand side is a one dimensional Array, the Array is expanded and the right hand side appended to the Array in-place. If the right hand side is an expression sequence (e.g., a ,= b,c,d) each element of the sequence is appended separately.

If the left hand side is an Array with a hardware datatype, and a right hand side is a one dimensional Array, then the contents of that Array are appended to the left hand side.

If the left hand side is an Array with a datatype of integer[1] (i.e., an array of bytes), and a right hand side is a string, the byte values of the characters in the string are individually appended to the left hand side.

If the left hand side is an object that implements a `,=` method, then that method is invoked to perform the operation. For example, the MutableSet object implements this method such that ms ,= x is equivalent to insert(ms,x) or ms union= MutableSet(x).

In cases other than those above, a right hand side is appended in its entirety as an element of the left hand side.

If any of the assignments described above are not possible (e.g. the right hand side is a symbol and the array has datatype float[8]), an exception is raised.

In addition to being used as a stand-alone statement, an if statement can be used as an expression or within an expression.

The value of such an embedded if statement is the value of the last expression computed within the branch that was executed.

In the example below, an if statement is embedded within a call to the String function. The value will be one of "st", "nd", "rd", or "th" depending on the value of variable a:

There is an older operator form of branching that can be used within an expression. In this form, if is always called with three arguments. The if operator has the following syntax:

The first argument condition is a Boolean-valued expression. The second argument consequent is an expression to evaluate if the first argument evaluates to the value true.  The third argument is an expression to evaluate if the first argument evaluates to either false or FAIL.

Note that the name if must be enclosed in name (left) quotes in this form.

The if command evaluates only one of its second and third arguments, determined by the value of the first argument.  The other argument is not evaluated.

However, the if command is much more limited than the if statement.  The consequent and alternative must be single expressions, and there is nothing corresponding to the elif parts of the statement form.

One simple kind of terminating loop is the while loop.

The loop header of a while loop involves only a single termination condition introduced by the keyword while. The loop repeats the statement sequence statseq as long as the Boolean-valued expression condition holds.

In this example, a loop counts the number of primes whose square is less than 1000.

This example uses the nextprime command, which returns the least prime greater than its argument. The name count is given the initial value 0, and the name p, which is used to store the current prime, is initially set to 2. The loop condition is the expression p^2 < 1000, appearing after the keyword while and before the keyword do. This condition is evaluated at the beginning of each iteration of the loop. If the condition evaluates to true, the body of the loop is executed. If the condition evaluates to false or FAIL, the code continues to execute at the next statement following the loop statement.

If the condition expression evaluates to a value other than true, false or FAIL, an exception is raised.

For more information on Boolean expressions, see Boolean and Relational Expressions.

Another kind of terminating loop is the until loop.

Like a while loop, an until loop has a single terminating condition, introduced by the keyword until. The until loop differs from the while loop in several respects:

A benefit of checking the condition at the end of the loop is that the condition may depend on values only calculated for the first time within the loop.

In this example, an until loop is used to implement the functionality of nextprime, yielding the next prime number after a given number, even if the given number is already prime.

Had this been written as a while loop with condition not isprime(N), the result would have been 23, not 29.

You can use a loop to repeatedly execute a sequence of statements a fixed number of times. These loops use the from and to clauses.

or equivalently

If the from clause is omitted, the default value of 1 is used.

The most common kind of loop is an inductive loop which is similar to a counted loop, but uses an induction variable whose value changes at each iteration of the loop. This is a particular kind of for loop with the general form

The default value for start is 1, for finish is infinity, and for increment is 1.

This loop performs the following tasks:

In the next example, the increment is a negative number.

Note: Since loops are increasing by default (increment by 1), the statement for i from 7 to 2 do print (i) end do; does not do anything unless you specify the increment as a negative number.  In this case, the loop increment is -2.

Loop control parameters (start, finish, and increment) do not need to be integers.

In addition to iterating over a numeric range, you can iterate over a range of characters. In this case, you must specify both the initial value start and the final value finish for the induction variable. Furthermore, the value of increment must be an integer.

An alternative form of the loop statement allows you to iterate over the operands of an expression (often, a data structure such as a set or list).

The induction variable var takes on, successively, the operands of the expression expr. There are a few exceptions.

Note that there is a difference between the loop above and the seemingly equivalent loop

The difference is the value of the induction variable i at the end of the loop. To see this, evaluate the induction variable i immediately after running the loop to display its value.

It is also possible to specify a pair of variables for var, separated by a comma. In this case, during each iteration of the loop, the first variable takes as value the index of the operand in expr, and the second variable takes on the corresponding value as described previously.

In addition to being used as a stand-alone statement, a loop can also be used as an expression or within an expression by enclosing it in parentheses. In the case where such a loop is the only expression within a list, set, or function call, on the right hand side of an assignment, or the sole argument to a return statement, the parentheses may be omitted.

The value of such an embedded loop statement is a sequence of the last value computed during each iteration of the loop.

The example below generates a list of all primes below a specified upper bound. The assignment to i initializes it and also serves to include the number 2 in the result. The i in the body of the loop adds each new prime in turn to the result.

The map command applies a function to every element of an aggregate object. The simplest form of the map command is

where f is a function and x is an expression. The map command replaces each operand elem of the expression x with f(elem).

For tables and Arrays (or other rtables), the function is applied to each entry.

Given a list of integers, you can create a list of their absolute values and of their squares by using the map command.

The general syntax of the map command is

where f is a function, x is any expression, and y1, ..., yn are expressions. The action of map is to replace each operand of x such that the ith operand of x is replaced by f(op(i,x), y1, ..., yn).

For more information and examples, see Basic Data Structures.

The select, remove, and selectremove commands also operate on the operands of an expression. The select command returns the operands for which the specified Boolean-valued function returns true. The remove command returns the operands for which the specified Boolean-valued function returns false. The selectremove command returns two objects: the operands for which the specified Boolean-valued function returns true and the operands for which the specified Boolean-valued function returns false. The select, remove, and selectremove commands have the same syntax as the map command.

For more information on these commands, see Other Data Structure Operations or refer to the select help page.

The zip command merges two lists or Arrays and then applies a binary function. The zip command has two forms

where f is a binary function, u and v are both lists or rtables, and d is any value. The zip command takes each pair of operands u[i], v[i], and creates a new list or vector from f(u[i], v[i]).

If the lists or vectors are not the same length, the length of the result depends on whether you provide the argument d.

If you do not specify d, the length of the result is the same as the length of the smaller list or vector.

If d is specified, the length of the result of the zip command is the same as the length of the longer list or vector. Maple replaces the missing value(s) with d.

The return statement causes an immediate return to the point where the current procedure was invoked.

In Command-line Maple, the return statement causes an error if it is run at the top level: Error, return out of context. In the Standard worksheet interface, return can be used at the top level in conjunction with DocumentTools:-RunWorksheet.

The error statement raises an exception and interrupts the execution of the current statement. If the exception is not caught (see the following section), a message is printed indicating that an error occurred.

In the first case, an error message is given as a string.

In the second case, string contains several placeholders of the form %n or %-n, where n is a positive integer, to include the provided parameters in the message.

The placeholder %n is replaced by the nth parameter given. The placeholder %-n is replaced by the ordinal form of the nth parameter, which should evaluate to an integer. The special placeholder %0 is replaced with the sequence of all parameters separated by commas and spaces.

Trapping Errors

The try statement is a mechanism for executing procedure statements in a controlled environment so that if an error occurs, it does not immediately terminate the procedure. The try statement has the following syntax   try tryStatSeq      catch catchStrings : catchStatSeq      finally finalStatSeq   end try This statement can include several catch clauses. The finally clause is optional. If procedure execution enters a try...catch block, the tryStatSeq is executed. If no exceptions occur during the execution of tryStatSeq, the finalStatSeq in the finally clause (if present) is executed. Execution then continues with the statement after end try. If an exception occurs during the execution of tryStatSeq, execution of tryStatSeq terminates immediately. The exception object corresponding to the exception is compared against each catchString. Any number of catch clauses can be provided, and each can have any number of catchStrings separated by commas. Alternatively, a catch clause does not need to have a catch string. Any given catchString (or a catch clause without one) can appear only once in a try...end try construct. If a matching catch clause is found, or the catch clause contains no catchStrings, the catchStatSeq of that catch clause is executed, and the exception is considered to have been caught. If no matching catch clause is found, the exception is considered not caught, and is re-raised outside of the try block. When Maple searches for a matching catch clause, the following definition of "matching" is used. •  Neither the exception object nor the catchStrings are evaluated (the exception object has already been evaluated by the error statement that produced it). •  The catchStrings are considered to be prefixes of the exception object's msgString. If a catchString has n characters, only the first n characters of the msgString need to match the catchString. This permits the definition of classes of exceptions. •  A catch clause without a catchString matches any exception. •  The "result" of a try statement (the value that % returns if it is evaluated immediately after execution of the try statement) is the result of the last statement executed in the try statement. A catchStatSeq can contain an error statement with no arguments, which also re-raises the exception. When an exception is re-raised, a new exception object is created that records the current procedure name, and the message and parameters from the original exception. Normally, the finalStatSeq of the finally clause, if there is one, is always executed before control leaves the try statement. This is true in the case that an exception occurs, independent of whether it is caught or whether another exception occurs in the catch clause. This is true even if a catchStatSeq re-raises the exception, raises a new one, or executes a return, break, or next statement. Under certain abnormal circumstances, the finalStatSeq is not executed: •  If an exception is caught in an interactive debugger session and you exit the debugger •  If one of the following untrappable exceptions occurs, the exception is not caught, and finalStatSeq is not executed: 1.  A computation timed out. This exception can only be caught by  the timelimit command, which raises a "time expired" exception that can be caught. For more information on the timelimit command, refer to the timelimit help page. 2.  A computation has been interrupted. In other words, you pressed Ctrl+C, Break, or equivalent. 3.  Internal system error. This exception indicates a bug in Maple itself. 4.  ASSERT or local variable type assertion failure. Assertion failures cannot be trapped because they indicate a coding error, not an algorithmic failure. 5.  Stack overflow. If a stack overflow occurs, there is generally not enough stack space to perform tasks such as running cleanup code. If an exception occurs during the execution of a catchStatSeq or the finalStatSeq, it is treated in the same way as if it occurred outside the try...end try statement.

Using try Statements in Expressions

A try statement can be used as an expression or within an expression. The value of such an embedded try statement is the value of the last expression computed within the last branch that was executed: •  If there was a non-empty finally clause, the result is that of the last expression computed in the finalStatSeq. •  If no exception occurred, the result is that of the last expression computed in the tryCatchSeq. •  If an exception did occur and was caught, the result is that of the last expression computed in the relevant catchStatSeq. •  If there was an exception and it was not caught, the evaluation of the entire expression is aborted just as it would be if no exception handling statement were involved.

Example 1

A useful application of the try and error statements is to stop a large computation as quickly and cleanly as possible. For example, suppose that you are trying to compute an integral by using one of several methods, and in the middle of the first method, you determine that it will not succeed. You want to stop that method and try another one. The following code implements this example. >  try    result := MethodA(f,x)  catch "FAIL":    result := MethodB(f,x)  end try: MethodA can stop its computation at any time by executing the statement error "FAIL". The catch clause catches that exception, and proceeds to try MethodB. If any other error occurs during the execution of MethodA, or if an error occurs during the execution of MethodB, it is not caught.

Example 2

Another useful application of the try statement is to ensure that certain resources are released when you are done with them, regardless of whether anything went wrong while you were using them. Use the following code to access the Maple I/O facilities to read the lines of a file and process them in some way. >  f := fopen("myfile",READ,TEXT):  try    line := readline(f);    while line < 0 do       ProcessContentsOfLine(line);       line := readline(f)    end do  finally    fclose(f)  end try: In this example, if any exception occurs while reading or processing the lines of the file, it is not caught because there is no catch clause. However, fclose(f) is executed before execution leaves the try statement, regardless of whether there was an exception. The next example uses both catch and finally clauses to write to a file instead of reading from one. >  f := fopen("myfile",WRITE,TEXT):  try    for i to 100 do       fprintf(f,"Result %d is %q\n",i,ComputeSomething(i))    end do  catch:    fprintf(f,"Something went wrong: %q\n",lastexception);    error  finally    fclose(f)  end try: If any exception occurs, it is caught with the catch clause having no catchString, and the exception object is written into the file. The exception is re-raised by executing the error statement with no msgString. In all cases, the file is closed by executing fclose(f) in the finally clause.