# Comparison of programming languages (list comprehension)

Programming Language Comparison
series.
General Comparison
Basic Syntax
Basic Instructions
Arrays
Associative arrays
String Operations
String Functions
List comprehension
Object-oriented programming
Object-oriented constructors
Database access

Evaluation strategy
List of "hello world" programs

Comparison of ALGOL 68 and C++
Compatibility of C and C++
Comparison of Pascal and Borland Delphi
Comparison of Pascal and C
Comparison of Java and C++
Comparison of Java and C#
Comparison of C# and Visual Basic .NET
Comparison of ABAP and Java

[hide] [hide]

## List Comprehensions

List comprehension is a syntactic construct available in some programming languages for creating a list based on existing lists. It follows the form of the mathematical set-builder notation (set comprehension.) as distinct from the use of map and filter functions.

### Boo

List with all the doubles from 0 to 10 (exclusive)

```doubles = [i*2 for i in range(10)]
```

List with the names of the customers based on Rio de Janeiro

```rjCustomers = [customer.Name for customer in customers if customer.State == "RJ"]
```

### C#

```var ns = from x in Enumerable.Range(0,100)
where x*x > 3
select x*2;
```

The previous code is syntactic sugar for the following code written using lambda expressions:

```var ns = Enumerable.Range(0, 100)
.Where(x => x*x > 3)
.Select(x => x*2);
```

### Clojure

An infinite lazy sequence:

```(for [x (iterate inc 0) :when (> (* x x) 3)] (* 2 x))
```

A list comprehension using multiple generators:

```(for [x (range 20), y (range 20), z (range 20) :when (== (+ (* x x) (* y y)) (* z z))] [x y z])
```

### Common Lisp

List comprehensions can be expressed with the `loop` macro's `collect` keyword. Conditionals are expressed with `if`, as follows:

```(loop for x from 0 to 100 if (> (* x x) 3) collect (* 2 x))
```

### Erlang

```L = lists:seq(0,100).
S = [2*X || X <- L, X*X > 3].
```

### F#

```{ for x in 0 .. 100 when x*x > 3 -> 2*x }
```

Or, more correctly for floating point values

```{ for x in 0.0 .. 100.0 when x**2.0 > 3.0 -> 2.0*x }
```

An example of a list comprehension using multiple generators:

```pyth = [(x,y,z) | x <- [1..20], y <- [x..20], z <- [y..20], x^2 + y^2 == z^2]
```

### JavaScript

Borrowing from Python, JavaScript 1.7 and later have array comprehensions.[1] Although this feature has been proposed for inclusion in the fourth edition ECMAScript standard, Mozilla is the only implementation that currently supports it.

```/* There is no "range" function in JavaScript's standard
library, so the application must provide it. */
function range(n) {
for (var i = 0; i < n; i++)
yield i;
}

[2 * x for (x in range(100)) if (x * x > 3)]
```

JavaScript 1.8 adds Python-like generator expressions.

### Nemerle

```\$[x*2 | x in [0 .. 100], x*x > 3]
```

### Perl

List comprehensions are supported in Perl through the use of the List::Comprehensions CPAN module.[2]

### Python

The Python programming language uses the following syntax for expressing list comprehensions over finite lists:

```S = [2*x for x in range(100) if x**2 > 3]
```

A generator expression may be used in Python versions >= 2.4 which gives lazy evaluation over its input, and can be used with generators to iterate over 'infinite' input such as the count generator function which returns successive integers:

```from itertools import count
S = (2*x for x in count() if x**2 > 3)
```

(Subsequent use of the generator expression will determine when to stop generating values).

### R

```x = (0:100)
S = 2 * x[x ^ 2 > 3]
```

### Scala

Using the for-comprehension:

```val s = for (x <- Stream.from(0); if x*x > 3) yield 2*x
```

### Visual Prolog

```S = [ 2*X || X = list::getMember_nd(L), X*X > 3 ]
```

### Windows PowerShell

```\$s = ( 0..100 | ? {\$_*\$_ -gt 3} | % {2*\$_} )
```