Control flow · Lablypedia

Although an imperative language encodes control flow explicitly, languages of other programming paradigms are less focused on control flow. A declarative language specifies desired results without prescribing an order of operations. A functional language uses both language constructs and functions to control flow even though they are usually not called control flow statements.

For a central processing unit instruction set, a control flow instruction often alters the program counter and is either an unconditional branch (a.k.a. jump) or a conditional branch. An alternative approach is predication which conditionally enables instructions instead of branching.

An asynchronous control flow transfer such as an interrupt or a signal alters the normal flow of control to a handler before returning control to where it was interrupted.

One way to attack software is to redirect the flow of execution. A variety of control-flow integrity techniques, including stack canaries, buffer overflow protection, shadow stacks, and vtable pointer verification, are used to defend against these attacks.

Structure

Control flow is closely related to code structure. Control flows along lines defined by structure and the execution rules of a language. This general concept of structure is not be confused with structured programming which limits structure to sequencing, selection and iteration based on block organization.

Sequences

Sequential execution is the most basic structure. Although not all code is sequential in nature, imperative code is.

Labels

A label identifies a position in source code. Some control flow statements reference a label so that control jumps to the labeled line. Other than marking a position, a label has no other effect.

Some languages limit a label to a number which is sometimes called a line number, although that implies the inherent index of the line, not a label. None-the-less, such numeric labels are typically required to increment from top to bottom in a file even if not be sequential. For example, in BASIC:

<span id="mwRA"></span><span class="nl" id="mwRQ">10</span><span class="w" id="mwRg"> </span><span class="kd" id="mwRw">LET</span><span class="w" id="mwSA"> </span><span class="vg" id="mwSQ">X</span><span class="w" id="mwSg"> </span><span class="o" id="mwSw">=</span><span class="w" id="mwTA"> </span><span class="il" id="mwTQ">3</span> <span class="nl" id="mwTg">20</span><span class="w" id="mwTw"> </span><span class="kr" id="mwUA">PRINT</span><span class="w" id="mwUQ"> </span><span class="vg" id="mwUg">X</span> <span class="nl" id="mwUw">30</span><span class="w" id="mwVA"> </span><span class="kr" id="mwVQ">GOTO</span><span class="w" id="mwVg"> </span><span class="nl" id="mwVw">10</span>

In many languages, a label is an alphanumeric identifier, usually appearing at the start of a line and immediately followed by a colon. For example, the following C code defines a label Success on line 3 which identifies a jump target point at the first statement that follows it (line 4).

<span id="mwXQ"></span><span class="linenos" data-line="1" id="mwXg"></span><span class="kt" id="mwXw">void</span><span class="w" id="mwYA"> </span><span class="nf" id="mwYQ">f</span><span class="p" id="mwYg">(</span><span class="kt" id="mwYw">bool</span><span class="w" id="mwZA"> </span><span class="n" id="mwZQ">ok</span><span class="p" id="mwZg">)</span><span class="w" id="mwZw"> </span><span class="p" id="mwaA">{</span> <span class="linenos" data-line="2" id="mwaQ"></span><span class="w" id="mwag"> </span><span class="k" id="mwaw">if</span><span class="w" id="mwbA"> </span><span class="p" id="mwbQ">(</span><span class="n" id="mwbg">ok</span><span class="p" id="mwbw">)</span><span class="w" id="mwcA"> </span><span class="p" id="mwcQ">{</span> <span class="linenos" data-line="3" id="mwcg"></span><span class="w" id="mwcw"> </span><span class="k" id="mwdA">goto</span><span class="w" id="mwdQ"> </span><span class="n" id="mwdg">success</span><span class="p" id="mwdw">;</span> <span class="linenos" data-line="4" id="mweA"></span><span class="w" id="mweQ"> </span><span class="p" id="mweg">}</span> <span class="linenos" data-line="5" id="mwew"></span><span class="w" id="mwfA"> </span><span class="k" id="mwfQ">return</span><span class="p" id="mwfg">;</span> <span class="linenos" data-line="6" id="mwfw"></span><span class="nl" id="mwgA">success</span><span class="p" id="mwgQ">:</span> <span class="linenos" data-line="7" id="mwgg"></span><span class="w" id="mwgw"> </span><span class="n" id="mwhA">printf</span><span class="p" id="mwhQ">(</span><span class="s" id="mwhg">"OK"</span><span class="p" id="mwhw">);</span> <span class="linenos" data-line="8" id="mwiA"></span><span class="p" id="mwiQ">}</span>

Blocks

Most languages provide for organizing sequences of code as a block. When used with a control statement, the beginning of a block provides a jump target. For example, in the following C code (which uses curly braces to delimit a block), control jumps from line 1 to 4 if done is false.

<span id="mwjw"></span><span class="linenos" data-line="1" id="mwkA"></span><span class="k" id="mwkQ">if</span><span class="w" id="mwkg"> </span><span class="p" id="mwkw">(</span><span class="n" id="mwlA">done</span><span class="p" id="mwlQ">)</span><span class="w" id="mwlg"> </span><span class="p" id="mwlw">{</span> <span class="linenos" data-line="2" id="mwmA"></span><span class="w" id="mwmQ"> </span><span class="n" id="mwmg">printf</span><span class="p" id="mwmw">(</span><span class="s" id="mwnA">"All done"</span><span class="p" id="mwnQ">);</span> <span class="linenos" data-line="3" id="mwng"></span><span class="p" id="mwnw">}</span><span class="w" id="mwoA"> </span><span class="k" id="mwoQ">else</span><span class="w" id="mwog"> </span><span class="p" id="mwow">{</span> <span class="linenos" data-line="4" id="mwpA"></span><span class="w" id="mwpQ"> </span><span class="n" id="mwpg">printf</span><span class="p" id="mwpw">(</span><span class="s" id="mwqA">"Still workin' on it"</span><span class="p" id="mwqQ">);</span> <span class="linenos" data-line="5" id="mwqg"></span><span class="p" id="mwqw">}</span>

One more chapter is free with a Lably account.

Control

Many control commands have been devised for programming languages. This section describes notable constructs; it is organized by functionality.

Functions

A function provides for control flow in that when called, execution jumps to the start of the function's code and when it completes, control returns the calling point. In the following C code, control jumps from line 6 to 2 in order to call function foo(). Then, after completing the function body (printing "Hi"), control returns to after the call, line 7.

<span id="mwsw"></span><span class="linenos" data-line="1" id="mwtA"></span><span class="kt" id="mwtQ">void</span><span class="w" id="mwtg"> </span><span class="nf" id="mwtw">foo</span><span class="p" id="mwuA">()</span><span class="w" id="mwuQ"> </span><span class="p" id="mwug">{</span> <span class="linenos" data-line="2" id="mwuw"></span><span class="w" id="mwvA"> </span><span class="n" id="mwvQ">printf</span><span class="p" id="mwvg">(</span><span class="s" id="mwvw">"Hi"</span><span class="p" id="mwwA">);</span> <span class="linenos" data-line="3" id="mwwQ"></span><span class="p" id="mwwg">}</span> <span class="linenos" data-line="4" id="mwww"></span> <span class="linenos" data-line="5" id="mwxA"></span><span class="kt" id="mwxQ">void</span><span class="w" id="mwxg"> </span><span class="nf" id="mwxw">bar</span><span class="p" id="mwyA">()</span><span class="w" id="mwyQ"> </span><span class="p" id="mwyg">{</span> <span class="linenos" data-line="6" id="mwyw"></span><span class="w" id="mwzA"> </span><span class="n" id="mwzQ">foo</span><span class="p" id="mwzg">();</span> <span class="linenos" data-line="7" id="mwzw"></span><span class="w" id="mw0A"> </span><span class="n" id="mw0Q">printf</span><span class="p" id="mw0g">(</span><span class="s" id="mw0w">"Done"</span><span class="p" id="mw1A">);</span> <span class="linenos" data-line="8" id="mw1Q"></span><span class="p" id="mw1g">}</span>

Branches

A branch command moves the point of execution from the point in the code that contains the command to the point that the command specifies.

Jump

A jump command unconditionally branches control to another point in the code, and is the most basic form of controlling the flow of code.

In a high-level language, this is often provided as a goto statement. Although the keyword may be upper or lower case or one or two words depending on the language, it is like: goto label. When control reaches a goto statement, control then jumps to the statement that follows the indicated label. The goto statement has been considered harmful by many computer scientists, including Dijkstra.

Conditional branch

A conditional statement jumps control based on the value of a Boolean expression. Common variations include:

if-goto: Jumps to a label based on a condition; a high-level programming statement that closely mimics a similar used machine code instruction

if-then: Rather than being restricted to a jump, a statement or block is executed if the expression is true. In a language that does not include the then keyword, this can be called an if statement.

if-then-else: Like if-then, but with a second action to be performed if the condition is false. In a language that does not include the then keyword, this can be called an if-else statement.

Nested: Conditional statements are often nested inside other conditional statements.

Arithmetic if: Early Fortran, had an arithmetic if (a.k.a. three-way if) that tests whether a numeric value is negative, zero, or positive. This statement was deemed obsolete in Fortran-90, and deleted as of Fortran 2018.

Operator: Some languages have an operator form, such as the ternary conditional operator.

When and unless: Perl supplements a C-style if with when and unless.

Messages: Smalltalk uses ifTrue and ifFalse messages to implement conditionals, rather than a language construct.

The following Pascal code shows a simple if-then-else. The syntax is similar in Ada:

<span id="mwARA"></span><span class="k" id="mwARE">if</span><span class="w" id="mwARI"> </span><span class="n" id="mwARM">a</span><span class="w" id="mwARQ"> </span><span class="o" id="mwARU">></span><span class="w" id="mwARY"> </span><span class="mi" id="mwARc">0</span><span class="w" id="mwARg"> </span><span class="k" id="mwARk">then</span> <span class="w" id="mwARo"> </span><span class="nb" id="mwARs">writeln</span><span class="p" id="mwARw">(</span><span class="err" id="mwAR0">"</span><span class="n" id="mwAR4">yes</span><span class="err" id="mwAR8">"</span><span class="p" id="mwASA">)</span> <span class="k" id="mwASE">else</span> <span class="w" id="mwASI"> </span><span class="nb" id="mwASM">writeln</span><span class="p" id="mwASQ">(</span><span class="err" id="mwASU">"</span><span class="n" id="mwASY">no</span><span class="err" id="mwASc">"</span><span class="p" id="mwASg">)</span><span class="o" id="mwASk">;</span>

In C:

<span id="mwAS4"></span><span class="k" id="mwAS8">if</span><span class="w" id="mwATA"> </span><span class="p" id="mwATE">(</span><span class="n" id="mwATI">a</span><span class="w" id="mwATM"> </span><span class="o" id="mwATQ">></span><span class="w" id="mwATU"> </span><span class="mi" id="mwATY">0</span><span class="p" id="mwATc">)</span><span class="w" id="mwATg"> </span><span class="p" id="mwATk">{</span><span class="w" id="mwATo"> </span> <span class="w" id="mwATs"> </span><span class="n" id="mwATw">puts</span><span class="p" id="mwAT0">(</span><span class="s" id="mwAT4">"yes"</span><span class="p" id="mwAT8">);</span> <span class="p" id="mwAUA">}</span><span class="w" id="mwAUE"> </span><span class="k" id="mwAUI">else</span><span class="w" id="mwAUM"> </span><span class="p" id="mwAUQ">{</span> <span class="w" id="mwAUU"> </span><span class="n" id="mwAUY">puts</span><span class="p" id="mwAUc">(</span><span class="s" id="mwAUg">"no"</span><span class="p" id="mwAUk">);</span> <span class="p" id="mwAUo">}</span>

In bash:

<span id="mwAU8"></span><span class="k" id="mwAVA">if</span><span class="w" id="mwAVE"> </span><span class="o" id="mwAVI">[</span><span class="w" id="mwAVM"> </span><span class="nv" id="mwAVQ">$a</span><span class="w" id="mwAVU"> </span>-gt<span class="w" id="mwAVY"> </span><span class="m" id="mwAVc">0</span><span class="w" id="mwAVg"> </span><span class="o" id="mwAVk">]</span><span class="p" id="mwAVo">;</span><span class="w" id="mwAVs"> </span><span class="k" id="mwAVw">then</span> <span class="w" id="mwAV0"> </span><span class="nb" id="mwAV4">echo</span><span class="w" id="mwAV8"> </span><span class="s2" id="mwAWA">"yes"</span> <span class="k" id="mwAWE">else</span> <span class="w" id="mwAWI"> </span><span class="nb" id="mwAWM">echo</span><span class="w" id="mwAWQ"> </span><span class="s2" id="mwAWU">"no"</span> <span class="k" id="mwAWY">fi</span>

In Python:

<span id="mwAWs"></span><span class="k" id="mwAWw">if</span> <span class="n" id="mwAW0">a</span> <span class="o" id="mwAW4">></span> <span class="mi" id="mwAW8">0</span><span class="p" id="mwAXA">:</span> <span class="nb" id="mwAXE">print</span><span class="p" id="mwAXI">(</span><span class="s2" id="mwAXM">"yes"</span><span class="p" id="mwAXQ">)</span> <span class="k" id="mwAXU">else</span><span class="p" id="mwAXY">:</span> <span class="nb" id="mwAXc">print</span><span class="p" id="mwAXg">(</span><span class="s2" id="mwAXk">"no"</span><span class="p" id="mwAXo">)</span>

In Lisp:

<span id="mwAX8"></span><span class="p" id="mwAYA">(</span><span class="nb" id="mwAYE">princ</span> <span class="w" id="mwAYI"> </span><span class="p" id="mwAYM">(</span><span class="k" id="mwAYQ">if</span><span class="w" id="mwAYU"> </span><span class="p" id="mwAYY">(</span><span class="nb" id="mwAYc">plusp</span><span class="w" id="mwAYg"> </span><span class="nv" id="mwAYk">a</span><span class="p" id="mwAYo">)</span> <span class="w" id="mwAYs"> </span><span class="s" id="mwAYw">"yes"</span> <span class="w" id="mwAY0"> </span><span class="s" id="mwAY4">"no"</span><span class="p" id="mwAY8">))</span>

Multiway branch

A multiway branch jumps control based on matching values. There is usually a provision for a default action if no match is found. A switch statement can allow compiler optimizations, such as lookup tables. In dynamic languages, the cases may not be limited to constant expressions, and might extend to pattern matching, as in the shell script example on the right, where the *) implements the default case as a glob matching any string. Case logic can also be implemented in functional form, as in SQL's decode statement.

The following Pascal code shows a relatively simple switch statement. Pascal uses the case keyword instead of switch.

<span id="mwAaE"></span><span class="k" id="mwAaI">case</span><span class="w" id="mwAaM"> </span><span class="n" id="mwAaQ">someChar</span><span class="w" id="mwAaU"> </span><span class="k" id="mwAaY">of</span> <span class="w" id="mwAac"> </span><span class="s" id="mwAag">'a'</span><span class="o" id="mwAak">:</span><span class="w" id="mwAao"> </span><span class="n" id="mwAas">actionOnA</span><span class="o" id="mwAaw">;</span> <span class="w" id="mwAa0"> </span><span class="s" id="mwAa4">'x'</span><span class="o" id="mwAa8">:</span><span class="w" id="mwAbA"> </span><span class="n" id="mwAbE">actionOnX</span><span class="o" id="mwAbI">;</span> <span class="w" id="mwAbM"> </span><span class="s" id="mwAbQ">'y'</span><span class="o" id="mwAbU">,</span><span class="s" id="mwAbY">'z'</span><span class="o" id="mwAbc">:</span><span class="n" id="mwAbg">actionOnYandZ</span><span class="o" id="mwAbk">;</span> <span class="w" id="mwAbo"> </span><span class="k" id="mwAbs">else</span><span class="w" id="mwAbw"> </span><span class="n" id="mwAb0">actionOnNoMatch</span><span class="o" id="mwAb4">;</span> <span class="k" id="mwAb8">end</span><span class="o" id="mwAcA">;</span>

In Ada:

<span id="mwAcU"></span><span class="kr" id="mwAcY">case</span> <span class="n" id="mwAcc">someChar</span> <span class="kr" id="mwAcg">is</span> <span class="kr" id="mwAck">when</span> <span class="p" id="mwAco">'</span><span class="na" id="mwAcs">a</span><span class="p" id="mwAcw">'</span> <span class="p" id="mwAc0">=></span> <span class="n" id="mwAc4">actionOnA</span><span class="p" id="mwAc8">;</span> <span class="kr" id="mwAdA">when</span> <span class="p" id="mwAdE">'</span><span class="na" id="mwAdI">x</span><span class="p" id="mwAdM">'</span> <span class="p" id="mwAdQ">=></span> <span class="n" id="mwAdU">actionOnX</span><span class="p" id="mwAdY">;</span> <span class="kr" id="mwAdc">when</span> <span class="p" id="mwAdg">'</span><span class="na" id="mwAdk">y</span><span class="p" id="mwAdo">'</span> <span class="p" id="mwAds">|</span> <span class="p" id="mwAdw">'</span><span class="na" id="mwAd0">z</span><span class="p" id="mwAd4">'</span> <span class="p" id="mwAd8">=></span> <span class="n" id="mwAeA">actionOnYandZ</span><span class="p" id="mwAeE">;</span> <span class="kr" id="mwAeI">when</span> <span class="kr" id="mwAeM">others</span> <span class="p" id="mwAeQ">=></span> <span class="n" id="mwAeU">actionOnNoMatch</span><span class="p" id="mwAeY">;</span> <span class="kr" id="mwAec">end</span><span class="p" id="mwAeg">;</span>

In C:

<span id="mwAe0"></span><span class="k" id="mwAe4">switch</span><span class="w" id="mwAe8"> </span><span class="p" id="mwAfA">(</span><span class="n" id="mwAfE">someChar</span><span class="p" id="mwAfI">)</span><span class="w" id="mwAfM"> </span><span class="p" id="mwAfQ">{</span> <span class="w" id="mwAfU"> </span><span class="k" id="mwAfY">case</span><span class="w" id="mwAfc"> </span><span class="sc" id="mwAfg">'a'</span><span class="p" id="mwAfk">:</span><span class="w" id="mwAfo"> </span> <span class="w" id="mwAfs"> </span><span class="n" id="mwAfw">actionOnA</span><span class="p" id="mwAf0">;</span><span class="w" id="mwAf4"> </span> <span class="w" id="mwAf8"> </span><span class="k" id="mwAgA">break</span><span class="p" id="mwAgE">;</span> <span class="w" id="mwAgI"> </span><span class="k" id="mwAgM">case</span><span class="w" id="mwAgQ"> </span><span class="sc" id="mwAgU">'x'</span><span class="p" id="mwAgY">:</span><span class="w" id="mwAgc"> </span> <span class="w" id="mwAgg"> </span><span class="n" id="mwAgk">actionOnX</span><span class="p" id="mwAgo">;</span><span class="w" id="mwAgs"> </span> <span class="w" id="mwAgw"> </span><span class="k" id="mwAg0">break</span><span class="p" id="mwAg4">;</span> <span class="w" id="mwAg8"> </span><span class="k" id="mwAhA">case</span><span class="w" id="mwAhE"> </span><span class="sc" id="mwAhI">'y'</span><span class="p" id="mwAhM">:</span> <span class="w" id="mwAhQ"> </span><span class="k" id="mwAhU">case</span><span class="w" id="mwAhY"> </span><span class="sc" id="mwAhc">'z'</span><span class="p" id="mwAhg">:</span><span class="w" id="mwAhk"> </span> <span class="w" id="mwAho"> </span><span class="n" id="mwAhs">actionOnYandZ</span><span class="p" id="mwAhw">;</span> <span class="w" id="mwAh0"> </span><span class="k" id="mwAh4">break</span><span class="p" id="mwAh8">;</span> <span class="w" id="mwAiA"> </span><span class="k" id="mwAiE">default</span><span class="o" id="mwAiI">:</span><span class="w" id="mwAiM"> </span> <span class="w" id="mwAiQ"> </span><span class="n" id="mwAiU">actionOnNoMatch</span><span class="p" id="mwAiY">;</span> <span class="p" id="mwAic">}</span>

In Bash:

<span id="mwAiw"></span><span class="k" id="mwAi0">case</span><span class="w" id="mwAi4"> </span><span class="nv" id="mwAi8">$someChar</span><span class="w" id="mwAjA"> </span><span class="k" id="mwAjE">in</span><span class="w" id="mwAjI"> </span> <span class="w" id="mwAjM"> </span>a<span class="o" id="mwAjQ">)</span><span class="w" id="mwAjU"> </span>actionOnA<span class="w" id="mwAjY"> </span><span class="p" id="mwAjc">;;</span> <span class="w" id="mwAjg"> </span>x<span class="o" id="mwAjk">)</span><span class="w" id="mwAjo"> </span>actionOnX<span class="w" id="mwAjs"> </span><span class="p" id="mwAjw">;;</span> <span class="w" id="mwAj0"> </span><span class="o" id="mwAj4">[</span>yz<span class="o" id="mwAj8">])</span><span class="w" id="mwAkA"> </span>actionOnYandZ<span class="w" id="mwAkE"> </span><span class="p" id="mwAkI">;;</span> <span class="w" id="mwAkM"> </span>*<span class="o" id="mwAkQ">)</span><span class="w" id="mwAkU"> </span>actionOnNoMatch<span class="w" id="mwAkY"> </span><span class="p" id="mwAkc">;;</span> <span class="k" id="mwAkg">esac</span>

In Lisp:

<span id="mwAk0"></span><span class="p" id="mwAk4">(</span><span class="nb" id="mwAk8">case</span><span class="w" id="mwAlA"> </span><span class="nv" id="mwAlE">some-char</span> <span class="w" id="mwAlI"> </span><span class="p" id="mwAlM">((</span><span class="sc" id="mwAlQ">#\a</span><span class="p" id="mwAlU">)</span><span class="w" id="mwAlY"> </span><span class="nv" id="mwAlc">action-on-a</span><span class="p" id="mwAlg">)</span> <span class="w" id="mwAlk"> </span><span class="p" id="mwAlo">((</span><span class="sc" id="mwAls">#\x</span><span class="p" id="mwAlw">)</span><span class="w" id="mwAl0"> </span><span class="nv" id="mwAl4">action-on-x</span><span class="p" id="mwAl8">)</span> <span class="w" id="mwAmA"> </span><span class="p" id="mwAmE">((</span><span class="sc" id="mwAmI">#\y</span><span class="w" id="mwAmM"> </span><span class="sc" id="mwAmQ">#\z</span><span class="p" id="mwAmU">)</span><span class="w" id="mwAmY"> </span><span class="nv" id="mwAmc">action-on-y-and-z</span><span class="p" id="mwAmg">)</span> <span class="w" id="mwAmk"> </span><span class="p" id="mwAmo">(</span><span class="nv" id="mwAms">else</span><span class="w" id="mwAmw"> </span><span class="nv" id="mwAm0">action-on-no-match</span><span class="p" id="mwAm4">))</span>

In Fortran:

<span id="mwAnM"></span><span class="k" id="mwAnQ">select case</span><span class="w" id="mwAnU"> </span><span class="p" id="mwAnY">(</span><span class="n" id="mwAnc">someChar</span><span class="p" id="mwAng">)</span> <span class="w" id="mwAnk"> </span><span class="k" id="mwAno">case</span><span class="w" id="mwAns"> </span><span class="p" id="mwAnw">(</span><span class="s1" id="mwAn0">'a'</span><span class="p" id="mwAn4">)</span> <span class="w" id="mwAn8"> </span><span class="n" id="mwAoA">actionOnA</span> <span class="w" id="mwAoE"> </span><span class="k" id="mwAoI">case</span><span class="w" id="mwAoM"> </span><span class="p" id="mwAoQ">(</span><span class="s1" id="mwAoU">'x'</span><span class="p" id="mwAoY">)</span> <span class="w" id="mwAoc"> </span><span class="n" id="mwAog">actionOnX</span> <span class="w" id="mwAok"> </span><span class="k" id="mwAoo">case</span><span class="w" id="mwAos"> </span><span class="p" id="mwAow">(</span><span class="s1" id="mwAo0">'y'</span><span class="p" id="mwAo4">,</span><span class="s1" id="mwAo8">'z'</span><span class="p" id="mwApA">)</span> <span class="w" id="mwApE"> </span><span class="n" id="mwApI">actionOnYandZ</span> <span class="w" id="mwApM"> </span><span class="k" id="mwApQ">case </span><span class="n" id="mwApU">default</span> <span class="w" id="mwApY"> </span><span class="n" id="mwApc">actionOnNoMatch</span> <span class="k" id="mwApg">end select</span>

Loops

In a loop, a sequence of statements—frequently called the loop body—gets re-executed (at least in part) after a conditional branch or jump to a previous step in the sequence. The number of times a loop gets executed usually depends on runtime state, for example: the body is executed once for each item of a collection (definite iteration), until a condition is met (indefinite iteration). Some loops, on the other hand, may repeat infinitely. It is possible for a loop to be written as an infinite loop but for loop exit to be controlled by a test within the loop body that transfers control outside the loop. Early exit from a loop may be supported via a break statement.

A loop inside the loop body of another loop is called a nested loop.

In a functional programming language, such as Haskell and Scheme, both recursive and iterative processes are expressed with tail recursive procedures instead of looping constructs that are syntactic.

Numeric

A relatively simple yet useful loop iterates over a range of numeric values. A simple form starts at an integer value, ends at a larger integer value and iterates for each integer value between. Often, the increment can be any integer value (even negative, to loop from a larger to a smaller value).

Example in BASIC:

<span id="mwAsg"></span><span class="kr" id="mwAsk">FOR</span><span class="w" id="mwAso"> </span><span class="vg" id="mwAss">I</span><span class="w" id="mwAsw"> </span><span class="o" id="mwAs0">=</span><span class="w" id="mwAs4"> </span><span class="il" id="mwAs8">1</span><span class="w" id="mwAtA"> </span><span class="k" id="mwAtE">TO</span><span class="w" id="mwAtI"> </span><span class="vg" id="mwAtM">N</span> <span class="w" id="mwAtQ"> </span><span class="vg" id="mwAtU">xxx</span> <span class="kr" id="mwAtY">NEXT</span><span class="w" id="mwAtc"> </span><span class="vg" id="mwAtg">I</span>

Example in Pascal:

<span id="mwAtw"></span><span class="k" id="mwAt0">for</span><span class="w" id="mwAt4"> </span><span class="n" id="mwAt8">I</span><span class="w" id="mwAuA"> </span><span class="o" id="mwAuE">:=</span><span class="w" id="mwAuI"> </span><span class="mi" id="mwAuM">1</span><span class="w" id="mwAuQ"> </span><span class="k" id="mwAuU">to</span><span class="w" id="mwAuY"> </span><span class="n" id="mwAuc">N</span><span class="w" id="mwAug"> </span><span class="k" id="mwAuk">do</span><span class="w" id="mwAuo"> </span><span class="k" id="mwAus">begin</span> <span class="w" id="mwAuw"> </span><span class="n" id="mwAu0">xxx</span> <span class="k" id="mwAu4">end</span><span class="o" id="mwAu8">;</span>

Example in Fortran:

<span id="mwAvM"></span><span class="k" id="mwAvQ">DO </span><span class="n" id="mwAvU">I</span><span class="w" id="mwAvY"> </span><span class="o" id="mwAvc">=</span><span class="w" id="mwAvg"> </span><span class="mi" id="mwAvk">1</span><span class="p" id="mwAvo">,</span><span class="n" id="mwAvs">N</span> <span class="w" id="mwAvw"> </span><span class="n" id="mwAv0">xxx</span> <span class="k" id="mwAv4">END DO</span>

In many programming languages, only integers can be used at all or reliably. As a floating-point number is represented imprecisely due to hardware constraints, the following loop might iterate 9 or 10 times, depending on various factors such as rounding error, hardware, compiler. Furthermore, if the increment of X occurs by repeated addition, accumulated rounding errors may mean that the value of X in each iteration can differ quite significantly from the commonly expected sequence of 0.1, 0.2, 0.3, ..., 1.0.

<b id="mwAwE">for</b> X := 0.1 <b id="mwAwI">step</b> 0.1 <b id="mwAwM">to</b> 1.0 <b id="mwAwQ">do</b>

Condition-controlled

Some loop constructs iterate until a condition is true. Some variations test the condition at the start of the loop; others test at the end. If the test is at the start, the body may be skipped completely. At the end, the body is always executed at least once.

Example in Visual Basic:

<span id="mwAww"></span><span class="k" id="mwAw0">DO</span><span class="w" id="mwAw4"> </span><span class="k" id="mwAw8">WHILE</span><span class="w" id="mwAxA"> </span><span class="p" id="mwAxE">(</span><span class="n" id="mwAxI">test</span><span class="p" id="mwAxM">)</span> <span class="w" id="mwAxQ"> </span><span class="n" id="mwAxU">xxx</span> <span class="k" id="mwAxY">LOOP</span>

Example in Pascal:

<span id="mwAxo"></span><span class="k" id="mwAxs">repeat</span> <span class="w" id="mwAxw"> </span><span class="n" id="mwAx0">xxx</span> <span class="k" id="mwAx4">until</span><span class="w" id="mwAx8"> </span><span class="n" id="mwAyA">test</span><span class="o" id="mwAyE">;</span>

Example in C family of pre-test:

<span id="mwAyU"></span><span class="k" id="mwAyY">while</span><span class="w" id="mwAyc"> </span><span class="p" id="mwAyg">(</span><span class="n" id="mwAyk">test</span><span class="p" id="mwAyo">)</span><span class="w" id="mwAys"> </span><span class="p" id="mwAyw">{</span> <span class="w" id="mwAy0"> </span><span class="n" id="mwAy4">xxx</span> <span class="p" id="mwAy8">}</span>

Example in C family of post-test:

<span id="mwAzM"></span><span class="k" id="mwAzQ">do</span> <span class="w" id="mwAzU"> </span><span class="n" id="mwAzY">xxx</span> <span class="nf" id="mwAzc">while</span><span class="w" id="mwAzg"> </span><span class="p" id="mwAzk">(</span><span class="n" id="mwAzo">test</span><span class="p" id="mwAzs">);</span>

Although using the for keyword, the three-part C-style loop is a condition-based construct, not a numeric-based one. The second part, the condition, is evaluated before each loop, so the loop is pre-test. The first part is a place to initialize state, and the third part is for incrementing for the next iteration, but both aspects can be performed elsewhere. The following C code implements the logic of a numeric loop that iterates for i from 0 to n-1.

<span id="mwA0A"></span><span class="k" id="mwA0E">for</span><span class="w" id="mwA0I"> </span><span class="p" id="mwA0M">(</span><span class="kt" id="mwA0Q">int</span><span class="w" id="mwA0U"> </span><span class="n" id="mwA0Y">i</span><span class="w" id="mwA0c"> </span><span class="o" id="mwA0g">=</span><span class="w" id="mwA0k"> </span><span class="mi" id="mwA0o">0</span><span class="p" id="mwA0s">;</span><span class="w" id="mwA0w"> </span><span class="n" id="mwA00">i</span><span class="w" id="mwA04"> </span><span class="o" id="mwA08"><</span><span class="w" id="mwA1A"> </span><span class="n" id="mwA1E">n</span><span class="p" id="mwA1I">;</span><span class="w" id="mwA1M"> </span><span class="o" id="mwA1Q">++</span><span class="n" id="mwA1U">i</span><span class="p" id="mwA1Y">)</span><span class="w" id="mwA1c"> </span><span class="p" id="mwA1g">{</span> <span class="w" id="mwA1k"> </span><span class="n" id="mwA1o">xxx</span> <span class="p" id="mwA1s">}</span>

Enumeration

Some loop constructs enumerate the items of a collection; iterating for each item.

Example in Smalltalk:

<span id="mwA2M"></span><span class="nv" id="mwA2Q">someCollection</span> <span class="nf" id="mwA2U">do:</span> [<span class="o" id="mwA2Y">:</span><span class="nv" id="mwA2c">eachElement</span> <span class="o" id="mwA2g">|</span><span class="nv" id="mwA2k">xxx</span>]<span class="p" id="mwA2o">.</span>

Example in Pascal:

<span id="mwA24"></span><span class="k" id="mwA28">for</span><span class="w" id="mwA3A"> </span><span class="n" id="mwA3E">Item</span><span class="w" id="mwA3I"> </span><span class="k" id="mwA3M">in</span><span class="w" id="mwA3Q"> </span><span class="n" id="mwA3U">Collection</span><span class="w" id="mwA3Y"> </span><span class="k" id="mwA3c">do</span><span class="w" id="mwA3g"> </span><span class="k" id="mwA3k">begin</span><span class="w" id="mwA3o"> </span><span class="n" id="mwA3s">xxx</span><span class="w" id="mwA3w"> </span><span class="k" id="mwA30">end</span><span class="o" id="mwA34">;</span>

Example in Raku:

<span id="mwA4I"></span><span class="n" id="mwA4M">foreach</span> (<span class="nb" id="mwA4Q">item</span>; <span class="n" id="mwA4U">myCollection</span>) { <span class="n" id="mwA4Y">xxx</span> }

Example in TCL:

<span id="mwA4o"></span><span class="k" id="mwA4s">foreach</span><span class="w" id="mwA4w"> </span>someArray<span class="w" id="mwA40"> </span><span class="k" id="mwA44">{</span><span class="w" id="mwA48"> </span><span class="nv" id="mwA5A">xxx</span><span class="w" id="mwA5E"> </span><span class="k" id="mwA5I">}</span>

Example in PHP:

<span id="mwA5Y"></span><span class="k" id="mwA5c">foreach</span> <span class="p" id="mwA5g">(</span><span class="nv" id="mwA5k">$someArray</span> <span class="k" id="mwA5o">as</span> <span class="nv" id="mwA5s">$k</span> <span class="o" id="mwA5w">=></span> <span class="nv" id="mwA50">$v</span><span class="p" id="mwA54">)</span> <span class="p" id="mwA58">{</span> <span class="nx" id="mwA6A">xxx</span> <span class="p" id="mwA6E">}</span>

Example in Java:

<span id="mwA6U"></span><span class="n" id="mwA6Y">Collection</span><span class="o" id="mwA6c"><</span><span class="n" id="mwA6g">String</span><span class="o" id="mwA6k">></span><span class="w" id="mwA6o"> </span><span class="n" id="mwA6s">coll</span><span class="p" id="mwA6w">;</span><span class="w" id="mwA60"> </span> <span class="k" id="mwA64">for</span><span class="w" id="mwA68"> </span><span class="p" id="mwA7A">(</span><span class="n" id="mwA7E">String</span><span class="w" id="mwA7I"> </span><span class="n" id="mwA7M">s</span><span class="w" id="mwA7Q"> </span><span class="p" id="mwA7U">:</span><span class="w" id="mwA7Y"> </span><span class="n" id="mwA7c">coll</span><span class="p" id="mwA7g">)</span><span class="w" id="mwA7k"> </span><span class="p" id="mwA7o">{}</span>

Example in C#:

<span id="mwA74"></span><span class="k" id="mwA78">foreach</span><span class="w" id="mwA8A"> </span><span class="p" id="mwA8E">(</span><span class="kt" id="mwA8I">string</span><span class="w" id="mwA8M"> </span><span class="n" id="mwA8Q">s</span><span class="w" id="mwA8U"> </span><span class="k" id="mwA8Y">in</span><span class="w" id="mwA8c"> </span><span class="n" id="mwA8g">myStringCollection</span><span class="p" id="mwA8k">)</span><span class="w" id="mwA8o"> </span><span class="p" id="mwA8s">{</span><span class="w" id="mwA8w"> </span><span class="n" id="mwA80">xxx</span><span class="w" id="mwA84"> </span><span class="p" id="mwA88">}</span>

Example in PowerShell where 'foreach' is an alias of 'ForEach-Object':

<span id="mwA9M"></span><span class="n" id="mwA9Q">someCollection</span> <span class="p" id="mwA9U">|</span> <span class="k" id="mwA9Y">foreach</span> <span class="p" id="mwA9c">{</span> <span class="nv" id="mwA9g">$_</span> <span class="p" id="mwA9k">}</span>

Example in Fortran:

<span id="mwA90"></span><span class="k" id="mwA94">forall</span><span class="w" id="mwA98"> </span><span class="p" id="mwA-A">(</span><span class="w" id="mwA-E"> </span><span class="nb" id="mwA-I">index</span><span class="w" id="mwA-M"> </span><span class="o" id="mwA-Q">=</span><span class="w" id="mwA-U"> </span><span class="n" id="mwA-Y">first</span><span class="p" id="mwA-c">:</span><span class="n" id="mwA-g">last</span><span class="p" id="mwA-k">:</span><span class="n" id="mwA-o">step</span><span class="p" id="mwA-s">...</span><span class="w" id="mwA-w"> </span><span class="p" id="mwA-0">)</span>

Scala has for-expressions, which generalise collection-controlled loops, and also support other uses, such as asynchronous programming. Haskell has do-expressions and comprehensions, which together provide similar function to for-expressions in Scala.

Infinite

In computer programming, an infinite loop (or endless loop) is a sequence of instructions that, as written, will continue endlessly, unless an external intervention occurs, such as turning off power via a switch or pulling a plug. It may be intentional.

There is no general algorithm to determine whether a computer program contains an infinite loop or not; this is the halting problem.

Loop-and-a-half problem

Common loop structures sometimes result in duplicated code, either repeated statements or repeated conditions. This arises for various reasons and has various proposed solutions to eliminate or minimize code duplication. Other than the traditional unstructured solution of a goto statement, general structured solutions include having a conditional (if statement) inside the loop (possibly duplicating the condition but not the statements) or wrapping repeated logic in a function (so there is a duplicated function call, but the statements are not duplicated).

A common case is where the start of the loop is always executed, but the end may be skipped on the last iteration. This was dubbed by Dijkstra a loop which is performed "n and a half times", and is now called the loop-and-a-half problem. Common cases include reading data in the first part, checking for end of data, and then processing the data in the second part; or processing, checking for end, and then preparing for the next iteration. In these cases, the first part of the loop is executed ⁠ $n$ ⁠ times, but the second part is only executed ⁠ $n - 1$ ⁠ times.

This problem has been recognized at least since 1967 by Knuth, with Wirth suggesting solving it via early loop exit. Since the 1990s this has been the most commonly taught solution, using a break statement, as in:

<b id="mwBDI">loop</b> <i id="mwBDM">statements</i> <b id="mwBDQ">if</b> <i id="mwBDU">condition</i> <b id="mwBDY">break</b> <i id="mwBDc">statements</i> <b id="mwBDg">repeat</b>

A subtlety of this solution is that the condition is the opposite of a usual while condition: rewriting while condition ... repeat with an exit in the middle requires reversing the condition: loop ... if not condition exit ... repeat. The loop with test in the middle control structure explicitly supports the loop-an-a-half use case, without reversing the condition.

Unstructured

A loop construct provides for structured completion criteria that either results in another iteration or continuing execution after the loop statement. But, various unstructured control flow constructs are supported by many languages.

Early next iteration: Some languages provide a construct that jumps control to the beginning of the loop body for the next iteration; for example, continue (most common), skip, cycle (Fortran), or next (Perl and Ruby).

Redo iteration: Some languages, like Perl and Ruby, have a redo statement that jumps to the start of the body for the same iteration.

Restart: Ruby has a retry statement that restarts the entire loop from the first iteration.

Early exit

Early exit jumps control to after the loop body For example, when searching a list, can stop looping when the item is found. Some programming languages provide a statement such as break (most languages), Exit (Visual Basic), or last (Perl).

In the following Ada code, the loop exits when X is 0.

<span id="mwBHo"></span><span class="kr" id="mwBHs">loop</span> <span class="n" id="mwBHw">Get</span><span class="p" id="mwBH0">(</span><span class="n" id="mwBH4">X</span><span class="p" id="mwBH8">);</span> <span class="kr" id="mwBIA">if</span> <span class="n" id="mwBIE">X</span> <span class="o" id="mwBII">=</span> <span class="mi" id="mwBIM">0</span> <span class="kr" id="mwBIQ">then</span> <span class="kr" id="mwBIU">exit</span><span class="p" id="mwBIY">;</span> <span class="kr" id="mwBIc">end</span> <span class="kr" id="mwBIg">if</span><span class="p" id="mwBIk">;</span> <span class="n" id="mwBIo">DoSomething</span><span class="p" id="mwBIs">(</span><span class="n" id="mwBIw">X</span><span class="p" id="mwBI0">);</span> <span class="kr" id="mwBI4">end</span> <span class="kr" id="mwBI8">loop</span><span class="p" id="mwBJA">;</span>

A more idiomatic style uses exit when:

<span id="mwBJU"></span><span class="kr" id="mwBJY">loop</span> <span class="n" id="mwBJc">Get</span><span class="p" id="mwBJg">(</span><span class="n" id="mwBJk">X</span><span class="p" id="mwBJo">);</span> <span class="kr" id="mwBJs">exit</span> <span class="kr" id="mwBJw">when</span> <span class="n" id="mwBJ0">X</span> <span class="o" id="mwBJ4">=</span> <span class="mi" id="mwBJ8">0</span><span class="p" id="mwBKA">;</span> <span class="n" id="mwBKE">DoSomething</span><span class="p" id="mwBKI">(</span><span class="n" id="mwBKM">X</span><span class="p" id="mwBKQ">);</span> <span class="kr" id="mwBKU">end</span> <span class="kr" id="mwBKY">loop</span><span class="p" id="mwBKc">;</span>

Python supports conditional execution of code depending on whether a loop was exited early (with a break statement) or not by using an else-clause with the loop. In the following Python code, the else clause is linked to the for statement, and not the inner if statement. Both Python's for and while loops support such an else clause, which is executed only if early exit of the loop has not occurred.

<span id="mwBLI"></span><span class="k" id="mwBLM">for</span> <span class="n" id="mwBLQ">n</span> <span class="ow" id="mwBLU">in</span> <span class="n" id="mwBLY">set_of_numbers</span><span class="p" id="mwBLc">:</span> <span class="k" id="mwBLg">if</span> <span class="n" id="mwBLk">isprime</span><span class="p" id="mwBLo">(</span><span class="n" id="mwBLs">n</span><span class="p" id="mwBLw">):</span> <span class="nb" id="mwBL0">print</span><span class="p" id="mwBL4">(</span><span class="s2" id="mwBL8">"Set contains a prime number"</span><span class="p" id="mwBMA">)</span> <span class="k" id="mwBME">break</span> <span class="k" id="mwBMI">else</span><span class="p" id="mwBMM">:</span> <span class="nb" id="mwBMQ">print</span><span class="p" id="mwBMU">(</span><span class="s2" id="mwBMY">"Set did not contain any prime numbers"</span><span class="p" id="mwBMc">)</span>

Multi-level breaks

Some languages support breaking out of nested loops; in theory circles, these are called multi-level breaks. One common use example is searching a multi-dimensional table. This can be done either via multilevel breaks (break out of $N$ levels), as in bash and PHP, or via labeled breaks (break out and continue at given label), as in Ada, Go, Java, Rust and Perl. Alternatives to multilevel breaks include single breaks, together with a state variable which is tested to break out another level; exceptions, which are caught at the level being broken out to; placing the nested loops in a function and using return to effect termination of the entire nested loop; or using a label and a goto statement. Neither C nor C++ currently have multilevel break or named loops, and the usual alternative is to use a goto to implement a labeled break. However, the inclusion of this feature has been proposed, and was added to C29, following the Java syntax. Python does not have a multilevel break or continue – this was proposed in PEP 3136, and rejected on the basis that the added complexity was not worth the rare legitimate use.

The notion of multi-level breaks is of some interest in theoretical computer science, because it gives rise to what is today called the Kosaraju hierarchy. In 1973 S. Rao Kosaraju refined the structured program theorem by proving that it is possible to avoid adding additional variables in structured programming, as long as arbitrary-depth, multi-level breaks from loops are allowed. Furthermore, Kosaraju proved that a strict hierarchy of programs exists: for every integer $n$ , there exists a program containing a multi-level break of depth $n$ that cannot be rewritten as a program with multi-level breaks of depth less than n without introducing added variables.

In his 2004 textbook, David Watt uses Tennent's notion of sequencer to explain the similarity between multi-level breaks and return statements. Watt notes that a class of sequencers known as escape sequencers, defined as "sequencer that terminates execution of a textually enclosing command or procedure", encompasses both breaks from loops (including multi-level breaks) and return statements. As commonly implemented, however, return sequencers may also carry a (return) value, whereas the break sequencer as implemented in contemporary languages usually cannot.

Middle test

The following structure was proposed by Dahl in 1972:

<b id="mwBQ4">loop</b> <b id="mwBQ8">loop</b> xxx1 read(char); <b id="mwBRA">while</b> test; <b id="mwBRE">while</b> <b id="mwBRI">not</b> atEndOfFile; xxx2 write(char); <b id="mwBRM">repeat</b>; <b id="mwBRQ">repeat</b>;

The construction here can be thought of as a do loop with the while check in the middle, which allows clear loop-and-a-half logic. Further, by omitting individual components, this single construction can replace several constructions in most programming languages. If xxx1 is omitted, we get a loop with the test at the top (a traditional while loop). If xxx2 is omitted, we get a loop with the test at the bottom, equivalent to a do while loop in many languages. If while is omitted, we get an infinite loop. This construction also allows keeping the same polarity of the condition even when in the middle, unlike early exit, which requires reversing the polarity (adding a not), functioning as until instead of while.

This structure is not widely supported, with most languages instead using if ... break for conditional early exit.

This is supported by some languages, such as Forth, where the syntax is BEGIN ... WHILE ... REPEAT, and the shell script languages Bourne shell (sh) and bash, where the syntax is while ... do ... done or until ... do ... done, as:

<span id="mwBUI"></span><span class="k" id="mwBUM">while</span> <span class="w" id="mwBUQ"> </span>statement-1 <span class="w" id="mwBUU"> </span>statement-2 <span class="w" id="mwBUY"> </span>... <span class="w" id="mwBUc"> </span>condition <span class="k" id="mwBUg">do</span> <span class="w" id="mwBUk"> </span>statement-a <span class="w" id="mwBUo"> </span>statement-b <span class="w" id="mwBUs"> </span>... <span class="k" id="mwBUw">done</span>

The shell syntax works because the while (or until) loop accepts a list of commands as a condition, formally:

<b id="mwBVU">while</b> <i id="mwBVY">test-commands</i>; <b id="mwBVc">do</b> <i id="mwBVg">consequent-commands</i>; <b id="mwBVk">done</b>

The value (exit status) of the list of test-commands is the value of the last command, and these can be separated by newlines, resulting in the idiomatic form above.

Similar constructions are possible in C and C++ with the comma operator, and other languages with similar constructs, which allow shoehorning a list of statements into the while condition:

<span id="mwBWI"></span><span class="k" id="mwBWM">while</span><span class="w" id="mwBWQ"> </span><span class="p" id="mwBWU">(</span><span class="n" id="mwBWY">statement_1</span><span class="p" id="mwBWc">,</span><span class="w" id="mwBWg"> </span><span class="n" id="mwBWk">statement_2</span><span class="p" id="mwBWo">,</span><span class="w" id="mwBWs"> </span><span class="n" id="mwBWw">condition</span><span class="p" id="mwBW0">)</span><span class="w" id="mwBW4"> </span><span class="p" id="mwBW8">{</span> <span class="w" id="mwBXA"> </span><span class="n" id="mwBXE">statement_a</span><span class="p" id="mwBXI">;</span> <span class="w" id="mwBXM"> </span><span class="n" id="mwBXQ">statement_b</span><span class="p" id="mwBXU">;</span> <span class="p" id="mwBXY">}</span>

While legal, this is marginal, and it is primarily used, if at all, only for short modify-then-test cases, as in:

<span id="mwBX4"></span><span class="k" id="mwBX8">while</span><span class="w" id="mwBYA"> </span><span class="p" id="mwBYE">(</span><span class="n" id="mwBYI">read_string</span><span class="p" id="mwBYM">(</span><span class="n" id="mwBYQ">s</span><span class="p" id="mwBYU">),</span><span class="w" id="mwBYY"> </span><span class="n" id="mwBYc">strlen</span><span class="p" id="mwBYg">(</span><span class="n" id="mwBYk">s</span><span class="p" id="mwBYo">)</span><span class="w" id="mwBYs"> </span><span class="o" id="mwBYw">></span><span class="w" id="mwBY0"> </span><span class="mi" id="mwBY4">0</span><span class="p" id="mwBY8">)</span><span class="w" id="mwBZA"> </span><span class="p" id="mwBZE">{</span> <span class="w" id="mwBZI"> </span><span class="c1" id="mwBZM">// ...</span> <span class="p" id="mwBZQ">}</span>

Loop variants and invariants

Loop variants and loop invariants are used to express correctness of loops.

In practical terms, a loop variant is an integer expression which has an initial non-negative value. The variant's value must decrease during each loop iteration but must never become negative during the correct execution of the loop. Loop variants are used to guarantee that loops will terminate.

A loop invariant is an assertion which must be true before the first loop iteration and remain true after each iteration. This implies that when a loop terminates correctly, both the exit condition and the loop invariant are satisfied. Loop invariants are used to monitor specific properties of a loop during successive iterations.

Some programming languages, such as Eiffel contain native support for loop variants and invariants. In other cases, support is an add-on, such as the Java Modeling Language's specification for loop statements in Java.

Loop sublanguage

Some Lisp dialects provide an extensive sublanguage for describing Loops. An early example can be found in Conversional Lisp of Interlisp. Common Lisp provides a Loop macro which implements such a sublanguage.

Loop system cross-reference table

^a while (true) does not count as an infinite loop for this purpose, because it is not a dedicated language structure.
^a ^b ^c ^d ^e ^f ^g ^h C's for (init; test; increment) loop is a general loop construct, not specifically a counting one, although it is often used for that.
^a ^b ^c Deep breaks may be accomplished in APL, C, C++ and C# through the use of labels and gotos.
^a Iteration over objects was added in PHP 5.
^a ^b ^c ^d ^e ^f A counting loop can be simulated by iterating over an incrementing list or generator, for instance, Python's range().
^a ^b ^c ^d ^e Deep breaks may be accomplished through the use of exception handling.
^a There is no special construct, since the while function can be used for this.
^a There is no special construct, but users can define general loop functions.
^a The C++11 standard introduced the range-based for. In the STL, there is a std::for_each template function which can iterate on STL containers and call a unary function for each element. The functionality also can be constructed as macro on these containers.
^a Numeric looping is effected by iteration across an integer interval; early exit by including an additional condition for exit.
^a Eiffel supports a reserved word retry, however it is used in exception handling, not loop control.
^a Requires Java Modeling Language (JML) behavioral interface specification language.
^a Requires loop variants to be integers; transfinite variants are not supported. Eiffel: Why loop variants are integers
^a D supports infinite collections, and the ability to iterate over those collections. This does not require any special construct.
^a Deep breaks can be achieved using GO TO and procedures.
^a Common Lisp predates the concept of generic collection type.
^a ^b Odin's general for loop supports syntax shortcuts for conditional loop and infinite loop.

Non-local

Many programming languages, especially those favoring more dynamic styles of programming, offer constructs for non-local control flow which cause execution to jump from the current execution point to a predeclared point. Notable examples follow.

Condition handling

The earliest Fortran compilers supported statements for handling exceptional conditions including IF ACCUMULATOR OVERFLOW, IF QUOTIENT OVERFLOW, and IF DIVIDE CHECK. In the interest of machine independence, they were not included in FORTRAN IV and the Fortran 66 Standard. However, since Fortran 2003 it is possible to test for numerical issues via calls to functions in the IEEE_EXCEPTIONS module.

PL/I has some 22 standard conditions (e.g., ZERODIVIDE SUBSCRIPTRANGE ENDFILE) which can be raised and which can be intercepted by: ON condition action; Programmers can also define and use their own named conditions.

Like the unstructured if, only one statement can be specified so in many cases a GOTO is needed to decide where flow of control should resume.

Unfortunately, some implementations had a substantial overhead in both space and time (especially SUBSCRIPTRANGE), so many programmers tried to avoid using conditions.

A typical example of syntax:

<b id="mwCDc">ON</b> <i id="mwCDg">condition</i> <b id="mwCDk">GOTO</b> <i id="mwCDo">label</i>

Exception handling

Many modern languages natively support exception handling. Generally, exceptional control flow starts with an exception object being thrown (a.k.a. raised). Control then proceeds to the inner-most exception handler for the call stack. If the handler handles the exception, then flow control reverts to normal. Otherwise, control proceeds outward to containing handlers until one handles the exception or the program reaches the outermost scope and exits. As control flows to progressively outer handlers, aspects that would normally occur such as popping the call stack are handled automatically.

The following C++ code demonstrates structured exception handling. If an exception propagates from the execution of doSomething() and the exception object type matches one of the types specified in a catch clause, then that clause is executed. For example, if an exception of type SomeException is propagated by doSomething(), then control jumps from line 2 to 4 and the message "Caught SomeException" is printed and then control jumps to after the try statement, line 8. If an exception of any other type is propagated, then control jumps from line 2 to 6. If no exception, then control jumps from 2 to 8.

<span id="mwCEY"></span><span class="linenos" data-line="1" id="mwCEc"></span><span class="k" id="mwCEg">try</span><span class="w" id="mwCEk"> </span><span class="p" id="mwCEo">{</span> <span class="linenos" data-line="2" id="mwCEs"></span><span class="w" id="mwCEw"> </span><span class="n" id="mwCE0">doSomething</span><span class="p" id="mwCE4">();</span> <span class="linenos" data-line="3" id="mwCE8"></span><span class="p" id="mwCFA">}</span><span class="w" id="mwCFE"> </span><span class="k" id="mwCFI">catch</span><span class="w" id="mwCFM"> </span><span class="p" id="mwCFQ">(</span><span class="k" id="mwCFU">const</span><span class="w" id="mwCFY"> </span><span class="n" id="mwCFc">SomeException</span><span class="o" id="mwCFg">&</span><span class="w" id="mwCFk"> </span><span class="n" id="mwCFo">e</span><span class="p" id="mwCFs">)</span> <span class="linenos" data-line="4" id="mwCFw"></span><span class="w" id="mwCF0"> </span><span class="n" id="mwCF4">std</span><span class="o" id="mwCF8">::</span><span class="n" id="mwCGA">println</span><span class="p" id="mwCGE">(</span><span class="s" id="mwCGI">"Caught SomeException: {}"</span><span class="p" id="mwCGM">,</span><span class="w" id="mwCGQ"> </span><span class="n" id="mwCGU">e</span><span class="p" id="mwCGY">.</span><span class="n" id="mwCGc">what</span><span class="p" id="mwCGg">());</span> <span class="linenos" data-line="5" id="mwCGk"></span><span class="p" id="mwCGo">}</span><span class="w" id="mwCGs"> </span><span class="k" id="mwCGw">catch</span><span class="w" id="mwCG0"> </span><span class="p" id="mwCG4">(...)</span><span class="w" id="mwCG8"> </span><span class="p" id="mwCHA">{</span> <span class="linenos" data-line="6" id="mwCHE"></span><span class="w" id="mwCHI"> </span><span class="n" id="mwCHM">std</span><span class="o" id="mwCHQ">::</span><span class="n" id="mwCHU">println</span><span class="p" id="mwCHY">(</span><span class="s" id="mwCHc">"Unknown error"</span><span class="p" id="mwCHg">);</span> <span class="linenos" data-line="7" id="mwCHk"></span><span class="p" id="mwCHo">}</span> <span class="linenos" data-line="8" id="mwCHs"></span><span class="n" id="mwCHw">doNextThing</span><span class="p" id="mwCH0">();</span>

Many languages use the C++ keywords (throw, try and catch), but some languages use other keywords. For example, Ada uses exception to introduce an exception handler and when instead of catch. AppleScript incorporates placeholders in the syntax to extract information about the exception as shown in the following AppleScript code.

<span id="mwCIg"></span><span class="k" id="mwCIk">try</span> <span class="k" id="mwCIo">set</span> <span class="nv" id="mwCIs">myNumber</span> <span class="k" id="mwCIw">to</span> <span class="nv" id="mwCI0">myNumber</span> <span class="o" id="mwCI4">/</span> <span class="mi" id="mwCI8">0</span> <span class="k" id="mwCJA">on</span> <span class="k" id="mwCJE">error</span> <span class="nv" id="mwCJI">e</span> <span class="nv" id="mwCJM">number</span> <span class="nv" id="mwCJQ">n</span> <span class="k" id="mwCJU">from</span> <span class="nv" id="mwCJY">f</span> <span class="k" id="mwCJc">to</span> <span class="nv" id="mwCJg">t</span> <span class="nv" id="mwCJk">partial</span> <span class="no" id="mwCJo">result</span> <span class="nv" id="mwCJs">pr</span> <span class="k" id="mwCJw">if</span> <span class="p" id="mwCJ0">(</span> <span class="nv" id="mwCJ4">e</span> <span class="o" id="mwCJ8">=</span> <span class="s2" id="mwCKA">"Can't divide by zero"</span> <span class="p" id="mwCKE">)</span> <span class="k" id="mwCKI">then</span> <span class="nb" id="mwCKM">display dialog</span> <span class="s2" id="mwCKQ">"You must not do that"</span> <span class="k" id="mwCKU">end</span> <span class="k" id="mwCKY">try</span>

In many languages (including Object Pascal, D, Java, C#, and Python) a finally clause at the end of a try statement is executed at the end of the try statement, whether an exception propagates from the rest of the try or not. The following C# code ensures that the stream stream is closed.

<span id="mwCK4"></span><span class="n" id="mwCK8">FileStream</span><span class="w" id="mwCLA"> </span><span class="n" id="mwCLE">stream</span><span class="w" id="mwCLI"> </span><span class="o" id="mwCLM">=</span><span class="w" id="mwCLQ"> </span><span class="k" id="mwCLU">null</span><span class="p" id="mwCLY">;</span> <span class="k" id="mwCLc">try</span> <span class="p" id="mwCLg">{</span> <span class="w" id="mwCLk"> </span><span class="n" id="mwCLo">stream</span><span class="w" id="mwCLs"> </span><span class="o" id="mwCLw">=</span><span class="w" id="mwCL0"> </span><span class="k" id="mwCL4">new</span><span class="w" id="mwCL8"> </span><span class="n" id="mwCMA">FileStream</span><span class="p" id="mwCME">(</span><span class="s" id="mwCMI">"logfile.txt"</span><span class="p" id="mwCMM">,</span><span class="w" id="mwCMQ"> </span><span class="n" id="mwCMU">FileMode</span><span class="p" id="mwCMY">.</span><span class="n" id="mwCMc">Create</span><span class="p" id="mwCMg">);</span> <span class="w" id="mwCMk"> </span><span class="k" id="mwCMo">return</span><span class="w" id="mwCMs"> </span><span class="nf" id="mwCMw">ProcessStuff</span><span class="p" id="mwCM0">(</span><span class="n" id="mwCM4">stream</span><span class="p" id="mwCM8">);</span> <span class="p" id="mwCNA">}</span><span class="w" id="mwCNE"> </span> <span class="k" id="mwCNI">finally</span> <span class="p" id="mwCNM">{</span> <span class="w" id="mwCNQ"> </span><span class="k" id="mwCNU">if</span><span class="w" id="mwCNY"> </span><span class="p" id="mwCNc">(</span><span class="n" id="mwCNg">stream</span><span class="w" id="mwCNk"> </span><span class="o" id="mwCNo">!=</span><span class="w" id="mwCNs"> </span><span class="k" id="mwCNw">null</span><span class="p" id="mwCN0">)</span> <span class="w" id="mwCN4"> </span><span class="p" id="mwCN8">{</span> <span class="w" id="mwCOA"> </span><span class="n" id="mwCOE">stream</span><span class="p" id="mwCOI">.</span><span class="n" id="mwCOM">Close</span><span class="p" id="mwCOQ">();</span> <span class="w" id="mwCOU"> </span><span class="p" id="mwCOY">}</span> <span class="p" id="mwCOc">}</span>

Since this pattern is common, C# provides the using statement to ensure cleanup. In the following code, even if ProcessStuff() propagates an exception, the stream object is released. Python's with statement and Ruby's block argument to File.open are used to similar effect.

<span id="mwCO8"></span><span class="k" id="mwCPA">using</span><span class="w" id="mwCPE"> </span><span class="p" id="mwCPI">(</span><span class="n" id="mwCPM">FileStream</span><span class="w" id="mwCPQ"> </span><span class="n" id="mwCPU">stream</span><span class="w" id="mwCPY"> </span><span class="o" id="mwCPc">=</span><span class="w" id="mwCPg"> </span><span class="k" id="mwCPk">new</span><span class="p" id="mwCPo">(</span><span class="s" id="mwCPs">"logfile.txt"</span><span class="p" id="mwCPw">,</span><span class="w" id="mwCP0"> </span><span class="n" id="mwCP4">FileMode</span><span class="p" id="mwCP8">.</span><span class="n" id="mwCQA">Create</span><span class="p" id="mwCQE">))</span> <span class="p" id="mwCQI">{</span> <span class="w" id="mwCQM"> </span><span class="k" id="mwCQQ">return</span><span class="w" id="mwCQU"> </span><span class="nf" id="mwCQY">ProcessStuff</span><span class="p" id="mwCQc">(</span><span class="n" id="mwCQg">stream</span><span class="p" id="mwCQk">);</span> <span class="p" id="mwCQo">}</span>

Continuation

In computer science, a continuation is an abstract representation of the control state of a computer program. A continuation implements (reifies) the program control state, i.e. the continuation is a data structure that represents the computational process at a given point in the process's execution; the created data structure can be accessed by the programming language, instead of being hidden in the runtime environment. Continuations are useful for encoding other control mechanisms in programming languages such as exceptions, generators, coroutines, and so on.

The "current continuation" or "continuation of the computation step" is the continuation that, from the perspective of running code, would be derived from the current point in a program's execution. The term continuations can also be used to refer to first-class continuations, which are constructs that give a programming language the ability to save the execution state at any point and return to that point at a later point in the program, possibly multiple times.

Generator

In computer science, a generator is a routine that can be used to control the iteration behaviour of a loop. All generators are also iterators. A generator is very similar to a function that returns an array, in that a generator has parameters, can be called, and generates a sequence of values. However, instead of building an array containing all the values and returning them all at once, a generator yields the values one at a time, which requires less memory and allows the caller to get started processing the first few values immediately. In short, a generator looks like a function but behaves like an iterator.

Generators can be implemented in terms of more expressive control flow constructs, such as coroutines or first-class continuations. Generators, also known as semicoroutines, are a special case of (and weaker than) coroutines, in that they always yield control back to the caller (when passing a value back), rather than specifying a coroutine to jump to; see comparison of coroutines with generators.

Coroutine

Coroutines are computer program components that can be suspended and resumed — generalizing subroutines — for cooperative multitasking. Coroutines are well-suited for implementing familiar program components such as cooperative tasks, exceptions, event loops, iterators, infinite lists and pipes.

They have been described as "functions whose execution you can pause".

Melvin Conway coined the term coroutine in 1958 when he applied it to the construction of an assembly program. The first published explanation of the coroutine appeared later, in 1963.

COMEFROM

In computer programming, COMEFROM is a control flow statement that causes control flow to jump to the statement after it when control reaches the point specified by the COMEFROM argument. The statement is intended to be the opposite of goto and is considered to be more a joke than serious computer science. Often the specified jump point is identified as a label. For example, COMEFROM x specifies that when control reaches the label x, then control continues at the statement after the COMEFROM.

A major difference with goto is that goto depends on the local structure of the code, while COMEFROM depends on the global structure. A goto statement transfers control when control reaches the statement, but COMEFROM requires the processor (i.e. interpreter) to scan for COMEFROM statements so that when control reaches any of the specified points, the processor can make the jump. The resulting logic tends to be difficult to understand since there is no indication near a jump point that control will in fact jump. One must study the entire program to see if any COMEFROM statements reference that point.

The semantics of a COMEFROM statement varies by programming language. In some languages, the jump occurs before the statement at the specified point is executed and in others the jump occurs after. Depending on the language, multiple COMEFROM statements that reference the same point may be invalid, non-deterministic, executed in some order, or induce parallel or otherwise concurrent processing as seen in Threaded Intercal.

COMEFROM was initially seen in lists of joke assembly language instructions (as 'CMFRM'). It was elaborated upon in a Datamation article by R. Lawrence Clark in 1973, written in response to Edsger Dijkstra's letter Go To Statement Considered Harmful. COMEFROM was eventually implemented in the C-INTERCAL variant of the esoteric programming language INTERCAL along with the even more obscure 'computed COMEFROM'. There were also Fortran proposals for 'assigned COME FROM' and a 'DONT' statement (to complement the existing 'DO' loop).

Event-based early exit from nested loop

Zahn's construct was proposed in 1974, and discussed in Knuth (1974). A modified version is presented here.

<b id="mwCTw">exitwhen</b> EventA <b id="mwCT0">or</b> EventB <b id="mwCT4">or</b> EventC; xxx <b id="mwCT8">exits</b> EventA: actionA EventB: actionB EventC: actionC <b id="mwCUA">endexit</b>;

exitwhen is used to specify the events which may occur within xxx, their occurrence is indicated by using the name of the event as a statement. When some event does occur, the relevant action is carried out, and then control passes just after endexit. This construction provides a very clear separation between determining that some situation applies, and the action to be taken for that situation.

exitwhen is conceptually similar to exception handling, and exceptions or similar constructs are used for this purpose in many languages.

The following simple example involves searching a two-dimensional table for a particular item.

<b id="mwCUs">exitwhen</b> found <b id="mwCUw">or</b> missing; <b id="mwCU0">for</b> I := 1 <b id="mwCU4">to</b> N <b id="mwCU8">do</b> <b id="mwCVA">for</b> J := 1 <b id="mwCVE">to</b> M <b id="mwCVI">do</b> <b id="mwCVM">if</b> table[I,J] = target <b id="mwCVQ">then</b> found; missing; <b id="mwCVU">exits</b> found: print ("item is in table"); missing: print ("item is not in table"); <b id="mwCVY">endexit</b>;

Structure

Sequences

Labels

Blocks

Control

Functions

Branches

Jump

Conditional branch

Multiway branch

Loops

Numeric

Condition-controlled

Enumeration

Infinite

Loop-and-a-half problem

Unstructured

Early exit

Multi-level breaks

Middle test

Loop variants and invariants

Loop sublanguage

Loop system cross-reference table

Non-local

Condition handling

Exception handling

Continuation

Generator

Coroutine

COMEFROM

Event-based early exit from nested loop

More in Computing and communication