Loops/Foreach: Difference between revisions

(82 intermediate revisions by 51 users not shown)

Line 22:

*   [[Loops/Wrong ranges]]

=={{header|11l}}==

<syntaxhighlight lang="11l">V things = [‘Apple’, ‘Banana’, ‘Coconut’]

L(thing) things

print(thing)</syntaxhighlight>

=={{header|ACL2}}==

<~~lang~~ ~~Lisp~~>(defun print-list (xs)

<syntaxhighlight lang="lisp">(defun print-list (xs)

(if (endp xs)

nil

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

(print-list (rest xs)))))</~~lang~~>

(print-list (rest xs)))))</syntaxhighlight>

<pre>

Line 39:

Line 47:

SYM

NIL

</pre>

=={{header|Action!}}==

In Action! there is no for-each loop.

<syntaxhighlight lang="action!">PROC Main()

DEFINE PTR="CARD"

BYTE i

PTR ARRAY items(10)

items(0)="First" items(1)="Second"

items(2)="Third" items(3)="Fourth"

items(4)="Fifth" items(5)="Sixth"

items(6)="Seventh" items(7)="Eighth"

items(8)="Ninth" items(9)="Tenth"

PrintE("In Action! there is no for-each loop")

PutE()

FOR i=0 TO 9

DO

PrintE(items(i))

OD

RETURN</syntaxhighlight>

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Foreach.png Screenshot from Atari 8-bit computer]

<pre>

In Action! there is no for-each loop

First

Second

Third

Fourth

Fifth

Sixth

Seventh

Eighth

Ninth

Tenth

</pre>

=={{header|Ada}}==

===arrays===

<~~lang~~ ~~Ada~~>with Ada.Integer_Text_IO;

<syntaxhighlight lang="ada">with Ada.Integer_Text_IO;

use Ada.Integer_Text_IO;

Line 56:

Line 100:

end loop;

end For_Each;</~~lang~~>

end For_Each;</syntaxhighlight>

Alternative solution (Ada 2012):

<~~lang~~ ~~Ada~~> for Item of A loop

<syntaxhighlight lang="ada"> for Item of A loop

Put( Item );

end loop;</~~lang~~>

end loop;</syntaxhighlight>

===doubly linked lists===

<~~lang~~ ~~Ada~~>with Ada.Integer_Text_IO, Ada.Containers.Doubly_Linked_Lists;

<syntaxhighlight lang="ada">with Ada.Integer_Text_IO, Ada.Containers.Doubly_Linked_Lists;

use Ada.Integer_Text_IO, Ada.Containers;

Line 90:

Line 134:

DL_List.Iterate (Print_Node'Access);

end Doubly_Linked_List;</~~lang~~>

end Doubly_Linked_List;</syntaxhighlight>

===vectors===

<~~lang~~ ~~Ada~~>with Ada.Integer_Text_IO, Ada.Containers.Vectors;

<syntaxhighlight lang="ada">with Ada.Integer_Text_IO, Ada.Containers.Vectors;

use Ada.Integer_Text_IO, Ada.Containers;

Line 117:

Line 161:

V.Iterate (Print_Element'Access);

end Vector_Example;</~~lang~~>

end Vector_Example;</syntaxhighlight>

=={{header|Aikido}}==

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

===strings===

<~~lang~~ aikido>var str = "hello world"

<syntaxhighlight lang="aikido">var str = "hello world"

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

println (ch) // one character at a time

}</~~lang~~>

}</syntaxhighlight>

===vectors===

<~~lang~~ aikido>var vec = [1,2,3,4]

<syntaxhighlight lang="aikido">var vec = [1,2,3,4]

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

println (v)

}</~~lang~~>

}</syntaxhighlight>

===maps===

<~~lang~~ aikido>var cities = {"San Ramon": 50000, "Walnut Creek": 70000, "San Francisco": 700000} // map literal

<syntaxhighlight lang="aikido">var cities = {"San Ramon": 50000, "Walnut Creek": 70000, "San Francisco": 700000} // map literal

foreach city cities {

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

}</~~lang~~>

}</syntaxhighlight>

===integers===

<~~lang~~ aikido>foreach i 100 {

<syntaxhighlight lang="aikido">foreach i 100 {

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

}

Line 149:

Line 193:

foreach i a..b {

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

}</~~lang~~>

}</syntaxhighlight>

===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

<~~lang~~ aikido>class List {

<syntaxhighlight lang="aikido">class List {

class Element (public data) {

public var next = null

Line 185:

Line 229:

foreach n list {

println (n)

}</~~lang~~>

}</syntaxhighlight>

===Coroutines===

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

<~~lang~~ aikido>// coroutine to generate the squares of a sequence of numbers

<syntaxhighlight lang="aikido">// coroutine to generate the squares of a sequence of numbers

function squares (start, end) {

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

Line 200:

Line 244:

foreach s squares (start, end) {

println (s)

}</~~lang~~>

}</syntaxhighlight>

===Files===

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

<~~lang~~ aikido>var s = openin ("input.txt")

<syntaxhighlight lang="aikido">var s = openin ("input.txt")

foreach line s {

print (line)

}</~~lang~~>

}</syntaxhighlight>

===Enumerations===

<~~lang~~ aikido>enum Color {

<syntaxhighlight lang="aikido">enum Color {

RED, GREEN, BLUE

}

Line 214:

Line 258:

foreach color Color {

println (color)

}</~~lang~~>

}</syntaxhighlight>

=={{header|Aime}}==

<~~lang~~ aime># iterate over a list of integers

<syntaxhighlight lang="aime"># iterate over a list of integers

integer i, v;

for (i, v in list(2, 3, 5, 7, 11, 13, 17, 18)) {

}</~~lang~~>

}</syntaxhighlight>

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

Line 228:

Line 271:

{{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}}

<~~lang~~ algol68>[]UNION(STRING, INT, PROC(REF FILE)VOID) collection = ("Mary","Had",1,"little","lamb.",new line);

<syntaxhighlight lang="algol68">[]UNION(STRING, INT, PROC(REF FILE)VOID) collection = ("Mary","Had",1,"little","lamb.",new line);

FOR index FROM LWB collection TO UPB collection DO

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

OD</~~lang~~>

OD</syntaxhighlight>

Output:

<pre>

Mary Had +1 little lamb.

</pre>

Note: [[ALGOL 68S]] actually has a reserved word FOREACH that is used to break arrays in to portions, and process in parallel.

[[ALGOL 68S]] has a reserved word FOREACH that is used to break arrays in to portions, and process in parallel.

[[ALGOL 68RS]] and [[Algol68toc]] have a FORALL loop, the following is equivalent to the example above:

<syntaxhighlight lang="algol68">FORALL c IN collection DO

print((c," "))

OD</syntaxhighlight>

=={{header|Amazing Hopper}}==

#include <jambo.h>

Main

things = {}, len list=0

Set ' 100,200,300,"Hello world!", -3,-2,-1 ' Apndlist 'things'

Let ' len list := Length(things) '

Printnl ' "\nNormal count:\n" '

For each( n, things, len list )

Printnl ' "Thing : ", n '

For each reverse ( n, things, len list )

Printnl ' "Thing : ", n '

</syntaxhighlight>

<pre>

Normal count:

Thing : 100

Thing : 200

Thing : 300

Thing : Hello world!

Thing : -3

Thing : -2

Thing : -1

Reverse count:

Thing : -1

Thing : -2

Thing : -3

Thing : Hello world!

Thing : 300

Thing : 200

Thing : 100

</pre>

=={{header|AmigaE}}==

<~~lang~~ amigae>PROC main()

<syntaxhighlight lang="amigae">PROC main()

DEF a_list : PTR TO LONG, a

a_list := [10, 12, 14]

Line 248:

Line 342:

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

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

ENDPROC</~~lang~~>

ENDPROC</syntaxhighlight>

=={{header|Apex}}==

Integer[] myInts = new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Line 257:

Line 351:

System.debug(i);

}

</syntaxhighlight>

</lang>

=={{header|AppleScript}}==

<~~lang~~ ~~AppleScript~~>repeat with fruit in {"Apple", "Orange", "Banana"}

<syntaxhighlight lang="applescript">repeat with fruit in {"Apple", "Orange", "Banana"}

log contents of fruit

end repeat</~~lang~~>

end repeat</syntaxhighlight>

=={{header|Arturo}}==

<~~lang~~ ~~arturo~~>~~array~~: #("one" "two" "three")

<syntaxhighlight lang="rebol">arr: ["one" "two" "three"]

dict: #{

dict: #[

name: "~~john~~"

name: "John"

surname: "~~doe~~"

surname: "Doe"

age: 33

age: 34

]

}

loop ~~array~~ {

loop arr 'item ->

print &

print item

}

loop dict @(key val){

loop dict [key val]->

print key + " => " + val

print [key "=>" val]</syntaxhighlight>

}</lang>

<pre>one

two

three

~~surname~~ => ~~doe~~

name => John

~~age~~ => 33

surname => Doe

~~name~~ => ~~john~~

age => 34</pre>

</pre>

=={{header|AutoHotkey}}==

<~~lang~~ ~~AutoHotkey~~>string = mary,had,a,little,lamb

<syntaxhighlight lang="autohotkey">string = mary,had,a,little,lamb

Loop, Parse, string, `,

MsgBox %A_LoopField%</~~lang~~>

MsgBox %A_LoopField%</syntaxhighlight>

=={{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).

<~~lang~~ awk>

BEGIN {

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

Line 302:

Line 393:

print strs[el]

}

}</~~lang~~>

}</syntaxhighlight>

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,

Line 308:

Line 399:

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

a normal loop can be used:

<~~lang~~ awk>BEGIN {

<syntaxhighlight lang="awk">BEGIN {

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

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

print strs[i]

}

}</~~lang~~>

}</syntaxhighlight>

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:

<~~lang~~ awk># This will not work

<syntaxhighlight lang="awk"># This will not work

BEGIN {

for (l in "apples","bananas","cherries") {

for (el in "apples","bananas","cherries") {

print "I like " l

print "I like " el

}

}</lang>

}</syntaxhighlight>

=={{header|Bait}}==

`for-in` loops work with both builtin container types (arrays and maps).

They allow to iterate the indices/keys and values.

fun for_in_array() {

arr := ['1st', '2nd', '3rd']

// Iterate over array indices and elements

for i, val in arr {

println('${i}: ${val}')

}

// Using only one variable will iterate over the elements

for val in arr {

println(val)

}

// To only iterate over the indices, use `_` as the second variable name.

// `_` is a special variable that will ignore any assigned value

for i, _ in arr {

println(i)

}

fun for_in_map() {

nato_abc := map{

'a': 'Alpha'

'b': 'Bravo'

'c': 'Charlie'

'd': 'Delta'

}

// Iterate over map keys and values.

// Note that, unlike arrays, only the two-variable variant is allowed

for key, val in nato_abc {

println('${key}: ${val}')

}

fun main() {

for_in_array()

println('')

for_in_map()

}

</syntaxhighlight>

=={{header|BASIC}}==

==={{header|BaCon}}===

BaCon includes support for ''delimited strings''. Delimited strings form a type of collection. Along with this support is a <code>for in</code> loop. Not quite a <code>for each</code> but pretty close.

<syntaxhighlight lang="freebasic">OPTION COLLAPSE TRUE

FOR x$ IN "Hello cruel world"

PRINT x$

PRINT y$

NEXT</syntaxhighlight>

<pre>prompt$ bacon -q forin.bac >/dev/null

prompt$ ./forin

Hello

cruel

world

1

2

"3,4"

5</pre>

The <code>OPTION COLLAPSE TRUE</code> statements prevents empty results when multiple delimiters appear together. The default delimiter is space, and can be changed with <code>OPTION DELIM x</code> where x is a static string literal.

==={{header|BASIC256}}===

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

<~~lang~~ ~~BASIC256~~>DIM collection$(1)

<syntaxhighlight lang="basic256">DIM collection$(1)

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

Line 334:

Line 498:

PRINT collection$[i]+ " ";

NEXT i

PRINT</~~lang~~>

PRINT</syntaxhighlight>

Output:

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

Line 340:

Line 504:

==={{header|BBC BASIC}}===

<~~lang~~ bbcbasic> DIM collection$(8)

<syntaxhighlight lang="bbcbasic"> DIM collection$(8)

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

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

Line 347:

Line 511:

PRINT collection$(index%) " ";

PRINT</~~lang~~>

PRINT</syntaxhighlight>

==={{header|Commodore BASIC}}===

Commodore BASIC too does not have a FOR-EACH construct. FOR loop is used to iterate through a string array by index. READ-DATA is used to fill up the string array

<~~lang~~ qbasic>10 DIM A$(9) :REM DECLARE STRING ARRAY

<syntaxhighlight lang="qbasic">10 DIM A$(9) :REM DECLARE STRING ARRAY

20 REM *** FILL ARRAY WITH WORDS ***

30 FOR I = 0 TO 8

Line 361:

Line 525:

90 NEXT

100 END

1000 DATA THE, QUICK, BROWN, FOX, JUMPS, OVER, THE, LAZY, DOG.</~~lang~~>

1000 DATA THE, QUICK, BROWN, FOX, JUMPS, OVER, THE, LAZY, DOG.</syntaxhighlight>

==={{header|Creative Basic}}===

<~~lang~~ ~~Creative~~ ~~Basic~~>DEF AnArray[11]:INT

<syntaxhighlight lang="creative basic">DEF AnArray[11]:INT

AnArray=0,1,2,3,4,5,6,7,8,9,10

Line 383:

Line 547:

'because this is a console only program.

END

</syntaxhighlight>

</lang>

==={{header|FreeBASIC}}===

<~~lang~~ freebasic>' FB 1.05.0

<syntaxhighlight lang="freebasic">' FB 1.05.0

' FreeBASIC doesn't have a foreach loop but it's easy to manufacture one using macros

Line 403:

Line 567:

Print

Sleep</~~lang~~>

Sleep</syntaxhighlight>

Line 412:

Line 576:

==={{header|Gambas}}===

'''[https://gambas-playground.proko.eu/?gist=cb94500c68749f6f93915f3f10de5a03 Click this link to run this code]'''

<~~lang~~ gambas>Public Sub Main()

<syntaxhighlight lang="gambas">Public Sub Main()

Dim siInput As Short[] = [1, 8, 0, 6, 4, 7, 3, 2, 5, 9]

Dim siTemp As Short

Line 420:

Line 584:

End</~~lang~~>

End</syntaxhighlight>

<pre>

Line 427:

Line 591:

==={{header|IS-BASIC}}===

<~~lang~~ IS-~~BASIC~~>100 STRING COLLECTION$(1 TO 9)*8

<syntaxhighlight lang="is-basic">100 STRING COLLECTION$(1 TO 9)*8

110 LET I=1

120 DO

Line 436:

Line 600:

170 PRINT COLLECTION$(J);" ";

180 NEXT

190 DATA The,quick,brown,fox,jumps,over,the,lazy,dog.</~~lang~~>

190 DATA The,quick,brown,fox,jumps,over,the,lazy,dog.</syntaxhighlight>

==={{header|IWBASIC}}===

'''Linked List'''

<~~lang~~ ~~IWBASIC~~>DEF AList:POINTER

<syntaxhighlight lang="iwbasic">DEF AList:POINTER

AList=ListCreate()

Line 471:

Line 635:

'Because this is a console only program.

END</~~lang~~>

END</syntaxhighlight>

'''An Array'''

<~~lang~~ ~~IWBASIC~~>DEF AnArray[11]:INT

<syntaxhighlight lang="iwbasic">DEF AnArray[11]:INT

AnArray=0,1,2,3,4,5,6,7,8,9,10

Line 491:

Line 655:

'Because this is a console only program.

END

</syntaxhighlight>

</lang>

==={{header|Lambdatalk}}===

{def collection alpha beta gamma delta}

-> collection

{S.map {lambda {:i} {br}:i} {collection}}

->

alpha

beta

gamma

delta

or

{def S.foreach

{lambda {:s}

{if {S.empty? {S.rest :s}}

then {S.first :s}

else {S.first :s} {br}{S.foreach {S.rest :s}}}}}

{S.foreach {collection}}

->

alpha

beta

gamma

delta

</syntaxhighlight>

==={{header|Liberty BASIC}}===

The most natural way is to use a csv list with a sentinel value.

<~~lang~~ lb>in$ ="Not,Hardly,Just,Adequately,Quite,Really,Very,Fantastically,xyzzy"

<syntaxhighlight lang="lb">in$ ="Not,Hardly,Just,Adequately,Quite,Really,Very,Fantastically,xyzzy"

element$ =""

i =1 ' used to point to successive elements

Line 506:

Line 699:

loop until 1 =2

end</~~lang~~>

end</syntaxhighlight>

Not good!

Hardly good!

Line 517:

Line 710:

==={{header|NS-HUBASIC}}===

<~~lang~~ NS-~~HUBASIC~~>10 DIM A$(9) : REM DECLARE STRING ARRAY

<syntaxhighlight lang="ns-hubasic">10 DIM A$(9) : REM DECLARE STRING ARRAY

20 REM ADD DATA TO ARRAY AND PRINT ARRAY CONTENTS

30 FOR I=0 TO 8

Line 523:

Line 716:

50 PRINT A$(I)" ";

60 NEXT

70 DATA THE, QUICK, BROWN, FOX, JUMPS, OVER, THE, LAZY, DOG.</~~lang~~>

70 DATA THE, QUICK, BROWN, FOX, JUMPS, OVER, THE, LAZY, DOG.</syntaxhighlight>

==={{header|PureBasic}}===

Works for LinkedLists and Maps

<~~lang~~ ~~PureBasic~~>ForEach element()

<syntaxhighlight lang="purebasic">ForEach element()

PrintN(element())

Next</~~lang~~>

Next</syntaxhighlight>

==={{header|Run BASIC}}===

<~~lang~~ runbasic>t$={Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday"

<syntaxhighlight lang="runbasic">t$={Sunday,Monday,Tuesday,Wednesday,Thursday,Friday,Saturday"

while word$(t$,i+1,",") <> ""

i = i + 1

print word$(t$,i,",")

wend</~~lang~~>

wend</syntaxhighlight>

==={{header|TI-89 BASIC}}===

<~~lang~~ ti89b>Local i,strs

<syntaxhighlight lang="ti89b">Local i,strs

Define strs = {"Lorem","ipsum","dolor"}

For i, 1, dim(strs)

Disp strs[i]

EndFor</~~lang~~>

EndFor</syntaxhighlight>

==={{header|VBA}}===

<~~lang~~ VB>Public Sub LoopsForeach()

<syntaxhighlight lang="vb">Public Sub LoopsForeach()

Dim FruitArray() As Variant

Dim Fruit As Variant

Line 559:

Line 752:

Debug.Print Fruit

Next Fruit

End Sub</~~lang~~>

End Sub</syntaxhighlight>

==={{header|VBScript}}===

<~~lang~~ vbscript>items = Array("Apple", "Orange", "Banana")

<syntaxhighlight lang="vbscript">items = Array("Apple", "Orange", "Banana")

For Each x In items

WScript.Echo x

Next</~~lang~~>

Next</syntaxhighlight>

==={{header|Visual Basic .NET}}===

<~~lang~~ vbnet>Dim list As New List(Of String)

<syntaxhighlight lang="vbnet">Dim list As New List(Of String)

list.Add("Car")

list.Add("Boat")

Line 576:

Line 769:

For Each item In list

Console.WriteLine(item)

Next</~~lang~~>

Next</syntaxhighlight>

==={{header|Yabasic}}===

<syntaxhighlight lang="yabasic">//Yabasic tampoco tiene una construcción ForEach.

//Mediante un bucle FOR iteramos a través de una matriz por índice.

//READ-DATA se usa para rellenar la matriz

dim arreglo(10)

data 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11

for each = 0 to arraysize(a(),1)

read arreglo(each)

next each

for each = 0 to arraysize(a(),1)

print arreglo(each), " ";

next each

print

end</syntaxhighlight>

=={{header|Batch File}}==

Line 582:

Line 794:

'''Direct usage:'''

<~~lang~~ dos>@echo off

<syntaxhighlight lang="dos">@echo off

for %%A in (This is a sample collection) do (

echo %%A

)</~~lang~~>

)</syntaxhighlight>

'''Using a Collection Variable:'''

<~~lang~~ dos>@echo off

<syntaxhighlight lang="dos">@echo off

set "collection=This is a sample collection"

for %%A in (%collection%) do (

echo %%A

)</~~lang~~>

)</syntaxhighlight>

<pre>This

Line 601:

Line 813:

=={{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.

<~~lang~~ bc>a[0] = .123

<syntaxhighlight lang="bc">a[0] = .123

a[1] = 234

a[3] = 95.6

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

a[i]

}</~~lang~~>

}</syntaxhighlight>

=={{header|Bracmat}}==

Bracmat has a more or less traditional 'while' loop (<code>whl'expression</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:

<~~lang~~ bracmat> ( list

<syntaxhighlight lang="bracmat"> ( list

= Afrikaans

Ελληνικά

Line 617:

Line 829:

മലയാളം

ئۇيغۇرچە

)</~~lang~~>

)</syntaxhighlight>

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

<~~lang~~ bracmat> !list:?L

<syntaxhighlight lang="bracmat"> !list:?L

& whl'(!L:%?language ?L&out$!language)</~~lang~~>

& whl'(!L:%?language ?L&out$!language)</syntaxhighlight>

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.

<~~lang~~ bracmat> !list:?L

<syntaxhighlight lang="bracmat"> !list:?L

& ( loop

= !L:%?language ?L

Line 628:

Line 840:

& !loop

)

& ~!loop</~~lang~~>

& ~!loop</syntaxhighlight>

A completely different way of iteration is by using a pattern that matches an element in the list, does something useful as a side effect and then fails, forcing bracmat to backtrack and try the next element in the list. The <code>@</code> flag matches at most one element. The <code>%</code> flag matches at least one element. Together they ensure that exactly one language name is assigned to the variable <code>language</code>. After all elements have been done, control is passed to the rhs of the <code>|</code> operator.

<~~lang~~ bracmat> ( !list

<syntaxhighlight lang="bracmat"> ( !list

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

|

)</~~lang~~>

)</syntaxhighlight>

=={{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.

<~~lang~~ c>#include <stdio.h>

<syntaxhighlight lang="c">#include <stdio.h>

...

Line 646:

Line 858:

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

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

}</~~lang~~>

}</syntaxhighlight>

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.

C string as a collection of char

#include <stdio.h>

#include <stdlib.h>

Line 669:

Line 881:

return(0);

}

</syntaxhighlight>

</lang>

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

#include <stdio.h>

#include <stdlib.h>

Line 689:

Line 901:

return(0);

}

</syntaxhighlight>

</lang>

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

: ''Note: idxtype can be removed and [http://gcc.gnu.org/onlinedocs/gcc/Typeof.html typeof(col[0])] can be used in it's place with [[GCC]]''

#include <stdio.h>

#include <stdlib.h>

Line 718:

Line 930:

return(0);

}

</syntaxhighlight>

</lang>

=={{header|C sharp|C#}}==

<syntaxhighlight lang="csharp">string[] things = {"Apple", "Banana", "Coconut"};

foreach (string thing in things)

{

Console.WriteLine(thing);

}</syntaxhighlight>

=={{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.

<~~lang~~ cpp>for (container_type::iterator i = container.begin(); i != container.end(); ++i)

<syntaxhighlight lang="cpp">for (container_type::iterator i = container.begin(); i != container.end(); ++i)

{

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

}</~~lang~~>

}</syntaxhighlight>

However the idiomatic way to output a container would be

<~~lang~~ cpp>std::copy(container.begin(), container.end(),

<syntaxhighlight lang="cpp">std::copy(container.begin(), container.end(),

std::ostream_iterator<container_type::value_type>(std::cout, "\n"));</~~lang~~>

std::ostream_iterator<container_type::value_type>(std::cout, "\n"));</syntaxhighlight>

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

<~~lang~~ cpp>void print_element(container_type::value_type const& v)

<syntaxhighlight lang="cpp">void print_element(container_type::value_type const& v)

{

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

Line 736:

Line 956:

...

std::for_each(container.begin(), container.end(), print_element);</~~lang~~>

std::for_each(container.begin(), container.end(), print_element);</syntaxhighlight>

<~~lang~~ cpp>for (auto element: container)

<syntaxhighlight lang="cpp">for (auto element: container)

{

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

}</~~lang~~>

}</syntaxhighlight>

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:

<~~lang~~ cpp>for (auto const& element: container)

<syntaxhighlight lang="cpp">for (auto const& element: container)

{

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

}</~~lang~~>

}</syntaxhighlight>

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

<~~lang~~ cpp>for (auto&& element: container) //use a 'universal reference'

<syntaxhighlight lang="cpp">for (auto&& element: container) //use a 'universal reference'

{

element += 42;

}</~~lang~~>

}</syntaxhighlight>

=={{header|~~C sharp|C#~~}}==

=={{header|C3}}==

C3 has a standard built-in foreach for iterating through lists.

<lang csharp>string[] things = {"Apple", "Banana", "Coconut"};

<syntaxhighlight lang="c3">String[] fruits = { "Apple", "Banana", "Strawberry" };

foreach (string thing in things)

foreach (fruit : fruits) io::printn(fruit);</syntaxhighlight>

{

Console.WriteLine(thing);

}</lang>

=={{header|Chapel}}==

<~~lang~~ chapel>var food = ["Milk", "Bread", "Butter"];

<syntaxhighlight lang="chapel">var food = ["Milk", "Bread", "Butter"];

for f in food do writeln(f);</~~lang~~>

for f in food do writeln(f);</syntaxhighlight>

=={{header|Clojure}}==

<~~lang~~ lisp>(doseq [item collection] (println item))</~~lang~~>

<syntaxhighlight lang="lisp">(doseq [item collection] (println item))</syntaxhighlight>

=={{header|CLU}}==

As in Python (which no doubt got the idea from CLU), every for loop in

CLU is really a foreach, and iterating over a range of numbers is done

by using an iterator (e.g. <code>int$from_to</code>).

Unlike Python, the for loop '''only''' accepts iterators, and collections

are not automatically cast into iterators. To loop over the elements of an array,

one needs to explicitly use the <code>elements</code> iterator.

<syntaxhighlight lang="clu">start_up = proc ()

po: stream := stream$primary_output()

words: array[string] := array[string]$

["enemy", "lasagna", "robust", "below", "wax"]

for word: string in array[string]$elements(words) do

stream$putl(po, word)

end

end start_up</syntaxhighlight>

=={{header|CMake}}==

<~~lang~~ cmake>set(list one.c two.c three.c)

<syntaxhighlight lang="cmake">set(list one.c two.c three.c)

foreach(file ${list})

message(${file})

endforeach(file)</~~lang~~>

endforeach(file)</syntaxhighlight>

=={{header|COBOL}}==

Line 779:

Line 1,018:

<~~lang~~ cobol>01 things occurs 3.

<syntaxhighlight lang="cobol">01 things occurs 3.

...

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

perform varying thing as string through things

display thing

end-perform</~~lang~~>

end-perform</syntaxhighlight>

=={{header|ColdFusion}}==

<~~lang~~ cfm>

</Cfloop>

</syntaxhighlight>

</lang>

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

<~~lang~~ lisp>(loop for i in list do (print i))</~~lang~~>

<syntaxhighlight lang="lisp">(loop for i in list do (print i))</syntaxhighlight>

or

<~~lang~~ lisp>(map nil #'print list)</~~lang~~>

<syntaxhighlight lang="lisp">(map nil #'print list)</syntaxhighlight>

or

<~~lang~~ lisp>(dolist (x the-list) (print x))</~~lang~~>

<syntaxhighlight lang="lisp">(dolist (x the-list) (print x))</syntaxhighlight>

or

<~~lang~~ lisp>(use-package :iterate)

<syntaxhighlight lang="lisp">(use-package :iterate)

(iter

(for x in the-list)

(print x))</~~lang~~>

(print x))</syntaxhighlight>

=== Using DO ===

(let ((the-list '(1 7 "foo" 1 4))) ; Set the-list as the list

(do ((i the-list (rest i))) ; Initialize to the-list and set to rest on every loop

((null i)) ; Break condition

(print (first i)))) ; On every loop print list's first element

</syntaxhighlight>

<pre>

1

7

"foo"

1

4

</pre>

=={{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.

<~~lang~~ d>import std.stdio: writeln;

<syntaxhighlight lang="d">import std.stdio: writeln;

void main() {

Line 824:

Line 1,080:

foreach (key, value; collection3)

writeln(key, " ", value);

}</~~lang~~>

}</syntaxhighlight>

<pre>A

Line 840:

Line 1,096:

=={{header|Dao}}==

<~~lang~~ dao>items = { 1, 2, 3 }

<syntaxhighlight lang="dao">items = { 1, 2, 3 }

for( item in items ) io.writeln( item )</~~lang~~>

for( item in items ) io.writeln( item )</syntaxhighlight>

=={{header|Delphi}}==

Line 847:

Line 1,103:

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

<~~lang~~ ~~Delphi~~>program LoopForEach;

<syntaxhighlight lang="delphi">program LoopForEach;

{$APPTYPE CONSOLE}

Line 856:

Line 1,112:

for s in 'Hello' do

Writeln(s);

end.</~~lang~~>

end.</syntaxhighlight>

Output:

<pre>H

Line 865:

Line 1,121:

=={{header|Dragon}}==

<~~lang~~ dragon>

for (value : array) {

for value : array {

showln ~~array~~

showln value

}

</syntaxhighlight>

</lang>

=={{header|Dyalect}}==

<~~lang~~ ~~Dyalect~~>for i in [1,2,3] {

<syntaxhighlight lang="dyalect">for i in [1,2,3] {

print(i)

}</~~lang~~>

}</syntaxhighlight>

This code would work for any type that has a method "iter" (returning an iterator). In fact a runtime environment silently calls this method for you here and creates an iterator out of an array. The code above is absolutely identical to:

<~~lang~~ ~~Dyalect~~>for i in [1,2,3].~~iter~~() {

<syntaxhighlight lang="dyalect">for i in [1,2,3].Iterate() {

print(i)

}</~~lang~~>

}</syntaxhighlight>

This would perfectly work with any custom iterator as well:

<~~lang~~ ~~Dyalect~~>func myCollection() {

<syntaxhighlight lang="dyalect">func myCollection() {

yield 1

yield 2

Line 892:

Line 1,148:

for i in myCollection() {

print(i)

}</~~lang~~>

}</syntaxhighlight>

All three code samples would output:

Line 901:

Line 1,157:

=={{header|E}}==

<~~lang~~ e>for e in theCollection {

<syntaxhighlight lang="e">for e in theCollection {

println(e)

}</~~lang~~>

}</syntaxhighlight>

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

=={{header|EasyLang}}==

for i in [ 5 1 19 25 12 1 14 7 ]

print i

.

</syntaxhighlight>

=={{header|EchoLisp}}==

<~~lang~~ scheme>

(define my-list '( albert simon antoinette))

(for ((h my-list)) (write h))

Line 921:

Line 1,184:

;; etc ... for other collections like Streams, Hashes, Graphs, ...

</syntaxhighlight>

</lang>

=={{header|Ecstasy}}==

module LoopForEach {

@Inject Console console;

void run() {

val vals = [10, 20, 30, 40];

console.print("Array of values:");

Loop: for (val val : vals) {

console.print($" value #{Loop.count + 1}: {val}");

}

Map<String, Int> pairs = ["x"=42, "y"=69];

console.print("\nKeys and values:");

for ((String key, Int val) : pairs) {

console.print($" {key}={val}");

}

console.print("\nJust the keys:");

Loop: for (String key : pairs) {

console.print($" key #{Loop.count + 1}: {key}");

}

console.print("\nValues from a range:");

for (Int n : 1..5) {

console.print($" {n}");

}

</syntaxhighlight>

<pre>

Array of values:

value #1: 10

value #2: 20

value #3: 30

value #4: 40

Keys and values:

x=42

y=69

Just the keys:

key #1: x

key #2: y

Values from a range:

1

2

3

4

5

</pre>

=={{header|Ed}}==

Print all (newline-separated) lines in the file.

,p

</syntaxhighlight>

=={{header|Efene}}==

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

<~~lang~~ efene>io.format("~p~n", [Collection])</~~lang~~>

<syntaxhighlight lang="efene">io.format("~p~n", [Collection])</syntaxhighlight>

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.

<~~lang~~ efene>lists.foreach(fn (X) { io.format("~p~n", [X]) }, Collection)</~~lang~~>

<syntaxhighlight lang="efene">lists.foreach(fn (X) { io.format("~p~n", [X]) }, Collection)</syntaxhighlight>

=={{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>.

<~~lang~~ eiffel > across my_list as ic loop print (ic.item) end</~~lang~~>

<syntaxhighlight lang="eiffel "> across my_list as ic loop print (ic.item) end</syntaxhighlight>

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===

Line 938:

Line 1,262:

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

<~~lang~~ eiffel> across my_list as ic all ic.item.count > 3 end</~~lang~~>

<syntaxhighlight lang="eiffel"> across my_list as ic all ic.item.count > 3 end</syntaxhighlight>

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

<~~lang~~ eiffel> across my_list as ic some ic.item.count > 3 end</~~lang~~>

<syntaxhighlight lang="eiffel"> across my_list as ic some ic.item.count > 3 end</syntaxhighlight>

=={{header|Ela}}==

<~~lang~~ ela>open monad io

<syntaxhighlight lang="ela">open monad io

each [] = do return ()

each (x::xs) = do

putStrLn $ show x

each xs</~~lang~~>

each xs</syntaxhighlight>

=={{header|Elena}}==

ELENA 4.1 :

ELENA 6.x :

<~~lang~~ elena>import system'routines;

<syntaxhighlight lang="elena">import system'routines;

import extensions;

public program()

{

var things := new string[]~~::(~~"Apple", "Banana", "Coconut");

var things := new string[]{"Apple", "Banana", "Coconut"};

things.forEach:(thing)

things.forEach::(thing)

{

console.printLine:thing

console.printLine(thing)

}

}</~~lang~~>

}</syntaxhighlight>

=== Using foreach statement template ===

<syntaxhighlight lang="elena">import extensions;

public program()

{

var things := new string[]{"Apple", "Banana", "Coconut"};

foreach(var thing; in things)

{

console.printLine(thing)

}

}</syntaxhighlight>

=={{header|Elixir}}==

<~~lang~~ elixir>iex(1)> list = [1,3.14,"abc",[3],{0,5}]

<syntaxhighlight lang="elixir">iex(1)> list = [1,3.14,"abc",[3],{0,5}]

[1, 3.14, "abc", [3], {0, 5}]

iex(2)> Enum.each(list, fn x -> IO.inspect x end)

Line 974:

Line 1,311:

[3]

{0, 5}

:ok</~~lang~~>

:ok</syntaxhighlight>

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

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

<~~lang~~ ~~Lisp~~>(dolist (x '(1 2 3 4))

<syntaxhighlight lang="lisp">(dolist (x '(1 2 3 4))

(message "x=%d" x))</~~lang~~>

(message "x=%d" x))</syntaxhighlight>

or <code>mapc</code> function

<~~lang~~ ~~Lisp~~>(mapc (lambda (x)

<syntaxhighlight lang="lisp">(mapc (lambda (x)

(message "x=%d" x))

'(1 2 3 4))</~~lang~~>

'(1 2 3 4))</syntaxhighlight>

<code>dolist</code> and <code>mapc</code> are both builtin in current Emacs. For past Emacs both can be had from <code>cl.el</code> with for instance <code>(eval-when-compile (require 'cl))</code>.

<code>cl.el</code> also offers a <code>loop</code> macro similar in style to [[#Common Lisp|Common Lisp]].

<syntaxhighlight lang="lisp">(cl-loop for x in '(1 2 3 4) do (message "x=%d" x))</syntaxhighlight>

=={{header|Erlang}}==

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

<~~lang~~ erlang>io:format("~p~n",[Collection]).</~~lang~~>

<syntaxhighlight lang="erlang">io:format("~p~n",[Collection]).</syntaxhighlight>

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.

<~~lang~~ erlang>lists:foreach(fun(X) -> io:format("~p~n",[X]) end, Collection).</~~lang~~>

<syntaxhighlight lang="erlang">lists:foreach(fun(X) -> io:format("~p~n",[X]) end, Collection).</syntaxhighlight>

=={{header|ERRE}}==

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

<~~lang~~ ~~ERRE~~>

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

PRINT(INDEX$;" ";)

END FOR

PRINT

</syntaxhighlight>

</lang>

=={{header|Euphoria}}==

<lang>

include std/console.e

Line 1,036:

Line 1,371:

if getc(0) then end if

</syntaxhighlight>

</lang>

<pre>

Line 1,074:

Line 1,409:

2

</pre>

=={{header|F_Sharp|F#}}==

We can use ''for'' directly or list iteration.

<syntaxhighlight lang="fsharp">for i in [1 .. 10] do printfn "%d" i

List.iter (fun i -> printfn "%d" i) [1 .. 10]</syntaxhighlight>

=={{header|Factor}}==

<~~lang~~ factor>{ 1 2 4 } [ . ] each</~~lang~~>

=={{header|Fantom}}==

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

<~~lang~~ fantom>class Main

<syntaxhighlight lang="fantom">class Main

{

public static Void main ()

Line 1,090:

Line 1,431:

}

}</~~lang~~>

}</syntaxhighlight>

=={{header|~~friendly interactive shell~~}}==

=={{header|Fennel}}==

====sequential table====

Unlike, bash or csh, the PATH variable is automatically converted to real array.

<syntaxhighlight lang="fennel">(each [k v (ipairs [:apple :banana :orange])]

<lang fishshell>for path in $PATH

(print k v))</syntaxhighlight>

echo You have $path in PATH.

end</lang>

<pre>1 apple

2 banana

3 orange</pre>

====key-value table====

<syntaxhighlight lang="fennel">(each [k v (pairs {:apple :x :banana 4 :orange 3})]

(print k v))</syntaxhighlight>

<pre>apple x

banana 4

orange 3</pre>

=={{header|Forth}}==

<syntaxhighlight lang="forth">create a 3 , 2 , 1 ,

: .array ( a len -- )

cells bounds do i @ . cell +loop ; \ 3 2 1</syntaxhighlight>

===FOREACH===

The thing about extensible languages is if you need FOREACH, you can have FOREACH.

The Forth ' operator returns the "execution token" (XT) of a Forth word. An XT can be run with EXECUTE.

If we apply an appropriate XT to all the elements of an array we have it.

<syntaxhighlight lang="forth">: FOREACH ( array size XT --)

Sample output:

>R \ save execution token on return stack

<pre>

CELLS BOUNDS \ convert addr,len -> last,first addresses

You have /bin in PATH.

BEGIN

You have /usr/bin in PATH.

2DUP > \ test addresses

</pre>

WHILE ( last>first )

DUP R@ EXECUTE \ apply the execution token to the address

CELL+ \ move first to the next memory cell

REPEAT

R> DROP \ clean return stack

2DROP \ and data stack

;

\ Make an operator to fetch contents of an address and print

: ? ( addr --) @ . ;

CREATE A[] 9 , 8 , 7 , 6 , 5 , 4 , 3 , 2 , 1 , 0 ,

\ Usage example:

A[] 10 ' ? FOREACH </syntaxhighlight>

=={{header|Fortran}}==

<~~lang~~ fortran>program main

<syntaxhighlight lang="fortran">program main

implicit none

Line 1,120:

Line 1,494:

write(*,'(A)') colors

end program main</~~lang~~>

end program main</syntaxhighlight>

=={{header|~~Forth~~}}==

=={{header|friendly interactive shell}}==

Unlike, bash or csh, the PATH variable is automatically converted to real array.

<lang forth>create a 3 , 2 , 1 ,

<syntaxhighlight lang="fishshell">for path in $PATH

: .array ( a len -- )

echo You have $path in PATH.

cells bounds do i @ . cell +loop ; \ 3 2 1</lang>

end</syntaxhighlight>

Sample output:

<pre>

You have /bin in PATH.

You have /usr/bin in PATH.

</pre>

=={{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.

<~~lang~~ frink>

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

for n = array

println[n]

</syntaxhighlight>

</lang>

=={{header|~~F_Sharp|F#~~}}==

=={{header|FutureBasic}}==

We can use ''for'' directly or list iteration.

<lang fsharp>for i in [1 .. 10] do printfn "%d" i

window 1

List.iter (fun i -> printfn "%d" i) [1 .. 10]</lang>

void local fn DoIt

CFArrayRef array = @[@"Alpha",@"Bravo",@"Charlie",@"Delta",@"Echo",@"FutureBasic"]

CFStringRef string

for string in array

print string

fn DoIt

HandleEvents

</syntaxhighlight>

<pre>

Alpha

Bravo

Charlie

Delta

Echo

FutureBasic

</pre>

=={{header|GAP}}==

<~~lang~~ gap>for p in AlternatingGroup(4) do

<syntaxhighlight lang="gap">for p in AlternatingGroup(4) do

Print(p, "\n");

od;

Line 1,159:

Line 1,561:

(1,3,4)

(1,2)(3,4)

(1,4,2)</~~lang~~>

(1,4,2)</syntaxhighlight>

=={{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.

<~~lang~~ go>func printAll(values []int) {

<syntaxhighlight lang="go">func printAll(values []int) {

for i, x := range values {

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

}

}</~~lang~~>

}</syntaxhighlight>

=={{header|Groovy}}==

"for" loop:

<~~lang~~ groovy>def beatles = ["John", "Paul", "George", "Ringo"]

<syntaxhighlight lang="groovy">def beatles = ["John", "Paul", "George", "Ringo"]

for(name in beatles) {

println name

}</~~lang~~>

}</syntaxhighlight>

"each()" method:

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.

<~~lang~~ groovy>beatles.each {

<syntaxhighlight lang="groovy">beatles.each {

println it

}</~~lang~~>

}</syntaxhighlight>

Output (same for either):

<pre>John

Line 1,188:

Line 1,590:

=={{header|Halon}}==

<~~lang~~ halon>$things = ["Apple", "Banana", "Coconut"];

<syntaxhighlight lang="halon">$things = ["Apple", "Banana", "Coconut"];

foreach ($things as $thing) {

echo $thing;

}</~~lang~~>

}</syntaxhighlight>

=={{header|Haskell}}==

<~~lang~~ haskell>import Control.Monad (forM_)

<syntaxhighlight lang="haskell">import Control.Monad (forM_)

forM_ collect print</~~lang~~>

forM_ collect print</syntaxhighlight>

which is the same as

<lang haskell>mapM_ print collect</~~lang~~>

<syntaxhighlight lang="haskell">mapM_ print collect</syntaxhighlight>

=={{header|Haxe}}==

<~~haxe~~ lang>var a = [1, 2, 3, 4];

<syntaxhighlight lang="haxe">var a = [1, 2, 3, 4];

for (i in a)

Sys.println(i);</syntaxhighlight>

trace(i);

</lang>

=={{header|HicEst}}==

<~~lang~~ hicest>CHARACTER days="Monday Tuesday Wednesday Thursday Friday Saturday Sunday "

<syntaxhighlight lang="hicest">CHARACTER days="Monday Tuesday Wednesday Thursday Friday Saturday Sunday "

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

Line 1,214:

Line 1,615:

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

WRITE() today

ENDDO</~~lang~~>

ENDDO</syntaxhighlight>

=={{header|Hy}}==

<~~lang~~ clojure>(for [x collection] (print x))</~~lang~~>

<syntaxhighlight lang="clojure">(for [x collection] (print x))</syntaxhighlight>

=={{header|Io}}==

<lang io>collection foreach(println)</lang>

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

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

<~~lang~~ ~~Icon~~>procedure main()

<syntaxhighlight lang="icon">procedure main()

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

every x := !L do

write(x)

end</~~lang~~>

end</syntaxhighlight>

This loop can be written somewhat more concisely as:

<lang ~~Icon~~>every write(!L)</~~lang~~>

<syntaxhighlight lang="icon">every write(!L)</syntaxhighlight>

=={{header|Io}}==

<syntaxhighlight lang="io">collection foreach(println)</syntaxhighlight>

=={{header|J}}==

<syntaxhighlight lang="j"> echo every i.10

<lang J>smoutput each i.10</lang>

0

1

2

3

4

5

6

7

8

9</syntaxhighlight>

That said, J's <code>for.</code> provides a "foreach" mechanism.

<syntaxhighlight lang="J"> {{for_i. i. y do. echo i end.}}10

0

1

2

3

4

5

6

7

8

9

</syntaxhighlight>

=={{header|Java}}==

<~~lang~~ java>Iterable<Type> collect;

<syntaxhighlight lang="java">Iterable<Type> collect;

...

for(Type i:collect){

System.out.println(i);

}</~~lang~~>

}</syntaxhighlight>

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

<~~lang~~ java>

Iterable collect;

...

collect.forEach(o -> System.out.println(o));

</syntaxhighlight>

</lang>

This works with any Iterable, but not with arrays.

=={{header|JavaScript}}==

For arrays in ES5, we can use '''Array.forEach()''':

<syntaxhighlight lang="javascript">"alpha beta gamma delta".split(" ").forEach(function (x) {

<lang JavaScript>"alpha beta gamma delta".split(' ').forEach(

function (x) {

console.log(x);

});</syntaxhighlight>

}

);</lang>

Output:

<pre>alpha

beta

gamma

delta</pre>

though it will probably be more natural – dispensing with side-effects, and allowing for easier composition of nested functions – to simply use '''Array.map()''',

<syntaxhighlight lang="javascript">console.log("alpha beta gamma delta".split(" ").map(function (x) {

<lang JavaScript>console.log("alpha beta gamma delta".split(' ').map(

function (x) {

return x.toUpperCase(x);

}).join("\n"));</syntaxhighlight>

}

).join('\n'));</lang>

Output:

<pre>ALPHA

BETA

GAMMA

DELTA</pre>

or, more flexibly, and with greater generality, obtain an accumulating fold from '''Array.reduce()'''

<syntaxhighlight lang="javascript">console.log("alpha beta gamma delta".split(" ").reduce(function (a, x, i, lst) {

return lst.length - i + ". " + x + "\n" + a;

<lang JavaScript>console.log(

}, ""));</syntaxhighlight>

"alpha beta gamma delta".split(' ').reduce(

function (a, x, i, lst) {

return lst.length - i + '. ' + x + '\n' + a;

}, ''

)

)</lang>

Output:

<pre>1. delta

2. gamma

3. beta

4. alpha</pre>

More generally, the following works for any object, including an array. It iterates over the keys of an object.

<~~lang~~ ~~JavaScript~~>for (var a in o) {

<syntaxhighlight lang="javascript">for (var a in o) {

print(o[a]);

}</~~lang~~>

}</syntaxhighlight>

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:

<~~lang~~ ~~JavaScript~~>for (var a in o) {

<syntaxhighlight lang="javascript">for (var a in o) {

if (o.hasOwnProperty(a)) {

print(o[a]);

}

}</~~lang~~>

}</syntaxhighlight>

;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:

<~~lang~~ ~~JavaScript~~>h = {"one":1, "two":2, "three":3}

<syntaxhighlight lang="javascript">h = {"one":1, "two":2, "three":3}

for (x in h) print(x);

for each (y in h) print(y);</syntaxhighlight>

/*

two

one

three

*/

for each (y in h) print(y);

/*

2

1

3

*/</lang>

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:

<~~lang~~ ~~JavaScript~~>h = {"one":1, "two":2, "three":3}

<syntaxhighlight lang="javascript">h = {"one":1, "two":2, "three":3}

for (x in h) print(x);

for (y of h) print(y);</syntaxhighlight>

/*

two

one

three

*/

for (y of h) print(y);

/*

2

1

3

*/</lang>

=={{header|Jsish}}==

Jsi supports ''for of'' for looping over element of an array.

<lang javascript>for (str of "alpha beta gamma delta".split(' ')) { puts(str); }</lang>

<pre>alpha

beta

gamma

delta</pre>

=={{header|Julia}}==

<lang julia>for i in collection

println(i)

end</lang>

The Julia <code>for</code> statement is always a "foreach", and the built-in <code>start:end</code> or <code>start:step:end</code> "range" syntax can be used for iteration over arithmetic sequences. Many Julia objects support iteration: arrays and tuples iterate over each item, strings iterate over each character, dictionaries iterate over (key,value) pairs, numeric scalars provide a length-1 iteration over their value, and so on.

=={{header|jq}}==

'''Iterables''':

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

<~~lang~~ jq>def example: [1,2];</~~lang~~>

<syntaxhighlight lang="jq">def example: [1,2];</syntaxhighlight>

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:

<~~lang~~ jq>example | .[]

<syntaxhighlight lang="jq">example | .[]

# or equivalently: example[]</~~lang~~>

# or equivalently: example[]</syntaxhighlight>

<~~lang~~ jq>{"a":1, "b":2} | .[]

<syntaxhighlight lang="jq">{"a":1, "b":2} | .[]

# or equivalently: {"a":1, "b":2}[]</~~lang~~>

# or equivalently: {"a":1, "b":2}[]</syntaxhighlight>

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:

<~~lang~~ jq>example | . as $a | range(0; length) | $a[.]</~~lang~~>

<syntaxhighlight lang="jq">example | . as $a | range(0; length) | $a[.]</syntaxhighlight>

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

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

</syntaxhighlight>

</lang>

produces:

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

Line 1,389:

Line 1,739:

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

<~~lang~~ jq>"abc" | . as $s | range(0;length) | $s[.:.+1]

<syntaxhighlight lang="jq">"abc" | . as $s | range(0;length) | $s[.:.+1]

"abc" | explode | map( [.]|implode) | .[]</~~lang~~>

"abc" | explode | map( [.]|implode) | .[]</syntaxhighlight>

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

=={{header|Jsish}}==

Jsi supports ''for of'' for looping over element of an array.

<syntaxhighlight lang="javascript">for (str of "alpha beta gamma delta".split(' ')) { puts(str); }</syntaxhighlight>

<pre>alpha

beta

gamma

delta</pre>

=={{header|Julia}}==

<syntaxhighlight lang="julia">for i in collection

println(i)

end</syntaxhighlight>

The Julia <code>for</code> statement is always a "foreach", and the built-in <code>start:end</code> or <code>start:step:end</code> "range" syntax can be used for iteration over arithmetic sequences. Many Julia objects support iteration: arrays and tuples iterate over each item, strings iterate over each character, dictionaries iterate over (key,value) pairs, numeric scalars provide a length-1 iteration over their value, and so on.

=={{header|K}}==

=={{header|Klingphix}}==

<syntaxhighlight lang="klingphix">include ..\Utilitys.tlhy

( -2 "field" 3.14159 ( "this" "that" ) ) len [get ?] for

" " input</syntaxhighlight>

<pre>-2

field

3.14159

("this", "that")</pre>

=={{header|Kotlin}}==

<~~lang~~ scala>// version 1.0.6

<syntaxhighlight lang="scala">// version 1.0.6

fun main(args: Array<String>) {

Line 1,405:

Line 1,788:

greek.forEach { print("$it ") }

println()

}</~~lang~~>

}</syntaxhighlight>

Line 1,413:

Line 1,796:

</pre>

=={{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. {{VI solution|LabVIEW_Loops_Foreach.png}}

=={{header|~~Langur~~}}==

=={{header|Lambdatalk}}==

<lang Langur>for .i in [1, 2, 3] {

{def collection alpha beta gamma delta}

writeln .i

-> collection

{S.map {lambda {:i} {br}:i} {collection}}

->

alpha

beta

gamma

delta

or

{def S.foreach

{lambda {:s}

{if {S.empty? {S.rest :s}}

then {S.first :s}

else {S.first :s} {br}{S.foreach {S.rest :s}}}}}

{S.foreach {collection}}

->

alpha

beta

gamma

delta

</syntaxhighlight>

=={{header|Lang}}==

$collection = fn.arrayOf(1, 2, 3)

# Foreach loop [Works with iterable types (text, collections [array, list])]

$ele

foreach($[ele], $collection) {

fn.println($ele)

}

# Foreach function

for .i in "abc" {

# Array: fn.arrayForEach(&arr, func)

writeln .i

# List: fn.listForEach(&list, func)

fn.arrayForEach($collection, fn.println)

</syntaxhighlight>

=={{header|Lang5}}==

<syntaxhighlight lang="lang5">: >>say.(*) . ;

5 iota >>say.</syntaxhighlight>

=={{header|langur}}==

A for in loop iterates over values and a for of loop iterates over keys.

for i in [1, 2, 3] {

writeln i

}

~~for~~ .i in "abc" {

val abc = "abc"

writeln cp2s .i

for i in abc {

}</lang>

writeln i

}

for i of abc {

writeln abc[i]

}

for i in abc {

writeln cp2s(i)

}

</syntaxhighlight>

Line 1,431:

Line 1,875:

2

3

97

98

99

97

98

Line 1,437:

Line 1,884:

b

c</pre>

=={{header|Lasso}}==

<~~lang~~ ~~Lasso~~>array(1,2,3) => foreach { stdoutnl(#1) }</~~lang~~>

<syntaxhighlight lang="lasso">array(1,2,3) => foreach { stdoutnl(#1) }</syntaxhighlight>

<~~lang~~ ~~Lasso~~>with i in array(1,2,3) do { stdoutnl(#i) }</~~lang~~>

<syntaxhighlight lang="lasso">with i in array(1,2,3) do { stdoutnl(#i) }</syntaxhighlight>

=={{header|K}}==

=={{header|LDPL}}==

<syntaxhighlight lang="ldpl">data:

fruits is text list

fruit is text

procedure:

split "apple banana orange" by " " in fruits

for each fruit in fruits do

display fruit lf

repeat

</syntaxhighlight>

<pre>

apple

banana

orange

</pre>

=={{header|LFE}}==

<~~lang~~ lisp>(lists:foreach

<syntaxhighlight lang="lisp">(lists:foreach

(lambda (x)

(io:format "item: ~p~n" (list x)))

(lists:seq 1 10))

</syntaxhighlight>

</lang>

=={{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. {{VI solution|LabVIEW_Loops_Foreach.png}}

=={{header|Lang5}}==

<lang lang5>: >>say.(*) . ;

5 iota >>say.</lang>

=={{header|LIL}}==

<~~lang~~ tcl># Loops/Foreach, in LIL

<syntaxhighlight lang="tcl"># Loops/Foreach, in LIL

set collection [list 1 2 "three"]

append collection [list 4 5 six] # appended as a single item in collection

Line 1,474:

Line 1,927:

# each loop step quotes two copies of the item

set newlist [foreach j $collection {quote $j $j}]

print "Result of second foreach: $newlist"</~~lang~~>

print "Result of second foreach: $newlist"</syntaxhighlight>

Line 1,487:

Line 1,940:

=={{header|Lingo}}==

<~~lang~~ lingo>days = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]

<syntaxhighlight lang="lingo">days = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]

repeat with day in days

put day

end repeat</~~lang~~>

end repeat</syntaxhighlight>

A callback-based forEach() can be implemented like this:

<~~lang~~ lingo>----------------------------------------

<syntaxhighlight lang="lingo">----------------------------------------

-- One of the five native iterative methods defined in ECMAScript 5

-- @param {list} tList

Line 1,504:

Line 1,957:

call(cbFunc, cbObj, tList[i], i, tList)

end repeat

end</~~lang~~>

end</syntaxhighlight>

<~~lang~~ lingo>days = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]

<syntaxhighlight lang="lingo">days = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]

forEach(days, #alert, _player)</~~lang~~>

forEach(days, #alert, _player)</syntaxhighlight>

=={{header|Lisaac}}==

<~~lang~~ ~~Lisaac~~>"Lisaac loop foreach".split.foreach { word : STRING;

<syntaxhighlight lang="lisaac">"Lisaac loop foreach".split.foreach { word : STRING;

word.print;

'\n'.print;

};</~~lang~~>

};</syntaxhighlight>

=={{header|LiveCode}}==

Livecode's ''for each'' operates on chunks which may be words, items, lines, tokens. Example is for items.<~~lang~~ ~~LiveCode~~>repeat for each item x in "red, green, blue"

Livecode's ''for each'' operates on chunks which may be words, items, lines, tokens. Example is for items.<syntaxhighlight lang="livecode">repeat for each item x in "red, green, blue"

put x & cr

--wait 100 millisec -- req'd if you want to see in the LC Message Box (akin to repl)

end repeat</~~lang~~>

end repeat</syntaxhighlight>

=={{header|Logo}}==

<~~lang~~ logo>foreach [red green blue] [print ?]</~~lang~~>

<syntaxhighlight lang="logo">foreach [red green blue] [print ?]</syntaxhighlight>

=={{header|Lua}}==

Line 1,527:

Line 1,980:

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

<~~lang~~ lua>t={monday=1, tuesday=2, wednesday=3, thursday=4, friday=5, saturday=6, sunday=0, [7]="fooday"}

<syntaxhighlight lang="lua">t={monday=1, tuesday=2, wednesday=3, thursday=4, friday=5, saturday=6, sunday=0, [7]="fooday"}

for key, value in pairs(t) do

print(value, key)

end</~~lang~~>

end</syntaxhighlight>

Output:

<pre>

Line 1,544:

Line 1,997:

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

and is used to iterate over lists in order.

<~~lang~~ lua>l={'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday', not_a_number='fooday', [0]='today', [-1]='yesterday' }

<syntaxhighlight lang="lua">l={'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday', not_a_number='fooday', [0]='today', [-1]='yesterday' }

for key, value in ipairs(l) do

print(key, value)

end</~~lang~~>

end</syntaxhighlight>

Output:

<pre>

Line 1,563:

Line 2,016:

Iterators we have for Arrays, Inventories and Stacks (containers). Each(object Start to End), or Each(object 1 to -1) or Each(Object, 1,-1). We can use -2 for second from end item. We can use step inside while iterator {} using Iterator=Each(object, new_start, end_item). We can read cursor using ^. So Print k^, k2^, k1^ return positions (from 0 for inventories). We can use more than one iterators for an object.

Module Checkit {

\\ Inventories may have keys or keys/values

Line 1,591:

Line 2,044:

}

Checkit

</syntaxhighlight>

</lang>

=={{header|Maple}}==

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

print(p);

end do;

</syntaxhighlight>

</lang>

=={{header|Mathematica}}==

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Foreach over list of strings

<~~lang~~ mathematica>s = (StringSplit@Import["ExampleData/USConstitution.txt"])[[1;;7]];

<syntaxhighlight lang="mathematica">s = (StringSplit@Import["ExampleData/USConstitution.txt"])[[1;;7]];

Do[

Print@i,

{i, s}

]</~~lang~~>

]</syntaxhighlight>

Output:

<pre>We

Line 1,617:

Line 2,070:

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

<~~lang~~ ~~Matlab~~> list1 = [1,5,6,7,-7,-9];

<syntaxhighlight lang="matlab"> list1 = [1,5,6,7,-7,-9];

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

printf('%i\n',k)

end; </~~lang~~>

end; </syntaxhighlight>

<~~lang~~ ~~Matlab~~> list2 = {'AA','BB','CC'};

<syntaxhighlight lang="matlab"> list2 = {'AA','BB','CC'};

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

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

end; </~~lang~~>

end; </syntaxhighlight>

A vectorized version of the code is

<~~lang~~ ~~Matlab~~> printf('%d\n',list1);

<syntaxhighlight lang="matlab"> printf('%d\n',list1);

printf('%s\n',list2{:}); </~~lang~~>

printf('%s\n',list2{:}); </syntaxhighlight>

=={{header|Maxima}}==

<~~lang~~ maxima>for n in [2, 3, 5, 7] do print(n);</~~lang~~>

<syntaxhighlight lang="maxima">for n in [2, 3, 5, 7] do print(n);</syntaxhighlight>

=={{header|MAXScript}}==

<~~lang~~ maxscript>

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

makeuniquearray arr

Line 1,639:

Line 2,092:

for i in arr do print i as string

</syntaxhighlight>

</lang>

=={{header|Metafont}}==

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

<~~lang~~ metafont>for x = "mary", "had", "a", "little", "lamb": message x; endfor

<syntaxhighlight lang="metafont">for x = "mary", "had", "a", "little", "lamb": message x; endfor

end</~~lang~~>

end</syntaxhighlight>

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

<~~lang~~ metafont>for x = for i = 1 upto 9: a[i], endfor, a[10]: show x; endfor

<syntaxhighlight lang="metafont">for x = for i = 1 upto 9: a[i], endfor, a[10]: show x; endfor

end</~~lang~~>

end</syntaxhighlight>

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

=={{header|min}}==

<~~lang~~ min>(1 2 3) 'puts foreach</~~lang~~>

<syntaxhighlight lang="min">(1 2 3) 'puts foreach</syntaxhighlight>

=={{header|MiniScript}}==

<~~lang~~ ~~MiniScript~~>for i in collection

<syntaxhighlight lang="miniscript">for i in collection

print i

end</~~lang~~>

end</syntaxhighlight>

The MiniScript <code>for</code> statement is always a "foreach", and the standard <code>range</code> intrinsic can be used for iteration over arithmetic sequences. All MiniScript collection types support iteration: lists iterate over each item, strings iterate over each character, and maps/objects iterate over (key,value) pairs.

=={{header|MOO}}==

<~~lang~~ moo>things = {"Apple", "Banana", "Coconut"};

<syntaxhighlight lang="moo">things = {"Apple", "Banana", "Coconut"};

for thing in (things)

player:tell(thing);

endfor</~~lang~~>

endfor</syntaxhighlight>

=={{header|Nanoquery}}==

Like Python, Nanoquery supports for...in syntax for list types and strings.

<~~lang~~ ~~Nanoquery~~>for item in collection

<syntaxhighlight lang="nanoquery">for item in collection

println item

end</~~lang~~>

end</syntaxhighlight>

Some examples:

<~~lang~~ ~~Nanoquery~~>for n in {1,3,5,7,9}

<syntaxhighlight lang="nanoquery">for n in {1,3,5,7,9}

print n + " "

end

Line 1,682:

Line 2,135:

print char

end

println</~~lang~~>

println</syntaxhighlight>

<pre>1 3 5 7 9

Line 1,689:

Line 2,142:

=={{header|Nemerle}}==

This works on anything which implements the IEnumerable interface.

<~~lang~~ ~~Nemerle~~>def things = ["Apple", "Banana", "Coconut"];

<syntaxhighlight lang="nemerle">def things = ["Apple", "Banana", "Coconut"];

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

foreach (i in [5, 10 .. 100]) Write($"$i\t");</~~lang~~>

foreach (i in [5, 10 .. 100]) Write($"$i\t");</syntaxhighlight>

=={{header|NetRexx}}==

<~~lang~~ ~~NetRexx~~>/* NetRexx */

<syntaxhighlight lang="netrexx">/* NetRexx */

options replace format comments java crossref savelog symbols nobinary

Line 1,707:

Line 2,160:

loop while daysi.hasNext

say daysi.next

end</~~lang~~>

end</syntaxhighlight>

=={{header|NewLISP}}==

<~~lang~~ ~~NewLISP~~>(map println '(Apple Banana Coconut))</~~lang~~>

<syntaxhighlight lang="newlisp">(map println '(Apple Banana Coconut))</syntaxhighlight>

=={{header|Nim}}==

<syntaxhighlight lang="nim">let list = ["lorem", "ipsum", "dolor"]

<lang nim>var list: seq[string] = @[]

for item in list:

list.add("lorem")

echo item</syntaxhighlight>

list.add("ipsum")

list.add("dolor")

<pre>lorem

for i in items(list):

echo(i)</lang>

Output:

<pre>

lorem

ipsum

dolor

dolor</pre>

=={{header|Nu}}==

let l = [a b c d]

for x in $l {print $x}

</syntaxhighlight>

<pre>

a

b

c

d

</pre>

=={{header|Objeck}}==

<syntaxhighlight lang="objeck">fruits := ["Apple", "Banana", "Coconut"];

each(i : fruits) {

fruits[i]->PrintLine();

};</syntaxhighlight>

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

Line 1,730:

Line 2,196:

<~~lang~~ objc>NSArray *collect;

<syntaxhighlight lang="objc">NSArray *collect;

//...

// ...

for(Type i in collect){

for (Type i in collect) {

NSLog(@"%@", i);

}</~~lang~~>

}</syntaxhighlight>

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

Or (always using OpenStep compatible frameworks):

<~~lang~~ objc>NSArray *collect;

<syntaxhighlight lang="objc">NSArray *collect;

//...

// ...

NSEnumerator *enm = [collect objectEnumerator];

id i;

while( (i = [enm nextObject]) ) {

while ((i = [enm nextObject])) {

// do something with object i

}</~~lang~~>

}</syntaxhighlight>

=={{header|Objeck}}==

<lang objeck>fruits := ["Apple", "Banana", "Coconut"];

each(i : fruits) {

fruits[i]->PrintLine();

};</lang>

=={{header|OCaml}}==

List of integers:

<~~lang~~ ocaml>List.iter

<syntaxhighlight lang="ocaml">List.iter

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

collect_list</~~lang~~>

collect_list</syntaxhighlight>

Array of integers:

<~~lang~~ ocaml>Array.iter

<syntaxhighlight lang="ocaml">Array.iter

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

collect_array</~~lang~~>

collect_array</syntaxhighlight>

=={{header|Oforth}}==

<lang Oforth>: printMonths | m | Date.Months forEach: m [ m . ] ;</lang>

But, apply can be used instead of a loop :

<lang Oforth>#. Date.Months apply</lang>

=={{header|Octave}}==

<~~lang~~ octave>a = [ 1,4,3,2 ];

<syntaxhighlight lang="octave">a = [ 1,4,3,2 ];

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

for v = a

Line 1,778:

Line 2,231:

for v = b

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

endfor</~~lang~~>

endfor</syntaxhighlight>

We can also iterate over structures:

<~~lang~~ octave>x.a = [ 10, 11, 12 ];

<syntaxhighlight lang="octave">x.a = [ 10, 11, 12 ];

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

for [ val, key ] = x

disp(key);

disp(val);

endfor</~~lang~~>

endfor</syntaxhighlight>

=={{header|Oforth}}==

<syntaxhighlight lang="oforth">: printMonths | m | Date.Months forEach: m [ m . ] ;</syntaxhighlight>

But, apply can be used instead of a loop :

<syntaxhighlight lang="oforth">#. Date.Months apply</syntaxhighlight>

=={{header|Ol}}==

<~~lang~~ scheme>

(for-each print '(1 3 4 2))

(print)

Line 1,795:

Line 2,255:

'(5 6 7 8)

'(a b x z))

</syntaxhighlight>

</lang>

<pre>

Line 1,812:

Line 2,272:

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.

<~~lang~~ ~~ooRexx~~>/* Rexx */

<syntaxhighlight lang="oorexx">/* Rexx */

say

say 'Loops/Foreach'

Line 1,824:

Line 2,284:

say out~strip()

exit</~~lang~~>

exit</syntaxhighlight>

'''Output:'''

<pre>

Line 1,832:

Line 2,292:

=={{header|Oz}}==

<~~lang~~ oz>declare

<syntaxhighlight lang="oz">declare

MyList = [1 2 3 4]

in

Line 1,838:

Line 2,298:

%% or:

for E in MyList do {Show E} end</~~lang~~>

for E in MyList do {Show E} end</syntaxhighlight>

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

<~~lang~~ parigp>for(i=1,#v,print(v[i]))</~~lang~~>

<syntaxhighlight lang="parigp">for(i=1,#v,print(v[i]))</syntaxhighlight>

or (PARI/GP >= 2.4)

<~~lang~~ parigp>apply(x->print(x),v)</~~lang~~>

<syntaxhighlight lang="parigp">apply(x->print(x),v)</syntaxhighlight>

=={{header|Pascal}}==

See [[Loops/Foreach#Delphi | Delphi]]

=={{header|PascalABC.NET}}==

##

foreach var s in |'Pascal','ABC','.NET'| do

Print(s);

</syntaxhighlight>

=={{header|Perl}}==

<~~lang~~ perl>foreach my $i (@collection) {

<syntaxhighlight lang="perl">foreach my $i (@collection) {

print "$i\n";

}</~~lang~~>

}</syntaxhighlight>

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:

<~~lang~~ perl>print "$_\n" foreach @collection</~~lang~~>

<syntaxhighlight lang="perl">print "$_\n" foreach @collection</syntaxhighlight>

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

<~~lang~~ perl>foreach $l ( "apples", "bananas", "cherries" ) {

<syntaxhighlight lang="perl">foreach $l ( "apples", "bananas", "cherries" ) {

print "I like $l\n";

}</~~lang~~>

}</syntaxhighlight>

=={{header|Perl 6}}==

<lang perl6>say $_ for @collection;</lang>

Perl 6 leaves off the <tt>each</tt> from <tt>foreach</tt>, leaving us with <tt>for</tt> instead. The variable <tt>$_</tt> refers to the current element, unless you assign a name to it using <tt>-></tt>.

<lang perl6>for @collection -> $currentElement { say $currentElement; }</lang>

Perl 6 will do it's best to put the topic at the right spot.

<lang perl6>.say for @collection;

for @collection { .say };</lang>

Iteration can also be done with hyperoperators. In this case it's a candidate for autothreading and as such, execution order may vary. The resulting list will be in order.

<lang per6>@collection>>.say;

@collection>>.=&infix:<+>(2); # increment each element by 2</lang>

=={{header|Phix}}==

<lang Phix>sequence s = {-2,"field",3.14159268979,{"this","that"}}

sequence s = {-2,"field",3.14159268979,{"this","that"}}

for i=1 to length(s) do

for i=1 to length(s) do

?s[i]

?s[i]

end for</lang>

end for

=={{header|PHL}}==

<~~lang~~ phl>var numbers = 1..10;

<syntaxhighlight lang="phl">var numbers = 1..10;

numbers each # (number) [

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

];</~~lang~~>

];</syntaxhighlight>

=={{header|PHP}}==

<~~lang~~ php>foreach ($collect as $i) {

<syntaxhighlight lang="php">foreach ($collect as $i) {

echo "$i\n";

}

Line 1,897:

Line 2,354:

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

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

}</~~lang~~>

}</syntaxhighlight>

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

=={{header|PicoLisp}}==

<~~lang~~ ~~PicoLisp~~>(mapc println '(Apple Banana Coconut))</~~lang~~>

<syntaxhighlight lang="picolisp">(mapc println '(Apple Banana Coconut))</syntaxhighlight>

=={{header|Pike}}==

<~~lang~~ pike>int main(){

<syntaxhighlight lang="pike">int main(){

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

foreach(collect, int|string elem){

write(elem + "\n");

}

}</~~lang~~>

}</syntaxhighlight>

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

<~~lang~~ pike>int main(){

<syntaxhighlight lang="pike">int main(){

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

foreach (coll;string key;string val)

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

}

}</~~lang~~>

}</syntaxhighlight>

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

<~~lang~~ pli>declare A(10) fixed binary;

<syntaxhighlight lang="pli">declare A(10) fixed binary;

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

put skip list (A(i));

end;</~~lang~~>

end;</syntaxhighlight>

=={{header|Plain English}}==

<syntaxhighlight lang="plainenglish">To run:

Start up.

Create a list.

Write each entry in the list to the console.

Destroy the list.

Wait for the escape key.

Shut down.

An entry is a thing with a number.

A list is some entries.

To add a number to a list:

Allocate memory for an entry.

Put the number into the entry's number.

Append the entry to the list.

To create a list:

Add 1 to the list.

Add 2 to the list.

Add 3 to the list.

Add 6 to the list.

Add 7 to the list.

Add 9 to the list.

To write an entry to the console:

Convert the entry's number to a string.

Write the string to the console.

To write each entry in a list to the console:

Get an entry from the list.

Loop.

If the entry is nil, exit.

Write the entry to the console.

Put the entry's next into the entry.

Repeat.</syntaxhighlight>

<pre>

1

2

3

6

7

9

</pre>

=={{header|Pop11}}==

Iteration over list:

<~~lang~~ pop11>lvars el, lst = [1 2 3 4 foo bar];

<syntaxhighlight lang="pop11">lvars el, lst = [1 2 3 4 foo bar];

for el in lst do

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

endfor;</~~lang~~>

endfor;</syntaxhighlight>

=={{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:

<~~lang~~ postscript>[1 5 3 2] { = } forall

<syntaxhighlight lang="postscript">[1 5 3 2] { = } forall

(abc) { = } forall</~~lang~~>

(abc) { = } forall</syntaxhighlight>

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

<~~lang~~ postscript><</a 25 /b 42>> {

<syntaxhighlight lang="postscript"><</a 25 /b 42>> {

exch (Key: ) print

=

(Value: ) print

=

} forall</~~lang~~>

} forall</syntaxhighlight>

=={{header|PowerShell}}==

$colors = "Black","Blue","Cyan","Gray","Green","Magenta","Red","White","Yellow",

"DarkBlue","DarkCyan","DarkGray","DarkGreen","DarkMagenta","DarkRed","DarkYellow"

Line 1,952:

Line 2,456:

Write-Host "$color" -ForegroundColor $color

}

</syntaxhighlight>

</lang>

<pre>

Line 1,975:

Line 2,479:

=={{header|Prolog}}==

For example :

<~~lang~~ ~~Prolog~~>?- foreach(member(X, [red,green,blue,black,white]), writeln(X)).

<syntaxhighlight lang="prolog">?- foreach(member(X, [red,green,blue,black,white]), writeln(X)).

red

green

Line 1,982:

Line 2,486:

white

true.

</syntaxhighlight>

</lang>

=={{header|Python}}==

<~~lang~~ python>for i in collection:

<syntaxhighlight lang="python">for i in collection:

print i</~~lang~~>

print i</syntaxhighlight>

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:

<~~lang~~ python>lines = words = characters = 0

<syntaxhighlight lang="python">lines = words = characters = 0

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

for eachline in f:

Line 2,001:

Line 2,504:

characters += 1

print lines, words, characters</~~lang~~>

print lines, words, characters</syntaxhighlight>

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.

Line 2,007:

Line 2,510:

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:

<~~lang~~ python>d = {3: "Earth", 1: "Mercury", 4: "Mars", 2: "Venus"}

<syntaxhighlight lang="python">d = {3: "Earth", 1: "Mercury", 4: "Mars", 2: "Venus"}

for k in sorted(d):

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

Line 2,013:

Line 2,516:

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

for k in sorted(d):

print("%s: %s" % (k, d[k]))</~~lang~~>

print("%s: %s" % (k, d[k]))</syntaxhighlight>

<~~lang~~ python>d = {"fortytwo": 42, 3.14159: "pi", 23: "twentythree", "zero": 0, 13: "thirteen"}

<syntaxhighlight lang="python">d = {"fortytwo": 42, 3.14159: "pi", 23: "twentythree", "zero": 0, 13: "thirteen"}

for k in sorted(d):

print("%s: %s" % (k, d[k]))</~~lang~~>

print("%s: %s" % (k, d[k]))</syntaxhighlight>

=={{header|Quackery}}==

<syntaxhighlight lang="quackery">$ "Sweet Boom Pungent Prickle Orange" nest$

witheach [ i times sp echo$ cr ]</syntaxhighlight>

<pre> Sweet

Boom

Pungent

Prickle

Orange

</pre>

=={{header|R}}==

<~~lang~~ R>a <- list("First", "Second", "Third", 5, 6)

<syntaxhighlight lang="r">a <- list("First", "Second", "Third", 5, 6)

for(i in a) print(i)</~~lang~~>

for(i in a) print(i)</syntaxhighlight>

=={{header|Racket}}==

<~~lang~~ racket>

#lang racket

Line 2,036:

Line 2,551:

(for ([i sequence])

(displayln i))

</syntaxhighlight>

</lang>

=={{header|Raku}}==

(formerly Perl 6)

<syntaxhighlight lang="raku" line>say $_ for @collection;</syntaxhighlight>

Raku leaves off the <tt>each</tt> from <tt>foreach</tt>, leaving us with <tt>for</tt> instead. The variable <tt>$_</tt> refers to the current element, unless you assign a name to it using <tt>-></tt>.

<syntaxhighlight lang="raku" line>for @collection -> $currentElement { say $currentElement; }</syntaxhighlight>

Raku will do it's best to put the topic at the right spot.

<syntaxhighlight lang="raku" line>.say for @collection;

for @collection { .say };</syntaxhighlight>

Iteration can also be done with hyperoperators. In this case it's a candidate for autothreading and as such, execution order may vary. The resulting list will be in order.

<syntaxhighlight lang="raku" line>@collection>>.say;

@collection>>.=&infix:<+>(2); # increment each element by 2</syntaxhighlight>

=={{header|REBOL}}==

<~~lang~~ ~~REBOL~~>REBOL [

<syntaxhighlight lang="rebol">REBOL [

Title: "Loop/Foreach"

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

Line 2,051:

Line 2,579:

; the list from the current position.

forall x [prin rejoin [x/1 "day "]] print ""</~~lang~~>

forall x [prin rejoin [x/1 "day "]] print ""</syntaxhighlight>

Output:

<pre>Sorkday Gunday Bluesday Nedsday Thirstday Frightday Caturday

Line 2,057:

Line 2,585:

=={{header|Red}}==

<~~lang~~ ~~Red~~>>> blk: ["John" 23 "dave" 30 "bob" 20 "Jeff" 40]

<syntaxhighlight lang="red">>> blk: ["John" 23 "dave" 30 "bob" 20 "Jeff" 40]

>> foreach item blk [print item]

John

Line 2,081:

Line 2,609:

20 Jeff 40

Jeff 40

40</~~lang~~>

40</syntaxhighlight>

=={{header|ReScript}}==

<syntaxhighlight lang="rescript">let fruits = ["apple", "banana", "coconut"]

Js.Array2.forEach(fruits, f => Js.log(f))</syntaxhighlight>

=={{header|Retro}}==

Retro has '''for-each''' combinators for operating on elements of various data structures.

<~~lang~~ ~~Retro~~># Strings

<syntaxhighlight lang="retro"># Strings

This will display the ASCII code for each character in a string

Line 2,109:

Line 2,642:

&Dictionary [ d:name s:put sp ] d:for-each

~~~

</syntaxhighlight>

</lang>

=={{header|REXX}}==

<~~lang~~ rexx>days = 'zuntik montik dinstik mitvokh donershtik fraytik shabes'

<syntaxhighlight lang="rexx">days = 'zuntik montik dinstik mitvokh donershtik fraytik shabes'

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

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

end /*j*/

/*stick a fork in it, we're done.*/</~~lang~~>

/*stick a fork in it, we're done.*/</syntaxhighlight>

=={{header|Ring}}==

<~~lang~~ ring>

aList = "Welcome to the Ring Programming Language"

for n in aList

see n + nl

</syntaxhighlight>

</lang>

=={{header|RPL}}==

In RPL, « printing » a collection means sending it to the printer, if you have one. To just output the items of a list, you put them into the stack, like this:

≪ { "one" "two" "three" "four" "five" } LIST→ DROP ≫

If the idea is to do more than displaying the items, the usual way is a <code>FOR..NEXT</code> loop

≪ { "one" "two" "three" "four" "five" } → collection

≪ 1 collection SIZE '''FOR''' j

collection j GET

''(do something with the item here)''

'''NEXT'''

≫ ≫

=={{header|Ruby}}==

<~~lang~~ ruby>for i in collection do

<syntaxhighlight lang="ruby">for i in collection do

puts i

end</~~lang~~>

end</syntaxhighlight>

This is syntactic sugar for:

<~~lang~~ ruby>collection.each do |i|

<syntaxhighlight lang="ruby">collection.each do |i|

puts i

end</~~lang~~>

end</syntaxhighlight>

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.

<~~lang~~ rust>let collection = vec![1,2,3,4,5];

<syntaxhighlight lang="rust">let collection = vec![1,2,3,4,5];

for elem in collection {

println!("{}", elem);

}</~~lang~~>

}</syntaxhighlight>

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.

<~~lang~~ rust>let mut collection = vec![1,2,3,4,5];

<syntaxhighlight lang="rust">let mut collection = vec![1,2,3,4,5];

for mut_ref in &mut collection {

// alternatively:

Line 2,160:

Line 2,702:

// for immut_ref in collection.iter() {

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

}</~~lang~~>

}</syntaxhighlight>

Since Rust 1.21 foreach can be used explicitly executing a closure on each element.

<~~lang~~ rust>let collection = vec![1, 2, 3, 4, 5];

<syntaxhighlight lang="rust">let collection = vec![1, 2, 3, 4, 5];

collection.iter().for_each(|elem| println!("{}", elem));</~~lang~~>

collection.iter().for_each(|elem| println!("{}", elem));</syntaxhighlight>

=={{header|Salmon}}==

<~~lang~~ ~~Salmon~~>iterate (x; ["Red", "Green", "Blue"])

<syntaxhighlight lang="salmon">iterate (x; ["Red", "Green", "Blue"])

x!;</~~lang~~>

x!;</syntaxhighlight>

output:

<pre>

Line 2,177:

Line 2,719:

=={{header|SAS}}==

<~~lang~~ sas>/* Initialize an array with integers 1 to 10, and print their sum */

<syntaxhighlight lang="sas">/* Initialize an array with integers 1 to 10, and print their sum */

data _null_;

array a a1-a10;

Line 2,187:

Line 2,729:

s=sum(of a{*});

put s;

run;</~~lang~~>

run;</syntaxhighlight>

=={{header|Sather}}==

<~~lang~~ sather>class MAIN is

<syntaxhighlight lang="sather">class MAIN is

main is

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

Line 2,199:

Line 2,741:

end;

end;</~~lang~~>

end;</syntaxhighlight>

=={{header|Scala}}==

<~~lang~~ scala>val collection = Array(1, 2, 3, 4)

<syntaxhighlight lang="scala">val collection = Array(1, 2, 3, 4)

collection.foreach(println)</~~lang~~>

collection.foreach(println)</syntaxhighlight>

Alternatively:

<~~lang~~ scala>(element <- 1 to 4).foreach(println)</~~lang~~>

<syntaxhighlight lang="scala">(element <- 1 to 4).foreach(println)</syntaxhighlight>

=={{header|Scheme}}==

List:

<~~lang~~ scheme>(for-each

<syntaxhighlight lang="scheme">(for-each

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

the_list)</~~lang~~>

the_list)</syntaxhighlight>

=={{header|Scilab}}==

<lang>for e=["a","b","c"]

<syntaxhighlight lang="text">for e=["a","b","c"]

printf("%s\n",e)

end</~~lang~~>

end</syntaxhighlight>

<pre>a

Line 2,225:

Line 2,767:

=={{header|Seed7}}==

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

<~~lang~~ seed7>$ include "seed7_05.s7i";

<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";

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

Line 2,236:

Line 2,778:

writeln(thing);

end for;

end func;</~~lang~~>

end func;</syntaxhighlight>

=={{header|Self}}==

<~~lang~~ self>aCollection do: [| :element | element printLine ].</~~lang~~>

<syntaxhighlight lang="self">aCollection do: [| :element | element printLine ].</syntaxhighlight>

(Provided that the objects in the collection understand the <code>printLine</code> method).

=={{header|SETL}}==

<~~lang~~ setl>S := {1,2,3,5,8,13,21,34,55,89};

<syntaxhighlight lang="setl">S := {1,2,3,5,8,13,21,34,55,89};

for e in S loop

print(e);

end loop;</~~lang~~>

end loop;</syntaxhighlight>

=={{header|Sidef}}==

'''foreach''' loop:

<~~lang~~ ruby>foreach [1,2,3] { |i|

<syntaxhighlight lang="ruby">foreach [1,2,3] { |i|

say i

}</~~lang~~>

}</syntaxhighlight>

'''for-in''' loop:

<~~lang~~ ruby>for i in [1,2,3] {

<syntaxhighlight lang="ruby">for i in [1,2,3] {

say i

}</~~lang~~>

}</syntaxhighlight>

'''.each''' method:

<~~lang~~ ruby>[1,2,3].each { |i|

<syntaxhighlight lang="ruby">[1,2,3].each { |i|

say i

}</~~lang~~>

}</syntaxhighlight>

=={{header|Slate}}==

<~~lang~~ slate>c do: [| :obj | print: obj].</~~lang~~>

<syntaxhighlight lang="slate">c do: [| :obj | print: obj].</syntaxhighlight>

=={{header|Smalltalk}}==

<~~lang~~ smalltalk>aCollection do: [ :element | element displayNl ].</~~lang~~>

<syntaxhighlight lang="smalltalk">aCollection do: [ :element | element displayNl ].</syntaxhighlight>

(Provided that the objects in the collection understand the <code>displayNl</code> method).

Provided that the objects in the collection understand the <code>displayNl</code> method (which can be added, if missing).

Most modern Smalltalks allow for a selector symbol to be sent a <tt>value:</tt> message; which allows for the very compact:

<syntaxhighlight lang="smalltalk">aCollection do:#displayNl.</syntaxhighlight>

(and because Aikido mentions it: of course this works for any kind of collection (and even things which simply implement a <tt>do:</tt> method to iterate on something)

<syntaxhighlight lang="smalltalk">(1 to:6 by:2) do:#displayNl.

'hello' do:#displayNl.

(Integer primesUpTo:100) do:#displayNl.

'/' asFilename directoryContents do:#displayNl.

((Smalltalk allClasses collect:#name) asSortedCollection to:2) do:#displayNl.

funnyClassLessObject := Plug new

respondTo:#do:

with:[:arg |

arg value:'look ma'.

arg value:'no classes needed'].

funnyClassLessObject do:#displayNl.

etc.</syntaxhighlight>

1

3

5

h

e

l

o

2

3

5

...

97

home

usr

...

tmp

cores

AAAARecord

AATree

look ma

no classes needed

=={{header|Snabel}}==

Prints foo, bar & baz followed by newlines.

<~~lang~~ snabel>['foo' 'bar' 'baz'] &say for</~~lang~~>

=={{header|Sparkling}}==

Line 2,279:

Line 2,862:

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

<~~lang~~ sparkling>let hash = { "foo": 42, "bar": 1337, "baz": "qux" };

<syntaxhighlight lang="sparkling">let hash = { "foo": 42, "bar": 1337, "baz": "qux" };

foreach(hash, function(key, val) {

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

});</~~lang~~>

});</syntaxhighlight>

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

List of integers:

<~~lang~~ sml>app

<syntaxhighlight lang="sml">app

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

collect_list</~~lang~~>

collect_list</syntaxhighlight>

Array of integers:

<~~lang~~ sml>Array.app

<syntaxhighlight lang="sml">Array.app

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

collect_array</~~lang~~>

collect_array</syntaxhighlight>

=={{header|Stata}}==

<~~lang~~ stata>local a 2 9 4 7 5 3 6 1 8

<syntaxhighlight lang="stata">local a 2 9 4 7 5 3 6 1 8

foreach i in `a' {

display "`i'"

}</~~lang~~>

}</syntaxhighlight>

=={{header|Suneido}}==

<~~lang~~ ~~Suneido~~>for i in #(1, 2, 3)

<syntaxhighlight lang="suneido">for i in #(1, 2, 3)

Print(i)</~~lang~~>

Print(i)</syntaxhighlight>

=={{header|Swift}}==

<~~lang~~ swift>for i in [1,2,3] {

<syntaxhighlight lang="swift">for i in [1,2,3] {

print(i)

}</~~lang~~>

}</syntaxhighlight>

This works for any type that conforms to the <code>SequenceType</code> protocol (including arrays, collections, generators, ranges).

Alternately:

<~~lang~~ swift>[1,2,3].forEach {

<syntaxhighlight lang="swift">[1,2,3].forEach {

print($0)

}</~~lang~~>

}</syntaxhighlight>

=={{header|SystemVerilog}}==

<~~lang~~ ~~SystemVerilog~~>program main;

<syntaxhighlight lang="systemverilog">program main;

int values[$];

Line 2,325:

Line 2,909:

end

endprogram</~~lang~~>

endprogram</syntaxhighlight>

=={{header|Tailspin}}==

Stream them

['a', 'b', 'c'] ... -> !OUT::write

</syntaxhighlight>

Lists/arrays can be put through an array transform to get the index as well

['a', 'b', 'c'] -> \[i]('$i;:$;

' -> !OUT::write \) -> !VOID

</syntaxhighlight>

<pre>

1:a

2:b

3:c

</pre>

=={{header|Tcl}}==

<~~lang~~ tcl>foreach i {foo bar baz} {

<syntaxhighlight lang="tcl">foreach i {foo bar baz} {

puts "$i"

}</~~lang~~>

}</syntaxhighlight>

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

<~~lang~~ tcl>foreach {x y} {1 2 3 4} {

<syntaxhighlight lang="tcl">foreach {x y} {1 2 3 4} {

puts "$x,$y"

}</~~lang~~>

}</syntaxhighlight>

And also multiple lists:

<~~lang~~ tcl>foreach i {1 2 3} j {a b c} {

<syntaxhighlight lang="tcl">foreach i {1 2 3} j {a b c} {

puts "$i,$j"

}</~~lang~~>

}</syntaxhighlight>

Or any combination of variables/list:

<~~lang~~ tcl>foreach i {1 2 3} {x y} {a b c d e f} {

<syntaxhighlight lang="tcl">foreach i {1 2 3} {x y} {a b c d e f} {

puts "$i,$x,$y"

}</~~lang~~>

}</syntaxhighlight>

=={{header|Trith}}==

<~~lang~~ trith>[1 2 3 4 5] [print] each</~~lang~~>

<syntaxhighlight lang="trith">[1 2 3 4 5] [print] each</syntaxhighlight>

=={{header|TUSCRIPT}}==

<~~lang~~ tuscript>$$ MODE TUSCRIPT

<syntaxhighlight lang="tuscript">$$ MODE TUSCRIPT

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

LOOP day=week

PRINT day

ENDLOOP</~~lang~~>

ENDLOOP</syntaxhighlight>

Output:

<pre>

Line 2,368:

Line 2,971:

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

<~~lang~~ bash>for file in *.sh; do

<syntaxhighlight lang="bash">for file in *.sh; do

echo "filename is $file"

done</~~lang~~>

done</syntaxhighlight>

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

<~~lang~~ bash>PATH=/usr/bin:/bin:/usr/sbin:/sbin:/usr/X11R6/bin:/usr/local/bin

<syntaxhighlight lang="bash">PATH=/usr/bin:/bin:/usr/sbin:/sbin:/usr/X11R6/bin:/usr/local/bin

oldifs=$IFS

Line 2,380:

Line 2,983:

echo search $dir

done

IFS=$oldifs</~~lang~~>

IFS=$oldifs</syntaxhighlight>

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

<~~lang~~ bash>collection=("first" "second" "third" "fourth" "something else")

<syntaxhighlight lang="bash">collection=("first" "second" "third" "fourth" "something else")

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

echo "$x"

done</~~lang~~>

done</syntaxhighlight>

<~~lang~~ bash>set -A collection "first" "second" "third" "fourth" "something else"

<syntaxhighlight lang="bash">set -A collection "first" "second" "third" "fourth" "something else"

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

echo "$x"

done</~~lang~~>

done</syntaxhighlight>

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

<~~lang~~ csh>set collection=(first second third fourth "something else")

<syntaxhighlight lang="csh">set collection=(first second third fourth "something else")

foreach x ($collection:q)

echo $x:q

end</~~lang~~>

end</syntaxhighlight>

=={{header|V}}==

<~~lang~~ v>[1 2 3] [puts] step</~~lang~~>

=={{header|Vala}}==

<~~lang~~ vala>List<string> things = new List<string> ();

<syntaxhighlight lang="vala">List<string> things = new List<string> ();

things.append("Apple");

things.append("Banana");

Line 2,411:

Line 3,014:

{

stdout.printf("%s\n", thing);

}</~~lang~~>

}</syntaxhighlight>

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

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

<~~lang~~ vim>for i in ["alpha", "beta", 42, 5.54]

<syntaxhighlight lang="vim">for i in ["alpha", "beta", 42, 5.54]

echo i

endfor</~~lang~~>

endfor</syntaxhighlight>

=={{header|V (Vlang)}}==

<syntaxhighlight lang="v (vlang)">fn print_all(values []int) {

for i, x in values {

println("Item $i = $x")

}

}</syntaxhighlight>

=={{header|Wart}}==

<~~lang~~ wart>each x '(1 2 3)

<syntaxhighlight lang="wart">each x '(1 2 3)

prn x</~~lang~~>

prn x</syntaxhighlight>

=={{header|WDTE}}==

<~~lang~~ ~~WDTE~~>let a => import 'arrays';

<syntaxhighlight lang="wdte">let a => import 'arrays';

let s => import 'stream';

Line 2,431:

Line 3,042:

-> s.map (io.writeln io.stdout)

-> s.drain

;</~~lang~~>

;</syntaxhighlight>

=={{header|Wren}}==

<syntaxhighlight lang="wren">for (f in ["apples", "oranges", "pears"]) System.print(f)</syntaxhighlight>

<pre>

apples

oranges

pears

</pre>

=={{header|XLISP}}==

XLISP's <tt>FOR-EACH</tt> applies a procedure to each member of a list in turn.

<~~lang~~ lisp>(FOR-EACH PRINT '(CYRUS CAMBYSES DARIUS XERXES ARTAXERXES))</~~lang~~>

<syntaxhighlight lang="lisp">(FOR-EACH PRINT '(CYRUS CAMBYSES DARIUS XERXES ARTAXERXES))</syntaxhighlight>

<pre>CYRUS

Line 2,445:

Line 3,066:

=={{header|XPL0}}==

Translation of C example:

<~~lang~~ ~~XPL0~~>include c:\cxpl\codes;

<syntaxhighlight lang="xpl0">include c:\cxpl\codes;

int List, I;

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

for I:= 0, 5-1 do

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

]</~~lang~~>

]</syntaxhighlight>

=={{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.

<~~lang~~ xml><fo:block font-weight="bold">Adults:</fo:block>

<syntaxhighlight lang="xml"><fo:block font-weight="bold">Adults:</fo:block>

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

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

</xsl:for-each></~~lang~~>

</xsl:for-each></syntaxhighlight>

=={{header|zig}}==

<~~lang~~ zig>const warn = @import("std").debug.warn;

<syntaxhighlight lang="zig">const warn = @import("std").debug.warn;

pub fn main() void {

const items = []i16{ 0, 1, 1, 2, 3, 5, 8 };

const items = [_]i16{ 0, 1, 1, 2, 3, 5, 8 };

for (items) |i| {

warn("{}\n", i);

warn("{}\n", .{i});

}

}</lang>

</syntaxhighlight>

=={{header|zkl}}==

<~~lang~~ zkl>foreach c in (T("Red","Green","Blue","Black","White"))

<syntaxhighlight lang="zkl">foreach c in (T("Red","Green","Blue","Black","White"))

{ print(c," "); }</~~lang~~>

{ print(c," "); }</syntaxhighlight>

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

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

<~~lang~~ zkl>foreach x,y,z in (T(T(1,2,3), T(4,5,6))) { println(x,y,z) }

<syntaxhighlight lang="zkl">foreach x,y,z in (T(T(1,2,3), T(4,5,6))) { println(x,y,z) }

foreach x,y,z in (T(1,2,3), T(4,5), T(6)){ println(x,y,z) }</~~lang~~>

foreach x,y,z in (T(1,2,3), T(4,5), T(6)){ println(x,y,z) }</syntaxhighlight>

<pre>

Line 2,492:

Line 3,114:

356

</pre>

=={{header|Zig}}==

<syntaxhighlight lang="zig">const std = @import("std");

pub fn main() !void {

const stdout_wr = std.io.getStdOut().writer();

// 1. Index element index sizes are comptime-known

const a1: []const u8 = &[_]u8{ 'a', 'b', 'c' };

// also works with slices

//const a2: [] u8 = &a1;

for (a1) |el_a|

try stdout_wr.print("{c}\n", .{el_a});

// 2. Index element index sizes are not comptime-known

// Convention is to provide a `next()` method.

// TODO

}</syntaxhighlight>