= For Expression =

The '''for''' expression enables looping in expressions and results in a list with the results.

{{{
for <var> in <ienumerable> [where <condition>] get <expr>
for <var> in <ienumerable> where <condition>
for <var> in <start-expr> : stop-expr [: <step-expr> [where <condition>] get <expr> 
}}}

The '''var''' may be declared in the expression or it can be a preexisting variable. The '''ienumerable''' is any expression that implements the '''IEnumerable''' interface (Collections, arrays, streams,...). [[BR]]
The '''condition''' is optional and is used to filter the list. [[BR]]
Finally, the expr is evaluated for each individual item resulting in the elements of the final list.

The '''get <expr>''' part can be excluded in the presence of '''where''' in which case it is assumed to be '''get <var>'''.[[BR]]
i.e return the item from the ienumerable.

Both '''ienumerable''' and the resulting list may be empty.

The resulting list is always newly created. The type of the list is '''List<of T>''' where T is the type of '''expr'''. There is no requirement that the type of expr be the same as the type of what the '''ienumerable''' contains.

The last variant specifying start and stop steps is to generate a list containing a range of numbers similarly to a numeric for loop. All the expressions here must evaluate to an IEnumerable range (integers usually). Unlike a for-loop the '''start-expr''' must be given. '''The stop-expr''' is the value at which generation stops, this value is not returned to the list (so its a one-past the end/sentinel ). The '''step-expr''' is the step between items the sequence progresses in - if not given it defaults to 1.

If the '''for''' expression is part of a more complex expression—especially if it is the beginning of one—then put parenthesis around it to prevent the get <expr> portion of the grammar from consuming the rest of the complex expression. See below for an example.

There is also a statement version of the for loop. (EnumerableForStatement and NumericFor)

{{{
#!cobra
# Example 1 
t = for x in [1, 2, 3] get x*x 
# type of `x` is int, type of `t` is List<of int>
assert t.count==3 
assert t[0]==1 
assert t[1]==4 
assert t[2]==9 

# Example 2: Explicit variable typing 
names = for name as String in provider.names get name.toLower 

# Example 3: Grouping with parens 
assert (for s in ['aa', 'bbbb', 'cccccc'] get s.length) == [2, 4, 6] 
# not needed in this case: 
assert [2, 4, 6] == for s in ['aa', 'bbbb', 'cccccc'] get s.length 

# Example 3: with `where` 
names = for name in names where name.trim.length get name.trim 

# Example 4: `get x` is implied 
t = for x in numbers where x > 0 

#Example 5: numeric ranged list 
range = for i in 0 : 10 get i*i
assert range.count == 10
assert range[0] ==0
assert range[9] == 81
}}}

Python calls this construct a 'List comprehension'.