# Comparison of programming languages (list comprehension)

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.

## Examples of list comprehension
### Boo

List with all the doubles from 0 to 10 (exclusive)
List with the names of the customers based in Rio de Janeiro

### C#

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

### Ceylon

Filtering numbers divisible by 3:
Multiple "generators":

### Clojure

An infinite lazy sequence:
A list comprehension using multiple generators:

### Common Lisp

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

### Cobra

List the names of customers:
List the customers with balances:
List the names of customers with balances:
The general forms:
Note that by putting the condition and expression after the variable name and enumerable object, editors and IDEs can provide autocompletion on the members of the variable.

### Erlang
### F#

Lazily-evaluated sequences:
Or, for floating point values
Lists and arrays:
List comprehensions are the part of a greater family of language constructs called computation expressions.

### Haskell

An example of a list comprehension using multiple generators:

### Io

By using Range object, Io language can create list as easy as in other languages:

### ISLISP

List comprehensions can be expressed with the for special form. Conditionals are expressed with if, as follows:

### Julia

Julia supports comprehensions using the syntax:
and multidimensional comprehensions like:
It is also possible to add a condition:
And just changing square brackets to the round one, we get a generator:

### Mythryl

Multiple generators:

### Nim

Nim has built-in seq, set, table and object comprehensions on the sugar standard library module:
The comprehension is implemented as a macro that is expanded at compile time, you can see the expanded code using the expandMacro compiler option:
The comprehensions can be nested and multi-line:

### OCaml

OCaml supports List comprehension through OCaml Batteries.

### Perl

Array with all the doubles from 1 to 9 inclusive:
Array with the names of the customers based in Rio de Janeiro (from array of hashes):
Filtering numbers divisible by 3:

### PowerShell

which is short-hand notation of:

### Python

Python uses the following syntax to express list comprehensions over finite lists:
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:
(Subsequent use of the generator expression will determine when to stop generating values).

### Racket

An example with multiple generators:

### Scala

Using the for-comprehension:

### Scheme

List comprehensions are supported in Scheme through the use of the SRFI-42 library.
An example of a list comprehension using multiple generators: