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