Flow-control structures: Difference between revisions

=={{header|Quackery}}==

A Quackery program is a dynamic array (''nest'') of numbers (bigints) operators (opcodes or primitives) and nests (named or explicit). It is evaluated by a depth first traversal of the structure, placing numbers on a data stack, and keeping track of the evaluation with a return stack. Flow control is achieved with meta-control flow operators, which modify the return stack during evaluation. The naming convention for meta-control flow operators is to wrap them in reversed brackets. They are <code>]again[ ]done[ ]if[ ]iff[ ]else[ ]'[ ]do[ ]this[</code> and <code>]bailby[</code>.

The first five, <code>]done[ ]again[ ]if[ ]iff[ ]else[</code>, are used to create a mix and match set of control flow words.

<pre>

[ ]again[ ] is again

[ ]done[ ] is done

[ ]if[ ] is if

[ ]iff[ ] is iff

[ ]else[ ] is else</pre>

<code>again</code> causes evaluation of the current nest to start again.

<code>done</code> causes evaluation of the current nest to end, and evaluation of the calling nest to continue.

<code>if</code> conditionally skips over the next item in the nest being evaluated. (dependant on the top of the data stack; it skips if the TOS is zero, and does not skip if it is a non-zero number. If it is not a number evaluation halts and a problem is reported.

<code>iff</code> is like <code>if</code> but conditionally skips over the next two items. It combines with <code>else</code> (below) to form an if...else... construct, and with other words to form more control flow structures (below).

<code>else</code> unconditionally skips over the next item in the nest being evaluated.

Also provided are <code>until</code> and <code>while</code>, and the programmer can add more as desired.

<pre>[ not if ]again[ ] is until

[ not if ]done[ ] is while</pre>

As this is a mix and match word set, complex control-flow structures can be made, restricted only to single-point of entry, achieved by the intentional omission of a <code>go-to</code> operator. For example, this code fragment from the task [[Largest number divisible by its digits#Quackery|Largest number divisible by its digits]].

<pre> [ 504 -

dup digits

dup 5 has iff

drop again

dup 0 has iff

drop again

repeats if again ]</pre>

<code>' do this</code>enable first and higher order functions, and recursion. They are defined using meta control flow operators.

<pre>

[ ]'[ ] is '

[ ]do[ ] is do

[ ]this[ ] is this</pre>

<code>'</code> unconditionally skips over the next item in the current nest, and places (a pointer to) it on the data stack.

<code>do</code> evaluates the item on the top of the data stack.

<code>this</code> places (a pointer to) the nest currently being evaluated on the data stack. so, for example, the phrase <code>this do</code> will cause the nest containing the phrase to be evaluated recursively. For convenience, the word <code>recurse</code> is provided which does the same thing.

<pre>[ ]this[ do ] is recurse</pre>

For more complex recursive situations the words <code>this</code> and <code>do</code> can be deployed at different levels of nesting, and additionally a forward referencing mechanism is provided. This example is from the task [[Mutual recursion#Quackery|Mutual recursion]].

<pre> forward is f ( n --> n )

[ dup 0 = if done

dup 1 - recurse f - ] is m ( n --> n )

[ dup 0 = iff 1+ done

dup 1 - recurse m - ]

resolves f ( n --> n )</pre>

<code>]'[</code> and <code>do</code> are also used to create the iterative looping word <code>times</code>, which will repeat the next item in the nest a specified number of times. The index of the loop is available from the word <code>i^</code>, which counts up from zero with each iteration, and the word <code>i</code>, which counts down to zero. The index can be modified with the words <code>step</code>, which causes the index to be incremented by a specified number, <code>refresh</code>, which resets it to the originally specified number of iterations, and <code>conclude</code>, which will sets it to zero.

<code>times</code> is used in the definition of <code>witheach</code>, which iterates over a nest placing the next item in the nest on the data stack with each iteration, so <code>I^ I step refresh conclude</code> are available within <code>witheach</code> loops.

<pre> ' [ 10 11 12 13 14 15 16 17 18 19 ]

witheach

[ dup 14 > iff

[ drop conclude ] done

echo

say " is item number " i^ echo cr

2 step ]</pre>

{{out}}

<pre>10 is item number 0

12 is item number 2

14 is item number 4</pre>

<code>witheach</code> can be used to define [[Higher-order functions#Quackery|Higher-order functions]].

<code>]bail-by[</code> removes a specified number of returns from the return stack. This is a high risk activity, as the data stack and ancillary stacks used by <code>times</code> and others are not restored in the process, additionally many words add items to the return stack that need to be accounted for. Without proper precautions it is an effective way of causing unpredictable behaviour (usually crashing). It exists primarily for the backtracking provided by the words <code>backup</code>, <code>bail</code>, and <code>bailed</code>, which do take the proper precautions.