## `repeat, while` -- repeat and while loop

#### Introduction

`repeat - end_repeat` is a loop that evaluates its body until a specified stopping criterion is satisfied.

`while - end_while` represents a loop that evaluates its body while a specified condition holds true.

#### Call(s)

repeat
body
until condition end_repeat `_repeat(body, condition)`
while condition do
body
end_while `_while(condition, body)`

#### Parameters

`body` | - | the body of the loop: an arbitrary sequence of statements
`condition` | - | a Boolean expression

#### Returns

the value of the last command executed in the body of the loop. If no command was executed, the value `NIL` is returned. If the body of a `while` loop is not evaluated due to a false condition, the void object of type `DOM_NULL` is returned.

#### Further Documentation

Chapter 16 of the MuPAD Tutorial.

#### Related Functions

`break`, `for`, `next`, `_lazy_and`, `_lazy_or`

#### Details

- In a `repeat` loop, first `body` and then `condition` are evaluated until `condition` evaluates to `TRUE`.
- In a `while` loop, `condition` is evaluated before the body is executed for the first time. If `condition` evaluates to `TRUE`, the loop is entered and `body` and `condition` are evaluated until `condition` evaluates to `FALSE`.
- In contrast to the `while` loop, the body of a `repeat` loop is always evaluated at least once.
- The body may consist of any number of statements which must be separated either by a colon `:` or a semicolon `;`. Only the last evaluated result inside the body (the return value of the loop) is printed on the screen. Use `print` to see intermediate results.
- The Boolean expression `condition` must be reducible to either `TRUE` or `FALSE`. Internally, the condition is evaluated in the lazy evaluation context of the functions `_lazy_and` and `_lazy_or`.
- The statements `next` and `break` can be used in `repeat` and `while` loops in the same way as in `for` loops.
- The keywords `end_repeat` and `end_while` may be replaced by the keyword `end`.
- The imperative forms `repeat - end_repeat` and `while - end_while` are equivalent to corresponding calls of the functions `_repeat` and `_while`, respectively. In most cases, the imperative forms should be preferred because they lead to simpler code.
- `_repeat` and `_while` are functions of the system kernel.

#### Example 1

Intermediate results of statements within a `repeat` and `while` loop are not printed to the screen:

    >> i := 1:
       s := 0:
       while i < 3 do
         s := s + i;
         i := i + 1;
       end_while

                                         3

Above, only the return value of the loop is displayed. Use `print` to see intermediate results:

    >> i := 1:
       s := 0:
       while i < 3 do
         print("intermediate sum" = s);
         s := s + i;
         i := i + 1;
         s
       end_while

                              "intermediate sum" = 0

                              "intermediate sum" = 1

                                         3

    >> delete i, s:

#### Example 2

A simple example is given, how a `repeat` loop can be expressed via an equivalent `while` loop. For other examples, this may be more complicated and additional initializations of variables may be needed:

    >> i := 1:
       repeat
         print(i);
         i := i + 1;
       until i = 3 end:

                                         1

                                         2

    >> i := 1:
       while i < 3 do
         print(i);
         i := i + 1;
       end:

                                         1

                                         2

    >> delete i:

#### Example 3

The Boolean expression `condition` must evaluate to `TRUE` or `FALSE`:

    >> condition := UNKNOWN:
       while not condition do
         print(Condition = condition);
         condition := TRUE;
       end_while:

          Error: Unexpected boolean UNKNOWN [while]

To avoid this error, change the stopping criterion to `condition <> TRUE`:

    >> condition := UNKNOWN:
       while condition <> TRUE do
         print(Condition = condition);
         condition := TRUE;
       end_while:

                                Condition = UNKNOWN

    >> delete condition:

#### Example 4

We demonstrate the correspondence between the functional and the imperative form of the `repeat` and `while` loop, respectively:

    >> hold(_repeat((statement1; statement2), condition))

                            repeat
                              statement1;
                              statement2
                            until condition end_repeat

    >> hold(_while(condition, (statement1; statement2)))

                                while condition do
                                  statement1;
                                  statement2
                                end_while

#### Changes

- `end` can be used as an alternative to `end_repeat` and `end_while`.

Do you have questions or comments?
Copyright © SciFace Software GmbH & Co. KG 2000