for (int i = 0; i < len; i++)

foreach (i in 0..3) // выдает последовательность 0, 1, 2, 3

foreach (i in 0..array.Length - 1) // не нравится этот "- 1"

foreach (i in 0...3) // то есть добавляется третья точка.

for i := 0 to 3 step 1 do

foreach (x where 0 >= x < 10 step 1) // "step 1" необязательный параметр позволяющий задать шаг отличный от еденицы

foreach (x from 0 to x < 10)

VD>foreach (x where 0 >= x < 10 step 1) // "step 1" необязательный параметр позволяющий задать шаг отличный от еденицы
VD>

foreach (x = 0 where x < 10 step 1) // "step 1" необязательный параметр позволяющий задать шаг отличный от еденицы

for (int i = 0; i < len; i++)

for (int i = 0; i < len; ++i)

foreach (int i in 0..3) выдаёт 0 1 2

foreach (int i in 0..array.Length) перебирает все элементы массива

либо

foreach (int i in 0 to 3) выдаёт 0 1 2
foreach (int i in 0 to array.Length) перебирает все элементы массива

либо

foreach (int i in 0 upto 3) выдаёт 0 1 2
foreach (int i in 0 downto 3) выдаёт 2 1 0 мелочь, а приятно

foreach (int i in 0 upto array.Length) перебирает все элементы массива
foreach (int i in 0 downto array.Length) перебирает все элементы массива в обратном порядке

причём foreach (int i in 0 upto 3) и foreach (int i in 3 downto 0) равнозначны

for (int i = 0; i < array.Length; i++)
    array[i] = f(array[i]);

foraech (i in IndexesOf(array))
  array[i] = f(array[i]);

ConvertElements(array, f);

foreach(i in [0,3]) // 0,1,2,3
foreach(i in [0,3[) // 0,1,2
foreach(i in ]0,3]) //   1,2,3
foreach(i in ]0,3[) //   1,2

foreach (x in array)
{
}

foreach (i in [0, array.Length); ++i) // i = 0..(array.Length-1)
{
}

foreach (i in [1, array.Length]; ++i) // i = 1..array.Length
{
}

foreach (0 <= i < array.Length; ++i) // i = 0..(array.Length-1)
{
}

var arr = [3,4,5,6,7,8];

for( var n in arr ) {....}
for( var n in arr[2..4] ) {....}

(dolist (var list-form)
  body-form*)

(dotimes (var count-form)
  body-form*)

  (map 'vector #'* #(1 2 3 4 5) #(10 9 8 7 6)) ==> #(10 18 24 28 30)

  (reduce #'+ #(1 2 3 4 5 6 7 8 9 10)) ==> 55

12.times { say 'hello' }          // _1 принимает значения от 0 до 11
(2..16).times { say 'hello '_1 }  // _1 принимает значения от 2 до 16
(10+.5).times { say 'hello '_1 }  // _1 принимает значения от 5 до 14 (то есть 10 различных значений)

action 5+i.10  // порождает список значений (action 5), (action 6), ..., (action 14)

LCR>12.times { say 'hello' }          // _1 принимает значения от 0 до 11
LCR>(2..16).times { say 'hello '_1 }  // _1 принимает значения от 2 до 16
LCR>(10+.5).times { say 'hello '_1 }  // _1 принимает значения от 5 до 14 (то есть 10 различных значений)
LCR>

(2..16) (x) { say 'hello 'x }  // _1 принимает значения от 2 до 16
(10+.5) (y) { say 'hello 'y }  // _1 принимает значения от 5 до 14 (то есть 10 различных значений)

IT>(2..16) (x) { say 'hello 'x }  // _1 принимает значения от 2 до 16
IT>(10+.5) (y) { say 'hello 'y }  // _1 принимает значения от 5 до 14 (то есть 10 различных значений)

(x, y)~(#10, 0..9): {say 'hello 'x','y}

LCR>>12.times { say 'hello' }          // _1 принимает значения от 0 до 11

aCollection do: [ :element | "do something with element" ].

aCollection do: [ :element | element blink ].

aCollection do: [ :element | anObject doSomethingWith: element ].

aNumber1 to: aNumber2 do: [ :number | "do something with number" ].

(aNumber1 to: aNumber2) do: [ :number | "do something with number" ].

1 to: 10 do: [ :i | anObject doSomethingWith: i ].

aNumber1 to: aNumber2 by: aNumber3 do: [ :number | "do something with number" ].

(aNumber1 to: aNumber2 by: aNumber3) do: [ :number | "do something with number" ].

1 to: 10 by: 3 do: [ :i | anObject doSomethingWith: i ].

anObject doSomethingWith: 1.
anObject doSomethingWith: 4.
anObject doSomethingWith: 8.

1.4 to: 13.3 by: 4.7 do: [ :i | anObject doSomethingWith: i ].

anObject doSomethingWith: 1.4.
anObject doSomethingWith: 6.1.
anObject doSomethingWith: 10.8.

public class Range : IEnumerable<int>
{
    private int _low;
    private int _high;
    public IEnumerator<int> GetEnumerator()
    {
        for (int i = _low; i <= _high; i++)
            yield return i;
    }

    #region Construction
    public Range(int low, int high)
    {
        _low = low;
        _high = high;
    }
    public static Range Indexes<T>(T[] array)
    {
        return new Range(0, array.Length - 1);
    }

    #endregion

    #region IEnumerable Members

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    #endregion
}

int[] a = new int[5];
foreach(int i in Range.Indexes(a)) // нет выбора между Length/Length-1
  Console.Write(i);

foreach(int i in new Range(0, 10))
  Console.Write(i);

1.1.4 stable rev. 510

[1 .. 3]        // от 1-го до 3-х включительно
[1 .. 10; 2] // шаг 2

[0 .. 10, 20 .. 30; 5] = {0, 5, 10, 20, 25, 30}

public delegate T NextIndexGenerator<T>(T current); // позволить использовать формулу для вычисления следующего члена ряда 
                                                    // исходя из значения предыдущего

[1 .. 1024; @current*2] = {1, 2, 4, 8, ..., 1024}

[0.1 .. 0.9, Math.Sqrt] = {0.1, 0.316, ..., 0.8999 } // ряд, сходящщийся к 1.0 по формуле next = sqrt(current);

[0..array.Length),

[1 .. before 1024; @current*4]

for(i from 0 to 10 step 2) // закрытый диапазон слева и справа

for(i from 0 before 10 step 5) // открытый диапазон

int[] arr = new int[10];

for(i before arr.Length) 
    arr[i]=i*i;

PD>Господа, а не кажется ли Вам, что для того, чтобы сравнивать нынешний программный продукт по числу LOC c тем, что писали 10 лет назад, надо для нынешнего продукта автоматически применять понижающий коэффициент, равный так примерно 10 ?

(+/ % #) list

int n = list.size();
double sum = 0;
for (int i = 0; i < n; i++)
    sum += list[i];
return sum/n;

sum = reduce(float.__add__, list, 0.0)

LCR>Я так полагаю, это Питончик? Да, там кстати считалось среднее

return Nemerle.Collections.List.FoldLeft(lisT, 0, fun(a,b) {a+b}) / x.Length

[0..array.Length),

int[] a = new int[] {1, 2, 3, 4};
int sum = 0;
foreach(int item in a)
  sum += item;

int[] a = new int[] {1, 2, 3, 4};
int weightedSum = 0;
foreach(int i in a.Indexes)
  weightedSum += i*a[i];

V>но боюсь, случайная опечатка в парных скобочках будет пересекаться с семантикой, что не есть гут. Может быть будут еще идеи как указать открытый диапазон? А может быть ввести некое ключевое слово, типа before:

1.1.4 stable rev. 510

foreach (i in (0, 4, 7)) // выдает последовательность 0, 4, 7
foreach (i in (0, 4..7+)) // выдает последовательность 0, 4, 5, 6, 7
foreach (i in (0, 4..7-, 12..14+)) // выдает последовательность 0, 4, 5, 6, 12, 13, 14

    macro @foreachIn (inexpr, body)
    syntax ("foreachIn", "(", inexpr, ")", body)
    {
        def intervalExecute(pat, intervalExpr, body)
        {
            match (intervalExpr)
            {
                | <[ $first .. $last ]> => 
                    <[
                        mutable i = $first;
                        def last = $last;
                        while (i <= last) 
                        {
                            def $pat = i;
                            $body;
                            i++;
                        }
                    ]>
                | <[ $single ]> => 
                    <[
                        def $pat = $single;
                        $body;
                    ]>
                | _ => throw Exception("foreachIn Usage: foreachIn(i[2..5, 7..10])");
            }
        }

        match (inexpr) 
        {
            | <[ $pat $[$single] ]>
            | <[ $pat [$single] ]> =>
                intervalExecute(pat, single, body)
            | <[ $pat $[..$list] ]>
            | <[ $pat [..$list] ]> =>
                {
                    def m(intervalExpr) { intervalExecute(pat, intervalExpr, body) }
                    mutable s = [];
                    foreach (i in list)
                        s =  m(i) :: s;
                    <[ { .. $(s.Reverse()) } ]>;
                }
            | _ => throw Exception("foreachIn Usage: foreachIn(i[2..5, 7..10])");
        }
    }

    def p = 6;
    def q = 9;
    foreachIn (i[2..4, p..q, 11, 13..15])
        printf("%d\n", i);

VD>foreach (i in 0...3) // то есть добавляется третья точка.

foreach (i in 0..<3)

VD>foreach (i in 0..array.Length - 1) // не нравится этот "- 1"
VD>

  for I := Low(A) to High(A) do;

  for I := 0 to A.Limit do;

  for i = A
    ...
  end

  for i = 1:10
    ...
  end

  for i = 1:10:-1
    ...
  end

  for i = A
    print(i)
  end

  for i = A.Range
    A(i) = 0.0
  end

foreach (i in 0 .. 3) // 0, 1, 2, 3

foreach (i in 0 ..< 3) // 0, 1, 2

foreach (i in 0 <.. 3) // 1, 2, 3

foreach (i in 0 <..< 3) // 1, 2

list.FoldLeft(0, _ + _) / x.Length

LCR>12.times { say 'hello' }          // _1 принимает значения от 0 до 11
LCR>(2..16).times { say 'hello '_1 }  // _1 принимает значения от 2 до 16
LCR>(10+.5).times { say 'hello '_1 }  // _1 принимает значения от 5 до 14 (то есть 10 различных значений)
LCR>

irb(main):013:0> 5.times { |i| puts "- #{i} -" }
- 0 -
- 1 -
- 2 -
- 3 -
- 4 -
=> 5
irb(main):014:0> (2..4).each { |i| puts "= #{i} =" }
= 2 =
= 3 =
= 4 =
=> 2..4
irb(main):015:0> (2...4).each { |i| puts "= #{i} =" }
= 2 =
= 3 =
=> 2...4
irb(main):016:0>

string[] strs = new {"a", "b", "c"};
on (strs each string str)
    Console.WriteLine(str);

string[] strs = new {"a", "b", "c"};
on (strs each string str with index)
    Console.WriteLine(strs[index]);

VD>foreach (i in 0...3) // то есть добавляется третья точка.
VD>

[1, 2, 3, 4].each { |item| ... }

10.times { |n| ... }

1.upto(10) { ... } # от 1 до 10.
10.downto(1) { ... } # от 10 до 1.
(1..10).each { ... } # от 1 до 10.
(1...10).each { ... } # от 1 до 9

Вы можете использовать for для итерации по любому объекту, который отвечает на метод each, например Array или Range:

for i in ['fee', 'fi', 'fo', 'fum']
  print i, " "
end
for i in 1..3
  print i, " "
end
for i in File.open("ordinal").find_all { |l| l =~ /d$/}
  print i.chomp, " "
end

выводит:

fee fi fo fum 1 2 3 second third

Как только ваш класс определяет соответствующий метод each, вы можете использовать цикл for для его обхода

class Periods
  def each
    yield "Classical"
    yield "Jazz"
    yield "Rock"
  end
end

periods = Periods.new
for genre in periods
  print genre, " "
end

выводит:

Classical Jazz Rock

I>foreach (i in 0 .. 3) // 0, 1, 2, 3
I>

I>foreach (i in 0 ..< 3) // 0, 1, 2
I>

I>foreach (i in 0 <.. 3) // 1, 2, 3
I>

I>foreach (i in 0 <..< 3) // 1, 2
I>

foreach (0 = i = 3) // 0, 1, 2, 3

foreach (0 = i < 3) // 0, 1, 2

foreach (0 < i = 3) // 1, 2, 3

foreach (0 < i < 3) // 1, 2

for(int i=0; i<arguments.length; i+=2)
{
    map[arguments[i]] = arguments[i+1];
}
for(Node *parent = theNode; parent; parent = parent->getParent())
{
}
for(Range r(collection); r; ++r)
{
  cout << *r;
}
char *list[] = {"aaa", "bbb", "ccc", NULL};
for(char **elem = list; *elem; ++elem)
{
}

//Синтаксис типа этого будет совершенно не в тему. А преимущества какие?
foreach( int i=[0..arguments.length) )
{
   cout << arguments[i];
}
// Ещё можно оправдать такой синтаксис, тем, что выкидывается неиспользуемое здесь понятие "индекс"/"итератор", 
используется только "коллекция" и её "элемент коллекции".
foreach int arg(arguments)
{
   cout << arg;
}

A>foreach (0 = i < 3) // 0, 1, 2

foreach (0 <= i < 3) // 0, 1, 2

foreach (i in offset + delta * (m..n))

foreach (offset + delta * m <= i <= offset + delta * n)

#! python

for x in range(   3) : print x  # 0 1 2
for x in range(3, 7) : print x  #       3 4 5 6
for x in range(7,10) : print x  #               7 8 9

VD>foreach (i in 0..array.Length - 1) // не нравится этот "- 1"
VD>

-- Haskell

-- так:
take array.Length [0..]
-- или так:
[i | i <- [0..], i < array.Length]

foreach (i in 0..array.Length - 1) // не нравится этот "- 1"

S>Предполагается набор перегруженных конструкторов для указания step. Предполагается наличие свойства Reverse для обращения обхода. Предполагается наличие операций пересечения/объединения интервалов. Велком

macro IndexesOf(collection) 
{ 
   // In real code one needs to do check type of collection and make specialized code 
   <[ $$[0..collection.Length - 1] ]> 
}

foreach (i in IndexesOf(myArray)) 
  ...

foreach (i in myarr.Indexes)
  ...

Кё>Совершенно верно, питон Но можно и другие языки:

Кё>return Nemerle.Collections.List.FoldLeft(lisT, 0, fun(a,b) {a+b}) / x.Length
Кё>

lisT.FoldLeft(0, _ + _) . lisT.Length

E>5.times { |i| puts "- #{i} -" }

E>>5.times { |i| puts "- #{i} -" }
LCR>

LCR>Здорово! Я теперь понял, откуда у меня такие фантазии

5.times { puts "---" }

foreach (i in 0...3)

foreach (i in 0..3) // выдает последовательность 0, 1, 2, 3

foreach (i in 0 .. 3) // 0, 1, 2, 3

foreach (i in 0 .. <3) // 0, 1, 2

foreach (i in 0< .. 3) // 1, 2, 3

foreach (i in 0< .. <3) // 1, 2

S>int[] a = new int[] {1, 2, 3, 4};
S>int weightedSum = 0;
S>foreach(int i in a.Indexes)
S>  weightedSum += i*a[i];
S>

#как-то так, да
weightedSum = 0
a.each_with_index {|obj, i| weightedSum += i * obj}

перебор(x, [0, 10))
{
}

S>int[] a = new int[] {1, 2, 3, 4};
S>int weightedSum = 0;
S>foreach(int i in a.Indexes)
S>  weightedSum += i*a[i];
S>

struct SomeStruct { 
    public double a, b, c, d, e, f; 
}

...

SomeStruct[] s = new SomeStruct[100];
for(int i = 0; i<s.Length; i++)
    Fill(s[i]);
    
...

public void Fill(ref SomeStruct item) {}

foreach(ref item in s)
    Fill(item);

f(x)
{
....
}

foreach( array, f );

Ключевое слово foreach служит просто синонимом ключевого слова for, поэтому for и foreach можно использовать взаимозаменяемо и в зависимости от того, которое из них выглядит более удобочитаемым в конкретной ситуации.

i@len // for (int i = 0; i < len; i++)
i@len@2 // for (int i = 0; i < len; i+=2)
i@@len // for (int i = 0; i <= len; i++)
i@(len+1) // for (int i = 0; i <= len; i++)

v@x // foreach(v in x)
 print v

for(var iter=init(); cond(iter); next(iter))
{
    use(*iter);
}
foreach var elem(collection)
{
    use(elem);
}

foreach(@a)

как должен выглядить идеальный синтаксис перебора значений из диапазона