• Obj-C

for (id x in items) _doSomething(x);

• Ada

for Item of Items loop
   Do_Something (Item);
end loop;

• C

for (size_t i = 0; i < sizeof(items) / sizeof(items[0]); i++) {
	DoSomethingWith(&items[i]);
}

• C

for (unsigned int i = 0 ; i < items_length ; ++i){
        Item* x = &(items[i]);
	DoSomethingWith(x);
}

• Caml

items |> List.iter do_something

• Clojure

(map do-something items)

• Cobol

IDENTIFICATION DIVISION.
PROGRAM-ID. list.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 LIST.
   03 X OCCURS 5 TIMES
        INDEXED BY i PIC 9.
PROCEDURE  DIVISION.       
    PERFORM VARYING i FROM 1  BY 1 UNTIL i > 5
        DISPLAY X(i)
    END-PERFORM    
STOP RUN.

• C++

for(const auto &x : items) {
	doSomething(x);
}

• C#

foreach (var x in items)
{
    DoSomething(x);
}

• D

items.each!(a => writeln(a))();

• D

foreach(x; items) {
	doSomethingWith(x);
}

• Dart

items.forEach(doSomething);

• Elixir

Enum.each(items, &IO.inspect/1)

• Elixir

for x <- items do
  IO.inspect(x)
end

• Erlang

[do_something(X) || X <- Items]

• Erlang

lists:foreach(fun do_something/1, Items).

• Fortran

elemental subroutine foo(x)
  real, intent(in) :: x
end subroutine foo

call foo(x)

• Go

for _, x := range items {
    doSomething(x)
}

• Groovy

items.each { x -> doSomething(x) }

• Groovy

for(x in items) doSomething(x)

• Groovy

items.each { doSomething(it) }

• Haskell

forM_ items doSomething

• JS

items.forEach(doSomething)

• JS

items.map(doSomething)

• JS

for (var i = 0; i<items.length; i++) {
  var x = items[i];
  doSomething(x);
}

• JS

items.forEach((x) => {
    doSomething(x);
});

• JS

for (const x of items) {
	doSomething(x);
}

• Java

for (T x : items) {}

• Java

for(int i=0;i<items.length;i++){
	doSomething( items[i] );
}

• Java

items.stream().forEach(item -> doSomething(item));

• Java

T t;
Iterator<T> i = items.listIterator();
while (i.hasNext()) {
    t = i.next();
}

• Java

for (Item x: items) {
    doSomething(x);
}

• Java

T t;
Iterator<T> i = items.iterator();
while (i.hasNext()) {
    t = i.next();
}

• Kotlin

items.forEach { doSomething(it) }

• Kotlin

items.forEach(::doSomething)

• Kotlin

for (x in items) doSomething(x)

• Lisp

(map nil #'something items)

• Lua

for _, x in ipairs(items) do
	print(x)
end

• PHP

array_map(func, $items);

• PHP

foreach ($items as $x){
    doSomething( $x );
}

• Pascal

for x in items do ;

• Perl

do_something($_) for @items;

• Perl

for my $x (@items) {
     do_something($x);
     more_stuffs($x);
}

• Python

f = lambda x: ...
for x in items: f(x)

• Python

[do_something(x) for x in items]

• Python

for x in items:
        doSomething( x )

• Ruby

items.each do |x|
  do_something( x )
end

• Ruby

items.each{|x| do_something( x )}

• Rust

items.into_iter().for_each(|x| do_something(x));

• Rust

for x in items {
	do_something(x);
}

• Scala

for {
  x <- items
} doSomething(x)

• Scala

items.foreach(doSomething)

• Scala

items.foreach{doSomething(_)}

• Scheme

(map doSomething items)

• Scheme

(define (sum a b)
 (sum-iter a b 0))

(define (sum-iter index n sum)
   (if (= n index)
    (+ sum index) 
    (+  (sum-iter  n (+ index 1) (+ sum index)))
 )

• Scheme

(define (doSomething x)
    (if (not (null? x))
        (begin 
            (display "Item=")
            (display (car x))
            (newline)
            (doSomething (cdr x)))))

• Smalltalk

items do: [:x | x doSomething]

• VB

For Each x In items
    DoSomething(x)
Next