```Search                        Top                                  Index
```
```HELP FOR                                Updated A. Sloman, Dec 1986
Ian Rogers, Apr 1989

FOR is an iterative command. There are several main forms, viz:

for <variable> in <list> do <actions> endfor

for <variable> on <list> do <actions> endfor

for <variable> in_list <list> do <actions> endfor

for <variable> on_list <list> do <actions> endfor

for <variable> in <structure> using_subscriptor <procedure> do
<actions>
endfor

for <variable> from <number> by <number> to <number> do <actions> endfor

for <variable> from <number> to <number> do <actions> endfor
(Default: by 1)

for <variable> by <number> to <number> do <actions> endfor
(Default: from 1)

for <variable> to <number> do <actions> endfor
(Defaults: from 1, by 1)

for <action> step <action> till <condition> do <actions> endfor

The first four forms have variants with multiple variables:
for V1 V2 ...Vn in L1, L2,...,Ln do <actions> endfor

for V1 V2 ...Vn on L1, L2,...,Ln do <actions> endfor

for V1 V2 ...Vn in_list L1, L2,...,Ln do <actions> endfor

for V1 V2 ...Vn on_list L1, L2,...,Ln do <actions> endfor

-- EXAMPLES -----------------------------------------------------------

The command:

for <variable> in <expression> do <actions> endfor

evaluates the expression, which should yield a list, and then performs the
actions with the variable being successively bound to each element of the
list, for example:

for x in [a b c] do x => endfor;
** a
** b
** c

The multiple variable form can be used to iterate over elements of
several lists at once, e.g.

for x y z in [ a b c d], [ e f g], [ h i j k] do
[^x ^y ^z] =>
endfor;

** [a e h]
** [b f i]
** [c g j]

Note that the loop terminates when the end of the shortest list has
been reached.

-----------------------------------------------------------------------

The command:

for <variable> on <expression> do <actions> endfor

evaluates the expression, which should yield a list, and then performs
the actions with the variable set first to the list, then the *TL of the
list, then the TL of the TL of the list etc. For example:

for x on [a b c] do x => endfor;
** [a b c]
** [b c]
** [c]

The multiple variable form can be used to progress down different
lists at once, e.g.

for x y z on [ a b c d], [ e f g], [ h i j k] do
[^x ^y ^z] =>
endfor;

** [[a b c d] [e f g] [h i j k]]
** [[b c d] [f g] [i j k]]
** [[c d] [g] [j k]]

As with "in" the loop terminates when the shortest list is exhausted.

---------------------------------------------------------------------

The command
for <variable> in <structure> using_subscriptor <procedure> do
<actions>
endfor

iterates over the elements of the <structure>, using the <procedure>
to access the elements, e.g.

for item in {[a] vector [of words] and [lists]}
using_subscriptor subscrv
do item=>
endfor;

** [a]
** vector
** [of words]
** and
** [lists]

-----------------------------------------------------------------------

The commands
for <variable> in_list <expression> do <actions> endfor
and
for <variable> on_list <expression> do <actions> endfor

do exactly the same things as
for ... in ... do ... endfor
and
for ... on ... do ... endfor

respectively except that the addition of "using_subscriptor" before the
do is not allowed. It is up to your personal taste as to which version
you use.

See also HELP * FOR_FORM for more complex iteration types such as
in_property, in_vector, from_repeater etc.

---------------------------------------------------------------------

The command:

for <variable> from <expression1> by <expression2> to <expression3> do
<actions>
endfor;

binds the variable to the result of evaluating the first expression and
then performs <actions>; the second expression is then added to the
variable. If it is less than or equal to the third expression the
actions are performed again. The addition, testing and execution of
actions is repeated until the variable exceeds the value of the third
expression.

If expression2 is negative (before the loop is entered) then the
termination test uses "<" instead of ">".

The 'by' and 'from' portions may both be omitted; in either case, the
missing value is assumed to be 1.

------------------------------------------------------------------------

Another form of the FOR command:

for <action1> step <action2> till <condition> do <actions> endfor;

first executes the instructions <action1>. Next <condition> is checked
to make sure it is not yet true (if it is, nothing more will happen).
After that the <actions> are repeatedly executed, each execution being
followed by the execution of the instructions <actions2> and the
checking of the condition. This continues until the condition evaluates
to TRUE, when the execution of the FOR loop is terminated. Thus:

for "steve" -> person step father(person) -> person
person =>
endfor

would print out:

** steve
** frank
** tom
.....
** cain

------------------------------------------------------------------------

Notice that the first five forms of the FOR command could all be
accomplished using the last, thus:

for <variable> in <expression> do <actions> endfor

is equivalent to:

for <expression> -> <temporary_variable>
step tl(<temporary_variable>) -> <temporary_variable>
till <temporary_variable> = []
do
hd(<temporary_variable>) -> <variable>;
<actions>
endfor

and:

for <variable> on <expression> do <actions> endfor;

is equivalent to:

for <expression> -> <variable>
step tl(<variable>) -> <variable>
till <variable> = []
do
<actions>
endfor

and:

for <variable> from <expression1> by <expression2> to <expression3> do
<actions>
endfor

is equivalent (when expression2 is positive) to:

for <expression1> -> <variable>
step <variable> + <expression2> -> <variable>
till <variable> > <expression_3>
do
<actions>
endfor

Finally, the FOR ... STEP format can be re-written using UNTIL, thus:

<action1>;
until <condition> do
<actions>;
<action2>
enduntil

------------------------------------------------------------------------

Please note that POP-11 makes no syntactic distinction between an action
and an expression. By convention, an expression is some POP-11 code that
leaves something on the stack whereas an action is some POP-11 code that
leaves the stack unaltered. Thus the following is legal:

for x from 1 to 10 do x endfor;

It leaves 10 items on the stack (the integers 1 to 10). A FOR loop can
(like any POP-11 code) be enclosed in decorated list or vector brackets,
for example:

[% for x from 1 to 10 do x endfor %] =>
** [1 2 3 4 5 6 7 8 9 10]

See REF * FASTPROCS for FAST_FOR, a fast, non-type-checking iteration over
lists or integers.

-----------------------------------------------------------------------

The iteration in a FOR loop can be terminated using any of

* RETURN, * QUITLOOP,  *QUITIF,  * QUITUNLESS

or re-started using

* NEXTLOOP, * NEXTIF, * NEXTUNLESS

Re-starting means effectively jumpting to just before ENDFOR, so that
the next loop-iteration is performed, after stepping loop variables and
testing for completion.

* FOR_FORM describes a method for defining new extensions to the "for"
loop mechanism.

*CONTROL     - for an overview of control facilities
*LOOPS       - for other forms of iteration
*EXPRASS     - for forms of expression in POP-11
*VARS        - for forms and uses of variables in POP-11
*LISTSUMMARY - for an overview of lists
*FOREACH, *FOREVERY - for iteration over items in a database that
match a given pattern.
*EFFICIENCY  - for tips on optimisation.

REF * SYNTAX    - syntax words in POP-11
REF * POPSYNTAX - syntax diagrams for POP-11

--- C.all/help/for