Rosetta Code

Loop structures: Difference between revisions

Page Discussion

Loop structures (view source)

Revision as of 13:31, 3 October 2023

13,571 bytes added ,  8 months ago
no edit summary
(→‎Pascal: All covered)
imported>Maleza
No edit summary
 
(75 intermediate revisions by 34 users not shown)
Line 1:
{{DeprecatedTask}}
[[Category:Maintenance]]In this former task, we document loop structures offered by different languages.
 
;What are loops?:
 
Loops are control structures that allow sections of code to be executed repeatedly according to the controlling conditions of the loop.
 
There are two types of loops:
 
;Repetition:
Additionally, there is the overly simple repetitive loop: [[repeat|repetition]]. The simplistic construct executes a block of code, or a procedure, a given number of times, without explicitly exposing any state change to the looped procedure.
 
;Iterative loops:
 
An [[:Category:Iteration|iterative loop]] repeatedly executes a set of instructions as the iterator steps through a series of values. Types of iterative loops include [[for loop]]s and [[foreach]] loops. An iterative loop is a repetition but with a variable dependent on the current iteration. This allows the looped procedure to vary slightly between iterations. For example, the same operation can be carried out on each iteration, but each time on a different object.
 
;Conditional loops:
A [[conditional loop]] tests for a condition around the loop, and repeatedly executes a block of [[instruction]]s whilst the [[condition]] is true. Types of [[conditional loop]]s include [[while loop]]s and [[do-while loop]]s.
 
'''Examples here should be migrated to an appropriate [[:Category:Iteration|Iteration]] page and removed from here. If a page does not exist demonstrating a particular loop structure, discuss it [[:Category talk:Iteration|here]].'''
<br><br>
=={{header|68000 Assembly}}==
'''NOT COVERED IN LOOP PAGES'''
 
The 68000 uses <code>DBxx Dn, label</code> for loop counting. "Dn" refers to a chosen data register. The "xx" is replaced with the condition code of your choice (<code>DBRA</code> stands for Decrement, Branch Always which is most commonly used). Execution will jump to the labeled line of code unless Dn's lower two bytes equal #$FFFF or the specified condition code is true, whichever occurs first. Keep in mind that the condition code has nothing to do with the value stored in Dn; rather, it represents the outcome of the operation just before the branch. This is similar to a "repeat until" construct in some other languages.
 
The below code snippet represents a loop that continues until a value greater than 3500 is read. However, it will also end after the 2000th iteration automatically, regardless of whether the condition is ever met.
 
<syntaxhighlight lang="68000devpac">
MOVE.W #1999,D1 ;DBxx loop counters need to be pre-decremented to work properly, since they terminate at $FFFF rather than 0
LOOP:
MOVE.W (A0)+,D0
CMP.W #3501,D0 ;COMPARE TO #3501
DBCC D1,LOOP ;DECREMENT, BRANCH UNTIL CARRY CLEAR OR D1 = #$FFFF
</syntaxhighlight>
 
=={{header|AmbientTalk}}==
 
===doTimes===
<syntaxhighlight lang="ambienttalk">
// print 1 2 3 ... 20
20.doTimes { |i| system.print(" "+i); }
 
</syntaxhighlight>
 
===each===
 
Iterate over a collection:
<syntaxhighlight lang="ambienttalk">
[ "foo", "bar", "baz" ].each: { |e|
system.print(" "+e);
}
// prints: foo bar baz
 
</syntaxhighlight>
 
==[[AppleScript]]==
'''NOT COVERED IN LOOP PAGES'''
===repeat-until===
<syntaxhighlight lang="applescript>
set i to 5
set i to 5
repeat until i is less than 0
repeat setuntil i tois iless -than 10
set i to i - 1
end repeat
end repeat
 
repeat
--endless loop
end repeat
</syntaxhighlight>
 
===repeat-with===
<syntaxhighlight lang="applescript>
repeat with i from 1 to 20
repeat with i from 1 to 20
--do something
end--do repeatsomething
end repeat
 
set array to {1,2,3,4,5}
repeat with i in array
display dialog i
end repeat
</syntaxhighlight>
 
==[[AssemblyScript]]==
'''NOT COVERING ALL POSSIBLE LOOP OPTIONS'''
 
===while===
<syntaxhighlight lang="javascript">
let done = false
while (!done) {
done = true
}
</syntaxhighlight>
 
===do while===
<syntaxhighlight lang="javascript">
let done = false
do {
done = true
} while (!done)
</syntaxhighlight>
 
===for===
<syntaxhighlight lang="javascript">
for (let i = 0; i < 10000; i++) {
i += i
}
</syntaxhighlight>
 
==[[Brainf***]]==
Line 40 ⟶ 122:
A compile-time for loop can be generated with template metaprogramming. Example:
 
<syntaxhighlight lang="cpp">
// the loop
// the loop
template<int start, int finish, template<int n, typename T> class X> struct loop
template<int start, int finish, template<int n, typename T> class X> struct loop
{
{
typedef typename X<start, typename loop<start+1, finish, X>::type>::type type;
typedef typename X<start, typename loop<start+1, finish, X>::type>::type type;
};
};
// the termination of the loop
template<int finish, template<int n, typename T> class X> struct loop<finish, finish, X>
{
typedef typename X<finish, void>::type type;
};
 
// example usage: This implements just a very complicated way of building a multi-dimensional array
// the loop body
template<int n, typename T> struct build_array
{
typedef T type[n];
};
template<int n> struct build_array<n, void>
{
typedef double type;
};
// the loop execution: This is equivalent to
// typedef double array_type[2][3][4][5];
typedef loop<2,6,build_array>::type array_type;
</syntaxhighlight>
 
==[[Clojure]]==
'''NOT COVERED IN LOOP PAGES'''
===loop===
<syntaxhighlight lang="clojure">
;; loop/recur is the most general looping construct
;; loop/recur is the most general looping construct
(loop [lst [1 3 5 7]
ret []]
Line 79 ⟶ 164:
ret))
==> [1 9 25 49]
</syntaxhighlight>
 
=={{header|Crack}}==
===For===
<syntaxhighlight lang="crack">
for( i=0; i<9; i++)
cout ` $i\n`;
</syntaxhighlight>
 
=={{header|Curto}}==
===HACER-BUCLE===
<syntaxhighlight lang="curto">
\ limite inicio HACER sentencias iteradas BUCLE
\ limite inicio HACER sentencias iteradas incremento +BUCLE
\ SALIR \ abandona bucle HACER
\ DBUCLE SALIR \ limpia contadores de la pila de retorno antes de abandonar la palabra actual
</syntaxhighlight>
 
ejemplo: Dos iteraciones típicas
<syntaxhighlight lang="curto">
10 0 hacer i . bucle \ Imprime números de 0 a 9
10 0 hacer i . 2 +bucle \ Imprime números pares de 0 a 8
</syntaxhighlight>
===EMPEZAR-HASTA===
<syntaxhighlight lang="curto">
\ EMPEZAR sentencias iteradas condicional HASTA
</syntaxhighlight>
 
ejemplo: Cuenta hacia abajo desde un número dado a cero
<syntaxhighlight lang="curto">
: cuenta-abajo ( n -- ) empezar dup rc . 1- dup 0< hasta soltar ;
</syntaxhighlight>
 
===EMPEZAR-DENUEVO===
<syntaxhighlight lang="curto">
\ EMPEZAR sentencias iteradas DENUEVO
</syntaxhighlight>
 
ejemplo: repetir entrada de usuario (solo funciona en cli, no en la interface gráfica)
<syntaxhighlight lang="curto">
: porsiempre ( -- ) empezar tecla emitir denuevo ;
</syntaxhighlight>
 
===EMPEZAR-MIENTRAS-REPETIR===
<syntaxhighlight lang="curto">
\ EMPEZAR sentencias iteradas incondicionales condicional MIENTRAS sentencias iteradas condicionales repetir
</syntaxhighlight>
ejemplo: cuenta hacia abajo desde un número dado a uno
<syntaxhighlight>
: cuenta-abajo ( n -- ) empezar dup mientras rc dup . 1- repetir soltar ;
</syntaxhighlight>
 
=={{header|Dafny}}==
<syntaxhighlight lang="dafny">
var i: int := 0;
while i < n
invariant 0 <= i <= n
decreases n - i
{
i := i + 1;
}
assert i == n;
</syntaxhighlight>
 
=={{header|Dao}}==
===For===
<syntaxhighlight lang="java">
for( i=0; i<9; ++i) io.writeln( i );
for( i = 0 : 8 ) io.writeln( i );</syntaxhighlight>
 
===For In===
<syntaxhighlight lang="java">
items = { 1, 2, 3 }
for( item in items ) io.writeln( item )
</syntaxhighlight>
 
===While===
<syntaxhighlight lang="java">
i = 0
while( i < 5 ) { i += 1 }
</syntaxhighlight>
 
===Do While===
<syntaxhighlight lang="java">
i = 0
do { i += 1 } while( i < 9 )
</syntaxhighlight>
 
=={{header|Déjà Vu}}==
===For===
Déjà Vu has a for-loop protocol, so you can write your own iterators. The most commonly used iterators are <code>in</code> and <code>range</code>. The first iterates over a list, the second takes two arguments and goes from the first to the second, like a classic for-loop.
<syntaxhighlight lang="dejavu">
for i range 1 3:
!print i # prints 1, 2 and 3
</syntaxhighlight>
===While===
<syntaxhighlight lang="dejavu">
while true:
!print "This is the song that never ends..."
</syntaxhighlight>
===Repeat===
<syntaxhighlight lang="dejavu">
repeat 3:
!print "This sentence is printed three times."
</syntaxhighlight>
 
==[[Factor]]==
'''NOT COVERED IN LOOP PAGES'''
===Looping===
Most looping is done with recursion. Tail recursion is properly optimized.
<syntaxhighlight lang="factor">
: forever ( quot -- ) dup slip forever ; inline
: forever ( quot -- ) dup slip forever ; inline
[ "A hungry raptor stalks you..." print flush 2000 random sleep ] forever
[ "A hungry raptor stalks you..." print flush 2000 random sleep ] forever
</syntaxhighlight>
 
===Iteration===
<syntaxhighlight lang="factor">
Most indices are implicit or not present at all.
3 [ "pint" drink ] times
{ "high" "level" "language" } [ print ] each
high
level
language
10 [ sq ] map
{ 0 1 4 9 16 25 36 49 64 81 }
{ 1 2 3 } { 4 5 6 } [ * ] 2map .
{ 4 10 18 }
10 [ even? ] subset .
V{ 0 2 4 6 8 }
0 10 3 <range> >array .
{ 0 3 6 9 }
10 1 -2 <range> >array .
{ 10 8 6 4 2 }
2222 [ dup 0 > ] [ 2/ dup ] [ ] unfold nip .
{ 1111 555 277 138 69 34 17 8 4 2 1 0 }a
</syntaxhighlight>
 
Iterating with an index:
<syntaxhighlight lang="factor">
: indexed-alphabet. ( -- )
: indexed-alphabet. ( -- )
"abcdefghijklmnopqrstuvwxyz"
"abcdefghijklmnopqrstuvwxyz"
[ [ 1string ] [ number>string ] bi* ": " glue print ] each-index ;
[ [ 1string ] [ number>string ] bi* ": " glue print ] each-index ;
</syntaxhighlight>
 
==[[Forth]]==
===DO-LOOP===
<syntaxhighlight lang="forth">
( limit start ) DO ( iterated statements ) LOOP
( limit start ) DO ( iterated statements ) ( increment ) +LOOP
( limit start ) DO ( iterated statements ) ( increment ) +LOOP
LEAVE \ exits a DO loop
LEAVE \ exits a DO loop
UNLOOP EXIT \ cleans up loop counters from return stack before returning from the current word
UNLOOP EXIT \ cleans up loop counters from return stack before returning from the current word
</syntaxhighlight>
 
example: Two standard iterations
<syntaxhighlight lang="forth">
10 0 DO I . LOOP \ Prints the numbers from 0 to 9
10 0 DO I . 2 +LOOP \ Prints the even numbers from 0 to 89
10 0 DO I . 2 +LOOP \ Prints the even numbers from 0 to 8
</syntaxhighlight>
 
===BEGIN-UNTIL===
<syntaxhighlight lang="forth">
BEGIN ( iterated statements ) ( conditional ) UNTIL
BEGIN ( iterated statements ) ( conditional ) UNTIL
</syntaxhighlight>
 
example: Counts down from a given number to zero
<syntaxhighlight lang="forth">
: COUNTDOWN ( n -- ) BEGIN DUP CR . 1- DUP 0< UNTIL DROP ;
: COUNTDOWN ( n -- ) BEGIN DUP CR . 1- DUP 0< UNTIL DROP ;
</syntaxhighlight>
 
===BEGIN-AGAIN===
<syntaxhighlight lang="forth">
BEGIN ( iterated statements ) AGAIN
BEGIN ( iterated statements ) AGAIN
</syntaxhighlight>
 
example: echo user's input
<syntaxhighlight lang="forth">
: FOREVER ( -- ) BEGIN KEY EMIT AGAIN ;
: FOREVER ( -- ) BEGIN KEY EMIT AGAIN ;
</syntaxhighlight>
 
===BEGIN-WHILE-REPEAT===
<syntaxhighlight lang="forth">
BEGIN ( conditional ) WHILE ( iterated statements ) REPEAT
BEGIN ( unconditional iterated statements ) ( conditional ) WHILE ( conditional iterated statements ) REPEAT
example: counts down from a given number to one
: COUNTDOWN ( n -- ) BEGIN DUP WHILE CR DUP . 1- REPEAT DROP ;
</syntaxhighlight>
Additional WHILE clauses may be added to a loop, but each extra WHILE requires a matching THEN after the REPEAT.
 
Line 139 ⟶ 355:
 
A good example of a useful combination is this complex loop:
<syntaxhighlight lang="forth">
BEGIN
BEGIN
( condition 1 )
( condition 1 )
WHILE
WHILE
( condition 2 )
( condition 2 )
UNTIL
UNTIL
( condition 2 succeeded )
( condition 2 succeeded )
ELSE
ELSE
( condition 1 failed )
( condition 1 failed )
THEN
THEN
</syntaxhighlight>
 
An example of using this idiom in practice might be this pseudo-Forth
<syntaxhighlight lang="forth">
BEGIN
BEGIN
read-next-record
read-next-record
WHILE
WHILE
found-record
found-record
UNTIL
UNTIL
process-record
process-record
ELSE
ELSE
error" Ran out of records looking for the right one!"
error" Ran out of records looking for the right one!"
THEN
THEN
</syntaxhighlight>
 
=={{header|FreeBASIC}}==
<h3>[[While_loop|While..Wend]]</h3>
Executes a block of statements while a condition is met.<br>
<syntaxhighlight lang="vbnet">While [ condition ]
[ statement block ]
Wend</syntaxhighlight>
 
<h3>[[For_loop|For..Next]]</h3>
Executes a block of statements while an iterator is less than or greater than an expression.<br>
<syntaxhighlight lang="vbnet">For iterator [ As datatype ] = startvalue To endvalue [ Step stepvalue ]
[ statement block ]
Next [ iterator ]
</syntaxhighlight>
 
<h3>[[While_loop|Do..Loop]]</h3>
Executes a block of statements while or until a condition is met.
<syntaxhighlight lang="vbnet">Do [ { Until | While } condition ]
[ statement block ]
Loop</syntaxhighlight>
or
<syntaxhighlight lang="vbnet">Do
[ statement block ]
Loop [ { Until | While } condition ]
</syntaxhighlight>
 
<h3>Intra-loop control</h3>
Continue While, Continue For and Continue Do
Prematurely re-enters a loop.<br>
<syntaxhighlight lang="vbnet">Continue {Do | For | While}</syntaxhighlight>
Exit While, Exit For and Exit Do
Prematurely breaks out of a loop.
<syntaxhighlight lang="vbnet">Exit {Do | For | While | Select }</syntaxhighlight>
<syntaxhighlight lang="vbnet">Exit {Sub | Function | Operator | Constructor | Destructor | Property }</syntaxhighlight>
 
<syntaxhighlight lang="vbnet">Exit {Do [, Do [ , ...] ] |
For [, For [ , ...] ] |
While [, While, [...] ] |
Select [, Select [ , ...] ] }</syntaxhighlight>
 
 
=={{header|Frink}}==
In all of the loops below, the curly braces can be omitted if the body is a single statement.
 
===For Loop===
A <CODE>for</CODE> loop is really a <CODE>foreach</CODE> loop that can work with range operators or iterate through various data structures. The <CODE>to</CODE> operator creates an enumerating expression that lazily steps through its range.
<syntaxhighlight lang="frink">
for i = 1 to 1000000
{
println[i]
}
 
</syntaxhighlight>
 
The <CODE>to</CODE> operator can be combined with a <CODE>step</CODE> statement:
<syntaxhighlight lang="frink">
for i = 1 to 1000000 step 3
println[i]
</syntaxhighlight>
 
As a <CODE>foreach</CODE> statement. The <CODE>for</CODE> construct can iterate over the elements of an array, set, dictionary, or enumerating expression.
<syntaxhighlight lang="frink">
for i = [2,3,7,9]
println[i]
</syntaxhighlight>
 
===Do...While Loop===
<syntaxhighlight lang="frink">
i=0
do
{
i = i+1
} while i<1000
</syntaxhighlight>
 
==[[Groovy]]==
Line 312 ⟶ 605:
The <tt>break</tt> statement will immediately terminate the current innermost <tt>for</tt>, <tt>while</tt>, <tt>repeat</tt>, <tt>if</tt>, <tt>case</tt> or <tt>switch</tt> without having to resort to a <tt>goto</tt>.
 
==[[Jinja]]==
 
===for===
<lang jinja>
print(Template("""{% for lang in ["Jinja", "Python", "Swift", "Nim"] %}
{{ loop.index }}) {{ lang }}
{%- endfor %}""").render())
</lang>
 
==[[Kabap]]==
 
There is no native loop command in Kabap, but labels, variables, jumps and conditional execution are supported which is enough to create a basic loop structure. Support for native loops is being prepared for the next major release.
 
===Basic loop===
<lang Kabap>
$i = 0;
:start;
// Your loop code here
$i = $i + 1;
if $i < 20;
goto start;
</lang>
 
==[[Logo]]==
Line 393 ⟶ 708:
Array.iteri</lang>
 
=={{header|Prolog}}==
==[[Pop11]]==
 
There are three primitive methods of looping in Prolog: recursion, fail-driven loops, and repeat-driven loops.
=== while ===
Pop11 offers multiple looping constructs. Basic one is while loop:
 
<lang Prolog>% recursion as loop
5 -> n;
print_each_element([]).
while n > 0 do
print_each_element([E|T]) :- writeln(E), print_each_element(T).
printf(n, '%p\n');
 
n - 1 -> n;
% fail-driven loop
endwhile;
fact(foo).
fact(bar).
fact(baz).
print_each_fact :-
( fact(X), writeln(X), fail
; true ).
 
% equivalently
%print_each_fact :- fact(X), writeln(X), fail.
%print_each_fact.
 
% repeat-driven loop
print_each_fact_again :-
repeat,
fact(X),
writeln(X),
X = baz,
!.
 
go :-
print_each_element([foo, bar, baz]),
print_each_fact,
print_each_fact_again.</lang>
 
Of the three recursion is the favoured approach as it requires no non-logical predicates and is thus easy to read in its declarative form.
 
The fail-driven loop form is a(n ab)use of the built-in backtracking mechanism of Prolog's reasoning engine. In the specific example provided, fact(X) will first succeed, binding "foo" to X. It will then write "foo" to the output (as a side effect of the writeln/1 predicate). It then hits the call to fail/0 which is a non-logical predicate which always fails and thus always triggers backtracking. On backtracking, the runtime will try fact(X) again and will find that it is true when X is bound to "bar". This will then print and backtrack again. A third time binds to and prints "baz". A fourth time will fail because there is no more solution to the goal "fact(X)". This triggers a further backtrack and a try on the second branch of the disjunction. That second branch invokes the true/0 predicate which always succeeds. This exits the query with an overall success.
 
The repeat-driven loop uses similar (ab)use of the backtracking mechanism. Instead of employing a predicate that always fails, however, it employs one that will always succeed: repeat/0. Thus, in this sample, fact(X) works as before, as does writeln(X), but the attempt to unify X with "baz" will fail for the first two attempts, causing the system to backtrack until it hits repeat. Since repeat always succeeds it drives the engine forward again, testing each fact in succession. Once X is unified with "baz" (which is to say once X contains the value "baz") the predicate carries on. The cut operator !/0, guarantees that the predicate won't be re-entered later.
 
As with any language permitting higher-order invocations, using the looping primitives directly as above is often not a desirable thing. Instead higher-order features would be used.
 
<lang Prolog>% using maplist/2 to replace explicit recursion on a list
print_each_element(L) :- maplist(writeln, L).
 
% using forall/2 to replace an explicit fail-driven loop
fact(foo).
fact(bar).
fact(baz).
print_each_fact() :- forall(fact(X), writeln(X)).</lang>
 
There are a myriad of such predicates available in a useful Prolog implementation (SWI-Prolog provides, non-exhaustively: include/3, exclude/3, partition/4-5, maplist/2-5, foldl/4-7, scanl/4-6, aggregate/3-4, aggregate_all/3-4, forall/2, findall/3-4, findnsols/4-5, bagof/3, setof/3, … just as the more fundamental wrappings.) If the provided predicates do not permit the kinds of functionality desired for common patterns, it is trivial to make a new one. As an illustration, this is the source code for forall/2:
 
<lang Prolog>:- meta_predicate forall(0,0).
forall(A, B) :- \+ (call(A), \+ call(B)).</lang>
 
=={{header|Pop11}}==
 
=== until ===
Line 411 ⟶ 772:
is equivalent to:
 
while motnot(condition) do /* Action */ endwhile;
 
=== for ===
Line 477 ⟶ 838:
 
===for===
 
Typically ''for'' is used to iterate over items in an iterable. Most Python built-in objects support iteration: lists, tuples, strings (including unicode string objects), dictionaries (by keys), sets, ranges (including the results from calls to the ''xrange()'' built-in functions) and files (line by line). Any object can support iteration by adding special methods.
 
<lang python>
for x in ["foo", "bar", "baz"]:
print x
</lang>
 
Frequently one wants to both iterate over a list and increment a counter:
 
Line 493 ⟶ 846:
</lang>
 
Iterating over more than one list is achieved by ''zip'':
 
<lang python>
for x, y, z in zip(lst1, lst2, lst3):
print x, y, z
</lang>
 
Iterating over more than one list + incrementing a counter:
Line 506 ⟶ 853:
print counter, x, y, z
</lang>
 
 
The built-in ''range()'' and ''xrange()'' functions are commonly used to provide indexes over which to iterate. ''range()'' returns a list while ''xrange()'' returns a generator object without building the list in memory:
 
<lang python>
import sys
for i in xrange(sys.maxint):
print i,
</lang>
 
This would usually result in a MemoryError if we attempted to use the ''range()'' because it would try to create a list in memory consisting of all the integers from 0 up to the system's maximum. However, with ''xrange()'' this will run without error (for a very long time or until it's interrupted).
 
Optional ''else'' suite is executed unless ''break'' was called during iteration:
 
<lang python>
for i in numbers:
if item < 0:
break
else:
print 'all numbers are positive'
</lang>
 
Because of the pervasive support for iteration and generators in Python classes and libraries the ''for'' loop structure is far more commonly used than ''while.''
 
=== list comprehension expressions ===
Line 600 ⟶ 924:
repeat <come_condition> until
<some_process>
 
=={{header|REXX}}==
===repeat===
This example shows how to perform a loop for one million times.
<lang rexx>n= 1000000
x= 1
y= 12
z= 0
do n
z=someFunction(z, x, y)
end /*n*/</lang> <br><br>
 
==[[Seed7]]==
Line 630 ⟶ 965:
end for;
 
==[[Smalltalk]]SETL4==
<lang setl4>
define('prime(n)set.this') :(prime.end)
 
* Tests if _n_ is a prime integer.
===timesRepeat===
 
prime
10 timesRepeat: [ expression ].
 
n = integer(n) +n
===iterating over a collection===
eq(n,2) :s(return)
even(n) :s(freturn)
exists(new('iter 3 ' square.root(n) ' 2'), 'multiple(n,this)') :s(freturn)f(return)
 
prime.end
( collection ) do: [ expression ].
 
define('primes(n)set.this') :(primes.end)
( collection ) collect: [:element | element sendMessageToElement].
 
* Returns set of primes less than _n_.
#(1 2 3 4) inject: 5 into: [:sum :number | sum + number]
 
primes
===whileTrue/whileFalse===
 
primes = filter(new('iter 2 ' (n - 1)),'prime(this)') :(return)
x := 0.
[ x <primes 100= ]new('set')
iter = new('iter whileTrue:2 [ x :=' x(n +- 10.].1))
loop(iter)
 
primes.loop
[ x = 0 ]
whileFalse: [ x := x - 20.].
this = next(iter) :f(return)
prime(this) add(primes,this) :(primes.loop)
 
primes.end
===simple looping===
</lang>
 
==[[SIMPOL]]==
In [[SIMPOL]] there is only one looping construct. It is very flexible and can be used as a while, a repeat, or a combination of both.
 
===while===
 
<lang simpol>while [condition]
// Actions taken here
end while [condition]</lang>
 
Either condition or both can be present. Not setting either condition will result in an endless loop. The first condition will continue the loop if the result is true, the second will exit the loop if it is true. In [[SIMPOL]] code it is common to see both present, with the initial condition being the standard method of exiting the loop, and the end while condition used for exiting because of an error.
 
In this abbreviated example, the code will read records from a database table in a loop, placing each in record object in an array element, until it reaches the end of the table.
 
<lang simpol>function readrecs(sbme1table table)
sbme1record r
array recs
integer e, i
 
e = 0
i = 0
recs =@ array.new()
r =@ table.select(error=e)
while r !@= .nul
i = i + 1
recs[i] =@ r
r =@ r.select(error=e)
end while e != 0
end function recs</lang>
 
The final condition should best be read as: "end the while, if this is true".
 
Another typical use of the loop is the traversing of rings that are commonly used in [[SIMPOL]].
 
<lang simpol>function getfieldnames(sbme1table table)
sbme1field field
integer i
array fieldnames
 
fieldnames =@ array.new()
i = 0
field =@ table.firstfield
while field !@= .nul
i = i + 1
fieldnames[i] = field.name
field =@ field.next
end while field =@= table.firstfield
end function fieldnames</lang>
 
=={{header|Sing}}==
<lang Sing>fn loops() void
{
// while: the condition must be strictly of boolean type
var idx = 0;
while (idx < 10) {
++idx;
}
 
// for in an integer range, the last value is excluded
// it is local to the loop and must not be previously declared
for (it in 0 : 10) {
}
 
// reverse direction
for (it in 10 : 0) {
}
 
// configurable step. The loop stops when it >= the final value
for (it in 0 : 100 step 3) {
}
 
// with an auxiliary counter. The counter start always at 0 and increments by one at each iteration
for (counter, it in 3450 : 100 step -22) {
}
 
// value assumes in turn all the values from array
1 to: 5 do: [:number | Transcript show: 'Here is a number: ' number printString ; cr]
var array [*]i32 = {0, 10, 100, 1000};
for (value in array) {
}
 
// as before with auxiliary counter
(-50 to: 50 by: 4) do: [:number | Transcript show: number ; cr]
for (counter, value in array) {
}
}</lang>
 
==[[SNUSP]]==
Line 672 ⟶ 1,096:
# #
 
 
==[[Sparkling]]==
 
While loop (test-first loop):
 
<lang sparkling>var n = -1;
print("Enter 0 to exit");
 
while n != 0 {
n = toint(getline());
print(n);
}</lang>
 
For loop (alternate form of test-first loop, idiomatic approach to counting):
 
<lang sparkling>var i;
for i = 0; i < 10; i++ {
print(i);
}</lang>
 
Do-while loop (test-last loop):
 
<lang sparkling>print("enter empty line to exit");
 
var s;
do {
s = getline();
print(s);
} while s != "";</lang>
 
==[[Toka]]==
Line 691 ⟶ 1,144:
0 [ dup . 1 + dup 101 = ] whileFalse
 
==[[Visual Basic .NETTern]]==
=== Do/Loop ===
 
Tern has several distinct loop statements.
Sub InfiniteLoop()
Do
'code
Loop
End Sub
Sub LoopWithInnerCondition()
Do
'code
If Condition() Then Exit Do
'more code
Loop
End Sub
Sub PreConditionLoop1()
Do While Condition() 'loop continues while Condition is true
'code
Loop
End Sub
Sub PreConditionLoop2()
Do Until Condition() 'loop continues until Condition is true
'code
Loop
End Sub
Sub PostConditionLoop1()
Do
'code
Loop While Condition() 'loop continues while Condition is true
End Sub
Sub PostConditionLoop2()
Do
'code
Loop Until Condition() 'loop continues until Condition is true
End Sub
Sub ClassicLoop() 'not generally used
While Condition() 'loop continues while Condition is true
'code
End While
End Sub
 
===Infinite For Loop===
 
<lang tern>let v = 0;
* The type of the iterator variable (i in these example) is infered from the upper and lower bounds.
loop {
* If a Step clause isn't provided, it is assumed to be 1.
println(v++);
* Loops can be left early using Exit For
}</lang>
* The upper bound is inclusive.
 
===While Loop===
Sub ForLoop1()
For i = 1 To 10
'code
Next
End Sub
Sub ForLoop2() 'skips even numbers
For i = 1 To 10 Step 2
'code
Next
End Sub
Sub ForLoop3() 'iterates backwards
For i = 10 To 1 Step -1
'code
Next
End Sub
 
<lang tern>let v = 0;
=== For Each ===
while(v < 100) {
println(v++);
Sub ForEachLoop() 'iterates over a collection
}</lang>
For Each item In Source()
 
'code
===For Loop===
Next
 
End Sub
<lang tern>for(let v = 0; v < 100; v++) {
println(v);
Function ForEachLoop2() 'searching for a string, exiting early if found
}</lang>
Dim found As Boolean
 
For Each item In Source()
===For In Loop===
If item = "CAR" Then
 
found = True
<lang tern>for(v in 0 to 99) {
Exit For
println(v);
End If
}</lang>
Next
 
End Function
=={{header|Woma}}==
 
Woma is limited to for loops.
 
==Infinte Loop==
 
<lang woma>i<@>iter(int, 1)
print(i)
</lang>
 
===For Loop===
 
<lang woma>i<@>range(100)
print(i)
</lang>
Anonymous user
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/15560...348232"