Comparison of programming languages (list comprehension)

<h2 id="examples-of-list-comprehension">Examples of list comprehension</h2>
<h3>Boo</h3>
<p class="note">Further information: <a href="/facts/Boo_(programming_language)/CB2lRUwl">Boo</a> for <a href="/facts/.NET/PDMQdfFu">.NET</a>–<a href="/facts/Mono_(software)/PlyeJxRS">Mono</a></p>
<p>List with all the doubles from 0 to 10 (exclusive)
</p>
doubles = [i*2 for i in range(10)]

<p>List with the names of the customers based in <a href="/facts/Rio_de_Janeiro/AVPTJJ2C">Rio de Janeiro</a>
</p>
rjCustomers = [customer.Name for customer in customers if customer.State == "RJ"]

<h3>C#</h3>
<p class="note">Further information: <a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C# 3.0 Language Integrated Query</a></p>
var ns = from x in Enumerable.Range(0, 100)
         where x * x > 3
         select x * 2;

<p>The previous code is <a href="/facts/Syntactic_sugar/FYkNSdTI">syntactic sugar</a> for the following code written using lambda expressions:
</p>
var ns = Enumerable.Range(0, 100)
        .Where(x => x * x > 3)
        .Select(x => x * 2);

<h3>Ceylon</h3>
<p class="note">Further information: <a href="/facts/Ceylon_(programming_language)/cygDphIa">Ceylon</a>, <a href="https://ceylon-lang.org/documentation/current/tour/comprehensions/">Ceylon comprehensions</a></p>
<p>Filtering numbers divisible by 3:
</p>
value divisibleBy3 = { for (i in 0..100) if (i%3==0) i };
// type of divisibleBy3 is Iterable<Integer>

<p>Multiple "generators":
</p>
value triples = { for (x in 0..20) for (y in x..20) for (z in y..20) if (x*x + y*y == z*z) [x,y,z] };
// type of triples is Iterable<Integer[3]>

<h3>Clojure</h3>
<p class="note">Further information: <a href="/facts/List_comprehension/aYAax9k0">List comprehension § Clojure</a></p>
<p>An infinite lazy sequence:
</p>
 (for [x (iterate inc 0) 
       :when (> (* x x) 3)]
   (* 2 x))

<p>A list comprehension using multiple generators:
</p>
 (for [x (range 20)
       y (range 20)
       z (range 20)
       :when (== (+ (* x x) (* y y)) (* z z))]
   [x y z])

<h3>CoffeeScript</h3>
<p class="note">Further information: <a href="/facts/CoffeeScript/S8U53Pxy">CoffeeScript</a></p>
largeNumbers = (number for number in list when number > 100)

<h3>Common Lisp</h3>
<p class="note">Further information: <a href="/facts/Common_Lisp/mq1pRbSF">Common Lisp</a></p>
<p>List comprehensions can be expressed with the loop macro's collect keyword. Conditionals are expressed with if, as follows:
</p>
(loop for x from 0 to 100 if (> (* x x) 3) collect (* 2 x))

<h3>Cobra</h3>
<p class="note">Further information: <a href="/facts/Cobra_(programming_language)/KoaKnA5c">Cobra</a></p>
<p>List the names of customers:
</p>
names = for cust in customers get cust.name

<p>List the customers with balances:
</p>
names = for cust in customers where cust.balance > 0

<p>List the names of customers with balances:
</p>
names = for cust in customers where cust.balance > 0 get cust.name

<p>The general forms:
</p>
for VAR in ENUMERABLE [where CONDITION] get EXPR
for VAR in ENUMERABLE where CONDITION

<p>Note that by putting the condition and expression <i>after</i> the variable name and enumerable object, editors and IDEs can provide <a href="/facts/Autocompletion/eLNAGYlS">autocompletion</a> on the members of the variable.
</p>
<h3>Dart</h3>
<p class="note">Further information: <a href="/facts/Dart_(programming_language)/xJ8tE6Tl">Dart</a>, <a href="https://dart.dev/guides/language/language-tour#lists">Dart lists</a></p>
[for (var i in range(0, 100)) if (i * i > 3) i * 2]

var pyth = [
  for (var x in range(1, 20))
    for (var y in range(x, 20))
      for (var z in range(y, 20)) if (x * x + y * y == z * z) [x, y, z]
];

Iterable<int> range(int start, int end) =>
    List.generate(end - start, (i) => start + i);

<h3>Elixir</h3>
<p class="note">Further information: <a href="/facts/Elixir_(programming_language)/vX1J3cgf">Elixir</a></p>
for x <- 0..100, x * x > 3, do: x * 2

<h3>Erlang</h3>
<p class="note">Further information: <a href="/facts/Erlang_(programming_language)/2PuxmzT3">Erlang</a></p>
L = lists:seq(0,100).
S = [2*X || X <- L, X*X > 3].

<h3>F#</h3>
<p class="note">Further information: <a href="/facts/F_Sharp_(programming_language)/jdXHnYz5">F#</a></p>
<p>Lazily-evaluated sequences:
</p>
seq { for x in 0 .. 100 do if x*x > 3 then yield 2*x }

<p>Or, for floating point values
</p>
seq { for x in 0. .. 100. do if x**2. > 3. then yield 2.*x }

<p>Lists and arrays:
</p>
[ for x in 0. .. 100. do if x**2. > 3. then yield 2.*x ]
[| for x in 0. .. 100. do if x**2. > 3. then yield 2.*x |]

<p>List comprehensions are the part of a greater family of language constructs called computation expressions.
</p>
<h3>Haskell</h3>
<p class="note">Further information: <a href="/facts/Haskell/ydEsHuGy">Haskell</a></p>
[x * 2 | x <- [0 .. 99], x * x > 3]

<p>An example of a list comprehension using multiple generators:
</p>
pyth = [(x,y,z) | x <- [1..20], y <- [x..20], z <- [y..20], x^2 + y^2 == z^2]

<h3>Io</h3>
<p class="note">Further information: <a href="/facts/Io_(programming_language)/06xtsq15">Io</a></p>
<p>By using Range object, Io language can create list as easy as in other languages:
</p>
Range 0 to(100) asList select(x, x*x>3) map(*2)

<h3>ISLISP</h3>
<p class="note">Further information: <a href="/facts/ISLISP/4qnw7Nyn">ISLISP</a></p>
<p>List comprehensions can be expressed with the for special form. Conditionals are expressed with if, as follows:
</p>
(for ((x 0 (+ x 1))
      (collect ()))
     ((>= x 100) (reverse collect))
     (if (> (* x x) 3)
         (setq collect (cons (* x 2) collect))))

<h3>Julia</h3>
<p class="note">Further information: <a href="/facts/Julia_(programming_language)/AoB0PJ9C">Julia</a></p>
<p>Julia supports comprehensions using the syntax:
</p>
 y = [x^2+1 for x in 1:10]

<p>and multidimensional comprehensions like:
</p>
 z = [(x-5)^2+(y-5)^2 for x = 0:10, y = 0:10]

<p>It is also possible to add a condition:
</p>
v = [3x^2 + 2y^2 for x in 1:7 for y in 1:7 if x % y == 0]

<p>And just changing square brackets to the round one, we get a generator:
</p>
g = (3x^2 + 2y^2 for x in 1:7 for y in 1:7 if x % y == 0)

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

<p>Multiple generators:
</p>
 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 ];

<h3>Nemerle</h3>
<p class="note">Further information: <a href="/facts/Nemerle/6E2y4sHK">Nemerle</a></p>
$[x*2 | x in [0 .. 100], x*x > 3]

<h3>Nim</h3>
<p><a href="/facts/Nim_(programming_language)/KBmz14Ek">Nim</a> has built-in seq, set, table and object comprehensions on the sugar standard library module:<a class="footnote-ref" id="fnref:1" href="#fn:1"><sup>1</sup></a>
</p>
import sugar

let variable = collect(newSeq):
  for item in @[-9, 1, 42, 0, -1, 9]: item + 1

assert variable == @[-8, 2, 43, 1, 0, 10]

<p>The comprehension is implemented as a macro that is expanded at compile time, 
you can see the expanded code using the expandMacro compiler option:
</p>
var collectResult = newSeq(Natural(0))
for item in items(@[-9, 1, 42, 0, -1, 9]):
  add(collectResult, item + 1)
collectResult

<p>The comprehensions can be nested and multi-line:
</p>
import sugar

let values = collect(newSeq):
  for val in [1, 2]:
    collect(newSeq):
      for val2 in [3, 4]:
        if (val, val2) != (1, 2):
          (val, val2)
        
assert values == @[@[(1, 3), (1, 4)], @[(2, 3), (2, 4)]]

<h3>OCaml</h3>
<p class="note">Further information: <a href="/facts/OCaml/ThBGLND8">OCaml</a></p>
<p><i>OCaml supports List comprehension through OCaml Batteries</i>.<a class="footnote-ref" id="fnref:2" href="#fn:2"><sup>2</sup></a>
</p>
<h3>Perl</h3>
<p class="note">Further information: <a href="/facts/Perl/fx31kjlT">Perl</a></p>
my @s = map {2 * $_} grep {$_ ** 2 > 3} 0..99;

<p>Array with all the doubles from 1 to 9 inclusive:
</p>
my @doubles = map {$_ * 2} 1..9;

<p>Array with the names of the customers based in Rio de Janeiro (from array of hashes):
</p>
my @rjCustomers = map {$_->{state} eq "RJ" ? $_->{name} : ()} @customers;

<p>Filtering numbers divisible by 3:
</p>
my @divisibleBy3 = grep {$_ % 3 == 0} 0..100;

<h3>PowerShell</h3>
<p class="note">Further information: <a href="/facts/PowerShell/G1d10lwn">PowerShell</a></p>
$s = ( 0..100 | ? {$_*$_ -gt 3} | % {2*$_} )
<p>which is short-hand notation of:</p>$s = 0..100 | where-object {$_*$_ -gt 3} | foreach-object {2*$_}

<h3>Python</h3>
<p class="note">Further information: <a href="/facts/Python_syntax_and_semantics/XNHY4v4E">Python syntax and semantics § Comprehensions</a></p>
<p><a href="/facts/Python_(programming_language)/YbuGqofa">Python</a> uses the following syntax to express list comprehensions over finite lists:
</p>
S = [2 * x for x in range(100) if x ** 2 > 3]

<p>A generator expression may be used in Python versions >= 2.4 which gives <a href="/facts/Lazy_evaluation/mD3DxDkc">lazy evaluation</a> over its input, and can be used with <a href="/facts/Generator_(computer_science)/nHRrs0GF">generators</a> to iterate over 'infinite' input such as the count generator function which returns successive integers:
</p>
from itertools import count
S = (2 * x for x in count() if x ** 2 > 3)

<p>(Subsequent use of the generator expression will determine when to stop generating values).
</p>
<h3>R</h3>
<p class="note">Further information: <a href="/facts/R_(programming_language)/LSrkr8K8">R</a></p>
 x <- 0:100
 S <- 2 * x[x ^ 2 > 3]

<h3>Racket</h3>
<p class="note">Further information: <a href="/facts/Racket_(programming_language)/5n7LW08b">Racket</a></p>
(for/list ([x 100] #:when (> (* x x) 3)) (* x 2))

<p>An example with multiple generators:
</p>
(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))

<h3>Raku</h3>
<p class="note">Further information: <a href="/facts/Raku_(programming_language)/9eYW7vRJ">Raku (programming language)</a></p>
 my @s = ($_ * 2 if $_ ** 2 > 3 for 0 .. 99);

<h3>Scala</h3>
<p class="note">Further information: <a href="/facts/Scala_(programming_language)/ebL8o6AK">Scala</a></p>
<p>Using the for-comprehension:
</p>
val s = for (x <- 0 to 100; if x*x > 3) yield 2*x

<h3>Scheme</h3>
<p class="note">Further information: <a href="/facts/Scheme_(programming_language)/0aGdf3SC">Scheme</a></p>
<p>List comprehensions are supported in Scheme through the use of the <a href="/facts/Scheme_Requests_for_Implementation/I5lcAax9">SRFI</a>-42 library.<a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a>
</p>
(list-ec (: x 100) (if (> (* x x) 3)) (* x 2))

<p>An example of a list comprehension using multiple generators:
</p>
(list-ec (: x 1 21) (: y x 21) (: z y 21) (if (= (+ (* x x) (* y y)) (* z z))) (list x y z))

<h3>SETL</h3>
<p class="note">Further information: <a href="/facts/SETL/VF8l7bME">SETL</a></p>
s := {2*x : x in {0..100} | x**2 > 3 };

<h3>Smalltalk</h3>
<p class="note">Further information: <a href="/facts/Smalltalk/Ru2UPVDE">Smalltalk</a></p>
((1 to: 100) select: [ :x | x squared > 3 ]) collect: [ :x | x * 2 ]

<h3>Visual Prolog</h3>
<p class="note">Further information: <a href="/facts/Visual_Prolog/03tnjaK8">Visual Prolog</a></p>
S = [ 2*X || X = list::getMember_nd(L), X*X > 3 ]

<h2 id="external-links">External links</h2>
<ul><li><a href="http://rosettacode.org/wiki/List_comprehensions">Comparison of list comprehensions on rosettacode.org</a></li></ul>

<h2 id="references">References</h2>

<ol>
<li id="fn:1"><p>Nim sugar module <a href="https://nim-lang.github.io/Nim/sugar.html#collect.m%2Cuntyped%2Cuntyped" target="_blank">https://nim-lang.github.io/Nim/sugar.html#collect.m%2Cuntyped%2Cuntyped</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li>
<li id="fn:2"><p>OCaml Batteries Included <a href="http://batteries.forge.ocamlcore.org/" target="_blank">http://batteries.forge.ocamlcore.org/</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li>
<li id="fn:3"><p>Scheme SRFI 42: Eager Comprehensions <a href="http://srfi.schemers.org/srfi-42/srfi-42.html" target="_blank">http://srfi.schemers.org/srfi-42/srfi-42.html</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li>
</ol>

Comparison of programming languages (list comprehension) open-in-new

Comparison of programming languages (list comprehension)