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