Comparison of programming languages (list comprehension)

Programming language comparisons
General comparison
Basic syntax
Basic instructions
Arrays
Associative arrays
String operations
String functions
List comprehension
Object-oriented programming
Object-oriented constructors
Database access
Database RDBMS
Evaluation strategy
List of "hello world" programs
ALGOL 58's influence on ALGOL 60
ALGOL 60: Comparisons with other languages
Comparison of ALGOL 68 and C++
ALGOL 68: Comparisons with other languages
Compatibility of C and C++
Comparison of Pascal and Borland Delphi
Comparison of Object Pascal and C
Comparison of Pascal and C
Comparison of Java and C++
Comparison of C# and Java
Comparison of C# and Visual Basic .NET
This box: view · talk · edit

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

Further information: Boo for .NET/Mono

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#

Further information: C# 3.0 Language Integrated Query

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

Further information: 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

Further information: 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))

Cobra

Further information: Cobra

List the names of customers:

names = for cust in customers get cust.name

List the customers with balances:

names = for cust in customers where cust.balance > 0

List the names of customers with balances:

names = for cust in customers where cust.balance > 0 get cust.name

The general forms:

for VAR in ENUMERABLE [where CONDITION] get EXPR
for VAR in ENUMERABLE where CONDITION

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

Further information: Erlang

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

F#

Further information: F#

seq { for x in 0 .. 100 do if x*x > 3 then yield 2*x }

Or, more correctly for floating point values

seq { for x in 0.0 .. 100.0 do if x**2.0 > 3.0 then yield 2.0*x }

Groovy

Further information: Groovy

(0..100).findAll{ x -> x * x > 3 }.collect { x -> 2 * x }

Haskell

Further information: Haskell

[x * 2 | x <- [0 .. 99], x * x > 3]

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

Further information: 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.

Mythryl

Further information: Mythryl

 s = [ 2*i for i in 1..100 where i*i > 3 ];

Multiple generators:

 pyth = [ (x,y,z) for x in 1..20 for y in x..20 for z in y..20 where x*x + y*y == z*z ];

Nemerle

Further information: Nemerle

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

Objective Caml

Further information: Objective Caml

OCaml supports List comprehension through OCaml Batteries. ^[2]

Perl 6

Further information: Perl 6

my @s = ($_ * 2 if $_ ** 2 > 3 for 0 .. 99);

Python

Further information: Python syntax and semantics: Generators

Python uses the following syntax to express 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

Further information: R

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

Racket

Further information: Racket

(for/list ([x (in-range 100)] #:when (> (* x x) 3)) (* x 2))

An example with multiple generators:

(for*/list ([x (in-range 1 21)] [y (in-range 1 21)] [z (in-range 1 21)]
            #:when (= (+ (* x x) (* y y)) (* z z)))
  (list x y z))

Scala

Further information: Scala

Using the for-comprehension:

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

Scheme

Further information: Scheme

List comprehensions are supported in Scheme through the use of the SRFI-42 library.^[3]

(list-ec (: x 100) (if (> (* x x) 3)) (* x 2))

An example of a list comprehension using multiple generators:

(list-ec (: x 1 21) (: y x 21) (: z y 21) (if (= (+ (* x x) (* y y)) (* z z))) (list x y z))

Smalltalk

((1 to: 100) select: [ x | x squared > 3 ]) collect: [ x | x * 2 ]

Visual Prolog

Further information: Visual Prolog

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

Windows PowerShell

Further information: Windows PowerShell

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

References

1. ^ New in JavaScript 1.7, Mozilla Developer Center
2. ^ | OCaml Batteries Included
3. ^ Scheme SRFI 42: Eager Comprehensions