Loops/Foreach: Difference between revisions

{{task|Iteration}}

 

=={{header|ACL2}}==

 

(if (endp xs)

nil

(prog2$ (cw "~x0~%" (first xs))

 

<pre>

SYM

NIL

</pre>

 

=={{header|Ada}}==

===arrays===

use Ada.Integer_Text_IO;

 

end loop;

 

 

Alternative solution (Ada 2012):

 

Put( Item );

 

===doubly linked lists===

{{works with|Ada 2005}}

use Ada.Integer_Text_IO, Ada.Containers;

 

DL_List.Iterate (Print_Node'Access);

===vectors===

{{works with|Ada 2005}}

use Ada.Integer_Text_IO, Ada.Containers;

 

V.Iterate (Print_Element'Access);

 

=={{header|Aikido}}==

Aikido's <code>foreach</code> loop allows iteration through multiple value types.

===strings===

foreach ch str { // you can also use an optional 'in'

println (ch) // one character at a time

===vectors===

foreach v vec { // you can also use an optional 'in'

println (v)

===maps===

foreach city cities {

println (city.first + " has population " + city.second)

===integers===

println (i) // prints values 0..99

}

foreach i a..b {

println (i) // prints values from a to b (20..10)

===Objects===

Aikido allows definition of a <code>foreach</code> operator for an object. In this example we define a single linked list and a foreach operator to iterate through it

class Element (public data) {

public var next = null

foreach n list {

println (n)

===Coroutines===

Aikido supports coroutines. The foreach operator may be used to iterate thorough the generated values.

function squares (start, end) {

for (var i = start ; i < end ; i++) {

foreach s squares (start, end) {

println (s)

===Files===

If you open a file you can iterate through all the lines

foreach line s {

print (line)

===Enumerations===

RED, GREEN, BLUE

}

foreach color Color {

println (color)

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

 

FOR index FROM LWB collection TO UPB collection DO

print((collection[index]," "))

Output:

<pre>

Mary Had +1 little lamb.

</pre>

 

=={{header|AmigaE}}==

DEF a_list : PTR TO LONG, a

a_list := [10, 12, 14]

-> if the "action" fits a single statement, we can do instead

ForAll({a}, a_list, `WriteF('\d\n', a))

 

=={{header|AutoHotkey}}==

Loop, Parse, string, `,

 

=={{header|AWK}}==

The <code>for (element_index in array)</code> can be used, but it does not give elements' indexes in the order inside the array (AWK indexes in array are indeed more like hashes).

BEGIN {

split("Mary had a little lamb", strs, " ")

print strs[el]

}

If elements must be returned in some order, keys must be generated in that order.

In the example above the array is filled through the split function,

So to iterate over the array's elements in the ''right'' order,

a normal loop can be used:

n = split("Mary had a little lamb", strs, " ")

for(i=1; i <= n; i++) {

print strs[i]

}

 

Note that in awk, foreach loops can only be performed against an associative container.

It is not possible to loop against an explicit list, so the following will not work:

 

BEGIN {

 

BASIC-256 does not have a FOR EACH type statement. Use a FOR loop to iterate through an array by index.

collection$ = { "The", "quick", "brown", "fox", "jumps", "over", "the", "lazy", "dog." }

 

PRINT collection$[i]+ " ";

NEXT i

Output:

<pre>The quick brown fox jumps over the lazy dog.</pre>

 

{{works with|BBC BASIC for Windows}}

collection$() = "The", "quick", "brown", "fox", "jumps", \

\ "over", "the", "lazy", "dog."

PRINT collection$(index%) " ";

NEXT

 

=={{header|bc}}==

There is no "for each"-loop in bc. For accessing each element of an array (the only collection-like type) one uses a straightforward for-loop.

a[1] = 234

a[3] = 95.6

for (i = 0; i < 4; i++) {

a[i]

 

=={{header|Bracmat}}==

Bracmat has a more or less traditional 'while' loop (<code>whl'<i>expression</i></code>) which was introduced rather late in the history of Bracmat. Before that, tail recursion was a way to repeat something.

But let us make a list first:

= Afrikaans

Ελληνικά

മലയാളം

ئۇيغۇرچە

The 'while' solution. Use an auxiliary variable <code>L</code> that gets its head chopped off until nothing is left:

The tail-recursive solution. When the auxiliary variable is reduced to nothing, the loop fails. By adding the <code>~</code> flag to the initial invocation, failure is turned into success. This solution benefits from tail recursion optimization.

& ( loop

= !L:%?language ?L

& !loop

)

: ? (%@?language&out$!language&~) ?

|

 

=={{header|C}}==

C does not really have a native 'container' type, nor does it have a 'for each' type statement. The following shows how to loop through an array and print each element.

...

 

for(ix=0; ix<LIST_SIZE; ix++) {

printf("%s\n", list[ix]);

 

The C language does, however, have a number of standard data structures that can be thought of as collections, and foreach can easily be made with a macro.<BR><BR>

 

C string as a collection of char

#include <stdio.h>

#include <stdlib.h>

return(0);

}

 

C int array as a collection of int (array size known at compile-time)

#include <stdio.h>

#include <stdlib.h>

return(0);

}

 

Most general: string or array as collection (collection size known at run-time)

#include <stdio.h>

#include <stdlib.h>

return(0);

}

 

=={{header|C++}}==

C++03 did not have a "for each" loop. The following is a generic loop which works with any standard container except for built-in arrays. The code snippet below assumes that the container type in question is typedef'd to <tt>container_type</tt> and the actual container object is named container.

{

std::cout << *i << "\n";

However the idiomatic way to output a container would be

There's also an algorithm named <tt>for_each</tt>. However, you need a function or function object to use it, e.g.

{

std::cout << v << "\n";

 

...

{{works with|C++11}}

{

std::cout << element << "\n";

Here <tt>container</tt> is the container variable, <tt>element</tt> is the loop variable (initialized with each container element in turn), and auto means that the compiler should determine the correct type of that variable automatically. If the type is expensive to copy, a const reference can be used instead:

{

std::cout << element << "\n";

Of course the container elements can also be changed by using a non-const reference (provided the container isn't itself constant):

{

element += 42;

 

 

 

=={{header|Chapel}}==

 

=={{header|Clojure}}==

 

=={{header|CMake}}==

 

foreach(file ${list})

message(${file})

 

=={{header|COBOL}}==

{{trans|C#}}

{{works with|Visual COBOL}}

...

set content of things to ("Apple", "Banana", "Coconut")

perform varying thing as string through things

display thing

 

=={{header|ColdFusion}}==

<Cfloop list="Fee, Fi, Foe, Fum" index="i">

<Cfoutput>#i#!</Cfoutput>

</Cfloop>

 

=={{header|Common Lisp}}==

or

 

 

 

=={{header|D}}==

This works if ''collection'' is a string/array/associative array, or if implements an appropriate ''opApply'' function, or if it has the basic Range methods.

 

void main() {

foreach (key, value; collection3)

writeln(key, " ", value);

{{out}}

<pre>A

 

=={{header|Dao}}==

 

=={{header|Delphi}}==

 

Supports arrays (single, multidimensional, and dynamic), sets, strings, collections and any class or interface that implements GetEnumerator().

 

{$APPTYPE CONSOLE}

for s in 'Hello' do

Writeln(s);

Output:

<pre>H

l

o</pre>

 

=={{header|E}}==

println(e)

In E, the for ... in ... loop is also used for iterating over numeric ranges; see [[Loop/For#E]].

 

=={{header|Efene}}==

Any data structure can be printed as a whole, preformated:

However, to iterate over each element of a list, Efene uses <tt>lists.map/2</tt>, except in the case of IO where <tt>lists.foreach/2</tt> has to be used as the evaluation order is defined to be the same as the order of the elements in the list.

 

=={{header|Eiffel}}==

{{works with|EiffelStudio|6.6 beta (with provisional loop syntax)}}

The iteration (foreach) form of the Eiffel loop construct is introduced by the keyword <code lang="eiffel">across</code>.

The local entity <code lang="eiffel">ic</code> is an instance of the library class <code lang="eiffel">ITERATION_CURSOR</code>. The cursor's feature <code lang="eiffel">item</code> provides access to each structure element. Descendants of class <code lang="eiffel">ITERATION_CURSOR</code> can be created to handle specialized iteration algorithms. The types of objects that can be iterated across (<code lang="eiffel">my_list</code> in the example) are based on classes that inherit from the library class <code lang="eiffel">ITERABLE</code>

===Boolean expression variant===

 

This iteration is a boolean expression which is true if all items in <code>my_list</code> have counts greater than three:

Whereas, the following is true if at least one item has a count greater than three:

 

=={{header|Ela}}==

 

 

 

 

=={{header|Emacs Lisp}}==

For a list either <code>dolist</code> macro

 

 

or <code>mapc</code> function

 

(message "x=%d" x))

 

 

 

=={{header|Erlang}}==

Any data structure can be printed as a whole, preformated:

However, to iterate over each element of a list, Erlang uses <tt>lists:map/2</tt>, except in the case of IO where <tt>lists:foreach/2</tt> has to be used as the evaluation order is defined to be the same as the order of the elements in the list.

 

=={{header|ERRE}}==

It's an extension of 'standard' FOR loop: constant list must be explicit.

FOR INDEX$=("The","quick","brown","fox","jumps","over","the","lazy","dog.") DO

PRINT(INDEX$;" ";)

END FOR

PRINT

 

=={{header|Euphoria}}==

{{works with|OpenEuphoria}}

include std/console.e

 

 

if getc(0) then end if

{{out}}

<pre>

2

</pre>

 

=={{header|Factor}}==

 

=={{header|Fantom}}==

Use <code>each</code> method to iterate over a collection of items in a <code>List</code>.

{

public static Void main ()

}

}

 

 

 

=={{header|Fortran}}==

 

implicit none

write(*,'(A)') colors

 

 

 

=={{header|Frink}}==

Frink's <CODE>for</CODE> loop is actually a "for each" loop which can iterate over built-in collection types including arrays, sets, dictionaries, enumerating expressions, and Java types such as Map, Iterator, Enumeration, etc.

array = [1, 2, 3, 5, 7]

for n = array

println[n]

 

 

 

=={{header|GAP}}==

 

Print(p, "\n");

od;

(1,3,4)

(1,2)(3,4)

 

=={{header|Go}}==

<code>range</code> works with all of the built-in container-types. With one variable (''i''), it gives you the key/index of every item. With two variables (''i'', ''x''), it gives you both the key/index and value/item. For channels, only the single-variable variant is allowed.

for i, x := range values {

fmt.Printf("Item %d = %d\n", i, x)

}

 

=={{header|Groovy}}==

"for" loop:

 

for(name in beatles) {

println name

"each()" method:<br>

Though technically not a loop, most Groovy programmers would use the somewhat more terse "each()" method on the list itself in preference to the "for" loop construct.

println it

Output (same for either):

<pre>John

George

Ringo</pre>

 

=={{header|Haskell}}==

which is the same as

 

=={{header|Haxe}}==

 

=={{header|HicEst}}==

 

items = INDEX(days, ' ', 256) ! 256 = count option

EDIT(Text=days, ITeM=j, Parse=today)

WRITE() today

 

 

=={{header|Icon}} and {{header|Unicon}}==

The example below X can be a list, string, table or other data type.

X := [1,2,3,-5,6,9]

every x := !L do

write(x)

This loop can be written somewhat more concisely as:

 

 

 

 

 

=={{header|Java}}==

{{works with|Java|1.5+}}

...

for(Type i:collect){

System.out.println(i);

This works for any array type as well as any type that implements the Iterable interface (including all Collections).

 

=={{header|JavaScript}}==

print(o[a]);

However, it has the often unwanted feature that it lists inherited properties and methods of objects as well as the ones directly set on the object -- consider whether to filter out such properties inside the loop, for example:

if (o.hasOwnProperty(a)) {

print(o[a]);

}

{{works with|JavaScript|1.6}}

;Deprecated

There is also a <tt>[https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Statements/for_each...in for each in]</tt> construct that iterates over the values of an object:

for (x in h) print(x);

{{works with|ECMAScript|6th edition}}

There is also a <tt>[https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Statements/for...of for of]</tt> construct that iterates over the values of an object:

for (x in h) print(x);

 

=={{header|jq}}==

'''Iterables''':

 

In this section, the array defined by "example" is used as an example:

jq has two types of iterables -- JSON arrays and JSON objects. In both cases, the ".[]" filter may be used to iterate through the values, it being understand that for objects, the "values" are the values associated with the keys:

 

In both cases, the output is the stream consisting of the values 1 followed by 2.

 

Sometimes it is necessary to use an alternative to ".[]". For example, one might want to generate an index along with the array elements. In such cases, the "range(m;n)" generator, which performs a similar role to C's "for(i=m; i<n; i++)", can be used for array. Here is how range/2 would be used to perform the task for an array:

For JSON objects, the corresponding technique involves using <tt>keys</tt>, e.g.

{"a":1, "b":2} | . as $o | keys | map( [., $o[.]] )

produces:

[["a",1],["b",2]]

 

To convert the constituent characters (or technically, codepoints) of a string into a stream of values, there are two techniques illustrated by these examples:

 

 

In both cases, the result is the stream of values: "a", "b", "c".

 

 

=={{header|K}}==

 

 

 

=={{header|LabVIEW}}==

[[LabVIEW]] has a feature known as an Auto-Indexed Tunnel. It is the very small orange box on the lower left of the for loop.<br/>{{VI solution|LabVIEW_Loops_Foreach.png}}

 

=={{header|Lang5}}==

 

 

 

 

=={{header|Lisaac}}==

word.print;

'\n'.print;

 

=={{header|Logo}}==

 

=={{header|Lua}}==

 

<code>pairs()</code> iterates over all entries in a table, but in no particular order:

for key, value in pairs(t) do

print(value, key)

Output:

<pre>

<code>ipairs()</code> iterates over table entries with positive integer keys,

and is used to iterate over lists in order.

for key, value in ipairs(l) do

print(key, value)

Output:

<pre>

</pre>

Note that <code>ipairs()</code> ignores non-numeric and non-positive integer keys.

 

=={{header|Maple}}==

for p in [2, 3, 5, 7] do

print(p);

end do;

 

Foreach over list of strings

Do[

Print@i,

{i, s}

Output:

<pre>We

 

=={{header|MATLAB}} / {{header|Octave}}==

for k = list1, % list1 must be a row vector (i.e. array of size 1xn)

printf('%i\n',k)

for k = list2, % list2 must be a row vector (i.e. array of size 1xn)

printf('%s\n',k{1})

A vectorized version of the code is

 

=={{header|Maxima}}==

 

=={{header|MAXScript}}==

arr = for i in 1 to 50 collect ("Number: " + (random 10 99) as string)

makeuniquearray arr

 

for i in arr do print i as string

 

=={{header|Metafont}}==

If we have a list of arbitrary items, we can simply use for:

The list can be generated in place by any suitable macro or another loop... e.g. let us suppose we have things like <tt>a[n]</tt> defined (with maximum n being 10). Then

works more like a <tt>foreach</tt>; we could make a macro to hide the strangeness of such a code.

 

=={{header|MOO}}==

for thing in (things)

player:tell(thing);

 

=={{header|Nemerle}}==

This works on anything which implements the IEnumerable interface.

 

foreach (thing in things) WriteLine(thing.ToLower());

 

=={{header|NetRexx}}==

options replace format comments java crossref savelog symbols nobinary

 

loop while daysi.hasNext

say daysi.next

 

=={{header|NewLISP}}==

 

=={{header|Nim}}==

ipsum

</pre>

 

=={{header|Objective-C}}==

{{works with|GNUstep}}

{{works with|Cocoa}}

NSLog(@"%@", i);

''collect'' can be any object that adopts the NSFastEnumeration protocol.

 

Or (always using OpenStep compatible frameworks):

{{works with|Objective-C|<2.0}}

NSEnumerator *enm = [collect objectEnumerator];

id i;

// do something with object i

 

=={{header|OCaml}}==

List of integers:

(fun i -> Printf.printf "%d\n" i)

Array of integers:

(fun i -> Printf.printf "%d\n" i)

 

=={{header|Octave}}==

b = [ 1,2,3,4; 5,6,7,8 ];

for v = a

for v = b

disp(v); % v is the column vector [1;5], then [2;6] ...

We can also iterate over structures:

x.b = { "Cell", "ul", "ar" };

for [ val, key ] = x

disp(key);

disp(val);

 

=={{header|ooRexx}}==

The <tt>OVER</tt> loop control keyword is used to select each item in a collection in turn.

Open Object Rexx allows the <tt>DO</tt> block structure keyword to be used to start a loop for backward compatibility with classic Rexx; the <tt>LOOP</tt> keyword is preferred here as it is self-documenting.

say

say 'Loops/Foreach'

say out~strip()

 

'''Output:'''

<pre>

 

=={{header|Oz}}==

MyList = [1 2 3 4]

in

 

%% or:

 

=={{header|PARI/GP}}==

 

or (PARI/GP >= 2.4)

 

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

print "$i\n";

The keyword <code>for</code> can be used instead of <code>foreach</code>. If a loop variable (here <code>$i</code>) is not given, then <code>$_</code> is used.

 

A more compact notation using perl statement modifier:

 

In perl, it is possible to loop against an explicit list, so there is no need to define a container:

 

print "I like $l\n";

 

 

=={{header|PHL}}==

 

numbers each # (number) [

printf("%i\n", number);

 

=={{header|PHP}}==

echo "$i\n";

}

foreach ($collect as $key => $i) {

echo "\$collect[$key] = $i\n";

<code>foreach</code> can also iterate over objects. By default it iterates over all visible fields of an object.

 

=={{header|PicoLisp}}==

 

=={{header|Pike}}==

array(int|string) collect = ({109, "Hi", "asdf", "qwerty"});

foreach(collect, int|string elem){

write(elem + "\n");

}

Iterating over the keys and values of a mapping (dictionary):

mapping(string:string) coll = (["foo":"asdf", "bar":"qwer", "quux":"zxcv"]);

foreach (coll;string key;string val)

write(key+" --> "+val+"\n");

}

 

=={{header|PL/I}}==

do i = lbound(A,1) to hbound(A,1);

put skip list (A(i));

 

=={{header|Pop11}}==

Iteration over list:

for el in lst do

printf(el,'%p\n');

 

=={{header|PostScript}}==

The <code>forall</code> operator performs a loop over a collection (array, string or dictionary). Strings and arrays can be treated very much the same:

but dictionaries take a little more work since a key/value pair is pushed on the stack in each iteration:

exch (Key: ) print

=

(Value: ) print

=

 

=={{header|PowerShell}}==

 

=={{header|Prolog}}==

For example :

red

green

white

true.

 

=={{header|Python}}==

 

Note: The Python <code>for</code> statement is always a ''"foreach" ...'' and the <code>range()</code> and <code>xrange()</code> built-in functions are used to generate lists of indexes over which it will iterate as necessary. The majority of Python objects support iteration. Lists and tuples iterate over each item, strings iterate over each character, dictionaries iterate over keys, files iterate over lines, and so on.

 

For example:

f = open('somefile','r')

for eachline in f:

characters += 1

 

 

Whether <code>for</code> loops over the elements of the collection in order depends on the collection having an inherent order or not. Elements of strings (i.e. characters), tuples and lists, for example, are ordered but the order of elements in dictionaries and sets is not defined.

One can loop over the key/value pairs of a dictionary in ''alphabetic'' or ''numeric'' key order by sorting the sequence of keys, provided that the keys are all of ''comparable'' types. In Python 3.x a sequence of mixed numeric and string elements is not sortable (at least not with the default invocation of <code>sorted()</code>), whereas in Python 2.x numeric types are sorted according to their string representation by default:

 

for k in sorted(d):

print("%i: %s" % (k, d[k]))

d = {"London": "United Kingdom", "Berlin": "Germany", "Rome": "Italy", "Paris": "France"}

for k in sorted(d):

 

{{works with|Python|2.x}}

 

for k in sorted(d):

 

=={{header|R}}==

 

=={{header|Racket}}==

 

#lang racket

 

(for ([i sequence])

(displayln i))

 

=={{header|REBOL}}==

Title: "Loop/Foreach"

URL: http://rosettacode.org/wiki/Loop/Foreach

]

; the list from the current position.

 

Output:

<pre>Sorkday Gunday Bluesday Nedsday Thirstday Frightday Caturday

Sorkday Gunday Bluesday Nedsday Thirstday Frightday Caturday</pre>

 

=={{header|Retro}}==

 

 

 

 

 

=={{header|REXX}}==

 

do j=1 for words(days) /*loop through days of the week. */

say word(days,j) /*display the weekday to screen. */

end /*j*/

 

=={{header|Ruby}}==

puts i

This is syntactic sugar for:

puts i

There are various flavours of <code>each</code> that may be class-dependent: [http://www.ruby-doc.org/core/classes/String.html#M000862 String#each_char], [http://www.ruby-doc.org/core/classes/Array.html#M002174 Array#each_index], [http://www.ruby-doc.org/core/classes/Hash.html#M002863 Hash#each_key], etc

 

=={{header|Rust}}==

Rust's for-loop already is a foreach-loop.

for elem in collection {

println!("{}", elem);

 

Do note that Rust moves values by default and doesn't copy them. A vector would be unusable after looping over it like above. To preserve it, borrow it or use an Iter, to mutate values do a mutable borrow or create an IterMut. To get an immutable reference omit the mut-part.

for mut_ref in &mut collection {

// alternatively:

// for immut_ref in collection.iter() {

println!("{}", *immut_ref);

 

=={{header|Salmon}}==

output:

<pre>

 

=={{header|SAS}}==

data _null_;

array a a1-a10;

s=sum(of a{*});

put s;

 

=={{header|Sather}}==

main is

num:ARRAY{INT} := |1, 5, 4, 3, 10|;

end;

end;

 

=={{header|Scala}}==

Alternatively:

 

=={{header|Scheme}}==

List:

(lambda (i) (display i) (newline))

 

=={{header|Scilab}}==

{{works with|Scilab|5.5.1}}

printf("%s\n",e)

{{out}}

b

 

=={{header|Seed7}}==

The for loop of Seed7 can be used to loop over the elements of a container.

 

var array string: things is [] ("Apple", "Banana", "Coconut");

writeln(thing);

end for;

 

=={{header|Sidef}}==

 

 

=={{header|Slate}}==

 

=={{header|Smalltalk}}==

 

=={{header|Sparkling}}==

Sparkling currently has no "foreach" construct, but there's a "foreach" function in the standard library:

 

foreach(hash, function(key, val) {

print(key, " -> ", val);

 

=={{header|Standard ML}}==

List of integers:

(fn i => print (Int.toString i ^ "\n"))

Array of integers:

(fn i => print (Int.toString i ^ "\n"))

 

=={{header|Suneido}}==

 

=={{header|Swift}}==

 

=={{header|SystemVerilog}}==

int values[$];

 

end

end

 

=={{header|Tcl}}==

puts "$i"

Note that <tt>foreach</tt> also accepts multiple variables:

puts "$x,$y"

And also multiple lists:

puts "$i,$j"

Or any combination of variables/list:

puts "$i,$x,$y"

 

=={{header|Trith}}==

 

=={{header|TUSCRIPT}}==

week="Monday'Tuesday'Wednesday'Thursday'Friday'Saterday'Sunday"

LOOP day=week

PRINT day

Output:

<pre>

To iterate any single list, you use a <code>for</code> loop.

{{works with|Bourne Shell}}

echo "filename is $file"

If the list is in a shell parameter (like <code>PATH</code>), you adjust <code>IFS</code>.

{{works with|Bourne Shell}}

 

oldifs=$IFS

echo search $dir

done

Some shells have real arrays. The <code>for</code> loop can also iterate these.

{{works with|Bash}}

for x in "${collection[@]}"; do

echo "$x"

{{works with|pdksh|5.2.14}}

for x in "${collection[@]}"; do

echo "$x"

 

==={{header|C Shell}}===

foreach x ($collection:q)

echo $x:q

 

=={{header|V}}==

 

 

=={{header|Vim Script}}==

Vim Script's for-loop is actually a foreach-loop and iterates through a list.

echo i

 

 

=={{header|Wart}}==

 

=={{header|XPL0}}==

Translation of C example:

int List, I;

[List:= ["Red", "Green", "Blue", "Black", "White"];

for I:= 0, 5-1 do

[Text(0, List(I)); CrLf(0)];

 

=={{header|XSLT}}==

For-each is the only iteration construct that is built into XSLT. All other iteration is either implied by applying a template to all members matching an XPath expression, or built from recursive application of a template. You have access to something like a loop counter with the one-based "position()" function.

<xsl:for-each select="person[@age &gt;= 21]">

<fo:block><xsl:value-of select="position()"/>. <xsl:value-of select="@name"/></fo:block>

 

=={{header|zkl}}==

{{trans|XPL0}}

{{out}}

<pre>Red Green Blue Black White</pre>

Other forms of foreach, one that breaks apart a container into elements and one line nested loops.

{{out}}

<pre>

356

</pre>

 

{{omit from|GUISS}}