Comparison of programming languages (list comprehension)

Examples of list comprehension

Boo

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

<span id="mwFg"></span><span class="n" id="mwFw">doubles</span><span class="w" id="mwGA"> </span><span class="o" id="mwGQ">=</span><span class="w" id="mwGg"> </span><span class="p" id="mwGw">[</span><span class="n" id="mwHA">i</span><span class="o" id="mwHQ">*</span><span class="mi" id="mwHg">2</span><span class="w" id="mwHw"> </span><span class="k" id="mwIA">for</span><span class="w" id="mwIQ"> </span><span class="n" id="mwIg">i</span><span class="w" id="mwIw"> </span><span class="ow" id="mwJA">in</span><span class="w" id="mwJQ"> </span><span class="nb" id="mwJg">range</span><span class="p" id="mwJw">(</span><span class="mi" id="mwKA">10</span><span class="p" id="mwKQ">)]</span>

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

<span id="mwLg"></span><span class="n" id="mwLw">rjCustomers</span><span class="w" id="mwMA"> </span><span class="o" id="mwMQ">=</span><span class="w" id="mwMg"> </span><span class="p" id="mwMw">[</span><span class="n" id="mwNA">customer</span><span class="p" id="mwNQ">.</span><span class="n" id="mwNg">Name</span><span class="w" id="mwNw"> </span><span class="k" id="mwOA">for</span><span class="w" id="mwOQ"> </span><span class="n" id="mwOg">customer</span><span class="w" id="mwOw"> </span><span class="ow" id="mwPA">in</span><span class="w" id="mwPQ"> </span><span class="n" id="mwPg">customers</span><span class="w" id="mwPw"> </span><span class="k" id="mwQA">if</span><span class="w" id="mwQQ"> </span><span class="n" id="mwQg">customer</span><span class="p" id="mwQw">.</span><span class="n" id="mwRA">State</span><span class="w" id="mwRQ"> </span><span class="o" id="mwRg">==</span><span class="w" id="mwRw"> </span><span class="s2" id="mwSA">"RJ"</span><span class="p" id="mwSQ">]</span>

C++

C++ can use the std::views namespace, introduced in C++20.

<span id="mwUQ"></span><span class="k" id="mwUg">using</span><span class="w" id="mwUw"> </span><span class="n" id="mwVA">std</span><span class="o" id="mwVQ">::</span><span class="n" id="mwVg">vector</span><span class="p" id="mwVw">;</span> <span class="k" id="mwWA">using</span><span class="w" id="mwWQ"> </span><span class="n" id="mwWg">std</span><span class="o" id="mwWw">::</span><span class="n" id="mwXA">ranges</span><span class="o" id="mwXQ">::</span><span class="n" id="mwXg">to</span><span class="p" id="mwXw">;</span> <span class="k" id="mwYA">using</span><span class="w" id="mwYQ"> </span><span class="n" id="mwYg">std</span><span class="o" id="mwYw">::</span><span class="n" id="mwZA">views</span><span class="o" id="mwZQ">::</span><span class="n" id="mwZg">filter</span><span class="p" id="mwZw">;</span> <span class="k" id="mwaA">using</span><span class="w" id="mwaQ"> </span><span class="n" id="mwag">std</span><span class="o" id="mwaw">::</span><span class="n" id="mwbA">views</span><span class="o" id="mwbQ">::</span><span class="n" id="mwbg">transform</span><span class="p" id="mwbw">;</span> <span class="n" id="mwcA">vector</span><span class="o" id="mwcQ"><</span><span class="kt" id="mwcg">int</span><span class="o" id="mwcw">></span><span class="w" id="mwdA"> </span><span class="n" id="mwdQ">ns</span><span class="w" id="mwdg"> </span><span class="o" id="mwdw">=</span><span class="w" id="mweA"> </span><span class="n" id="mweQ">std</span><span class="o" id="mweg">::</span><span class="n" id="mwew">views</span><span class="o" id="mwfA">::</span><span class="n" id="mwfQ">iota</span><span class="p" id="mwfg">(</span><span class="mi" id="mwfw">0</span><span class="p" id="mwgA">,</span><span class="w" id="mwgQ"> </span><span class="mi" id="mwgg">100</span><span class="p" id="mwgw">)</span> <span class="w" id="mwhA"> </span><span class="o" id="mwhQ">|</span><span class="w" id="mwhg"> </span><span class="n" id="mwhw">filter</span><span class="p" id="mwiA">([](</span><span class="kt" id="mwiQ">int</span><span class="w" id="mwig"> </span><span class="n" id="mwiw">x</span><span class="p" id="mwjA">)</span><span class="w" id="mwjQ"> </span><span class="o" id="mwjg">-></span><span class="w" id="mwjw"> </span><span class="kt" id="mwkA">bool</span><span class="w" id="mwkQ"> </span><span class="p" id="mwkg">{</span><span class="w" id="mwkw"> </span><span class="k" id="mwlA">return</span><span class="w" id="mwlQ"> </span><span class="n" id="mwlg">x</span><span class="w" id="mwlw"> </span><span class="o" id="mwmA">*</span><span class="w" id="mwmQ"> </span><span class="n" id="mwmg">x</span><span class="w" id="mwmw"> </span><span class="o" id="mwnA">></span><span class="w" id="mwnQ"> </span><span class="mi" id="mwng">3</span><span class="p" id="mwnw">;</span><span class="w" id="mwoA"> </span><span class="p" id="mwoQ">})</span> <span class="w" id="mwog"> </span><span class="o" id="mwow">|</span><span class="w" id="mwpA"> </span><span class="n" id="mwpQ">transform</span><span class="p" id="mwpg">([](</span><span class="kt" id="mwpw">int</span><span class="w" id="mwqA"> </span><span class="n" id="mwqQ">x</span><span class="p" id="mwqg">)</span><span class="w" id="mwqw"> </span><span class="o" id="mwrA">-></span><span class="w" id="mwrQ"> </span><span class="kt" id="mwrg">int</span><span class="w" id="mwrw"> </span><span class="p" id="mwsA">{</span><span class="w" id="mwsQ"> </span><span class="k" id="mwsg">return</span><span class="w" id="mwsw"> </span><span class="n" id="mwtA">x</span><span class="w" id="mwtQ"> </span><span class="o" id="mwtg">*</span><span class="w" id="mwtw"> </span><span class="mi" id="mwuA">2</span><span class="p" id="mwuQ">;</span><span class="w" id="mwug"> </span><span class="p" id="mwuw">})</span> <span class="w" id="mwvA"> </span><span class="o" id="mwvQ">|</span><span class="w" id="mwvg"> </span><span class="n" id="mwvw">to</span><span class="o" id="mwwA"><</span><span class="n" id="mwwQ">vector</span><span class="o" id="mwwg">></span><span class="p" id="mwww">();</span>

C#

<span id="mwyQ"></span><span class="n" id="mwyg">IEnumerable</span><span class="o" id="mwyw"><</span><span class="kt" id="mwzA">int</span><span class="o" id="mwzQ">></span><span class="w" id="mwzg"> </span><span class="n" id="mwzw">ns</span><span class="w" id="mw0A"> </span><span class="o" id="mw0Q">=</span><span class="w" id="mw0g"> </span><span class="k" id="mw0w">from</span><span class="w" id="mw1A"> </span><span class="n" id="mw1Q">x</span><span class="w" id="mw1g"> </span><span class="k" id="mw1w">in</span><span class="w" id="mw2A"> </span><span class="n" id="mw2Q">Enumerable</span><span class="p" id="mw2g">.</span><span class="n" id="mw2w">Range</span><span class="p" id="mw3A">(</span><span class="mi" id="mw3Q">0</span><span class="p" id="mw3g">,</span><span class="w" id="mw3w"> </span><span class="mi" id="mw4A">100</span><span class="p" id="mw4Q">)</span> <span class="w" id="mw4g"> </span><span class="k" id="mw4w">where</span><span class="w" id="mw5A"> </span><span class="n" id="mw5Q">x</span><span class="w" id="mw5g"> </span><span class="o" id="mw5w">*</span><span class="w" id="mw6A"> </span><span class="n" id="mw6Q">x</span><span class="w" id="mw6g"> </span><span class="o" id="mw6w">></span><span class="w" id="mw7A"> </span><span class="mi" id="mw7Q">3</span> <span class="w" id="mw7g"> </span><span class="k" id="mw7w">select</span><span class="w" id="mw8A"> </span><span class="n" id="mw8Q">x</span><span class="w" id="mw8g"> </span><span class="o" id="mw8w">*</span><span class="w" id="mw9A"> </span><span class="mi" id="mw9Q">2</span><span class="p" id="mw9g">;</span>

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

<span id="mw-w"></span><span class="n" id="mw_A">IEnumerable</span><span class="o" id="mw_Q"><</span><span class="kt" id="mw_g">int</span><span class="o" id="mw_w">></span><span class="w" id="mwAQA"> </span><span class="n" id="mwAQE">ns</span><span class="w" id="mwAQI"> </span><span class="o" id="mwAQM">=</span><span class="w" id="mwAQQ"> </span><span class="n" id="mwAQU">Enumerable</span><span class="p" id="mwAQY">.</span><span class="n" id="mwAQc">Range</span><span class="p" id="mwAQg">(</span><span class="mi" id="mwAQk">0</span><span class="p" id="mwAQo">,</span><span class="w" id="mwAQs"> </span><span class="mi" id="mwAQw">100</span><span class="p" id="mwAQ0">)</span> <span class="w" id="mwAQ4"> </span><span class="p" id="mwAQ8">.</span><span class="n" id="mwARA">Where</span><span class="p" id="mwARE">(</span><span class="n" id="mwARI">x</span><span class="w" id="mwARM"> </span><span class="o" id="mwARQ">=></span><span class="w" id="mwARU"> </span><span class="n" id="mwARY">x</span><span class="w" id="mwARc"> </span><span class="o" id="mwARg">*</span><span class="w" id="mwARk"> </span><span class="n" id="mwARo">x</span><span class="w" id="mwARs"> </span><span class="o" id="mwARw">></span><span class="w" id="mwAR0"> </span><span class="mi" id="mwAR4">3</span><span class="p" id="mwAR8">)</span> <span class="w" id="mwASA"> </span><span class="p" id="mwASE">.</span><span class="n" id="mwASI">Select</span><span class="p" id="mwASM">(</span><span class="n" id="mwASQ">x</span><span class="w" id="mwASU"> </span><span class="o" id="mwASY">=></span><span class="w" id="mwASc"> </span><span class="n" id="mwASg">x</span><span class="w" id="mwASk"> </span><span class="o" id="mwASo">*</span><span class="w" id="mwASs"> </span><span class="mi" id="mwASw">2</span><span class="p" id="mwAS0">);</span>

Ceylon

Filtering numbers divisible by 3:

<span id="mwATQ"></span><span class="kt" id="mwATU">value</span><span class="w" id="mwATY"> </span><span class="n" id="mwATc">divisibleBy3</span><span class="w" id="mwATg"> </span><span class="o" id="mwATk">=</span><span class="w" id="mwATo"> </span><span class="o" id="mwATs">{</span><span class="w" id="mwATw"> </span><span class="k" id="mwAT0">for</span><span class="w" id="mwAT4"> </span><span class="o" id="mwAT8">(</span><span class="n" id="mwAUA">i</span><span class="w" id="mwAUE"> </span><span class="k" id="mwAUI">in</span><span class="w" id="mwAUM"> </span><span class="mi" id="mwAUQ">0</span><span class="o" id="mwAUU">..</span><span class="mi" id="mwAUY">100</span><span class="o" id="mwAUc">)</span><span class="w" id="mwAUg"> </span><span class="k" id="mwAUk">if</span><span class="w" id="mwAUo"> </span><span class="o" id="mwAUs">(</span><span class="n" id="mwAUw">i</span><span class="o" id="mwAU0">%</span><span class="mi" id="mwAU4">3</span><span class="o" id="mwAU8">==</span><span class="mi" id="mwAVA">0</span><span class="o" id="mwAVE">)</span><span class="w" id="mwAVI"> </span><span class="n" id="mwAVM">i</span><span class="w" id="mwAVQ"> </span><span class="o" id="mwAVU">};</span> <span class="c1" id="mwAVY">// type of divisibleBy3 is Iterable<Integer></span>

Multiple "generators":

<span id="mwAVo"></span><span class="kt" id="mwAVs">value</span><span class="w" id="mwAVw"> </span><span class="n" id="mwAV0">triples</span><span class="w" id="mwAV4"> </span><span class="o" id="mwAV8">=</span><span class="w" id="mwAWA"> </span><span class="o" id="mwAWE">{</span><span class="w" id="mwAWI"> </span><span class="k" id="mwAWM">for</span><span class="w" id="mwAWQ"> </span><span class="o" id="mwAWU">(</span><span class="n" id="mwAWY">x</span><span class="w" id="mwAWc"> </span><span class="k" id="mwAWg">in</span><span class="w" id="mwAWk"> </span><span class="mi" id="mwAWo">0</span><span class="o" id="mwAWs">..</span><span class="mi" id="mwAWw">20</span><span class="o" id="mwAW0">)</span><span class="w" id="mwAW4"> </span><span class="k" id="mwAW8">for</span><span class="w" id="mwAXA"> </span><span class="o" id="mwAXE">(</span><span class="n" id="mwAXI">y</span><span class="w" id="mwAXM"> </span><span class="k" id="mwAXQ">in</span><span class="w" id="mwAXU"> </span><span class="n" id="mwAXY">x</span><span class="o" id="mwAXc">..</span><span class="mi" id="mwAXg">20</span><span class="o" id="mwAXk">)</span><span class="w" id="mwAXo"> </span><span class="k" id="mwAXs">for</span><span class="w" id="mwAXw"> </span><span class="o" id="mwAX0">(</span><span class="n" id="mwAX4">z</span><span class="w" id="mwAX8"> </span><span class="k" id="mwAYA">in</span><span class="w" id="mwAYE"> </span><span class="n" id="mwAYI">y</span><span class="o" id="mwAYM">..</span><span class="mi" id="mwAYQ">20</span><span class="o" id="mwAYU">)</span><span class="w" id="mwAYY"> </span><span class="k" id="mwAYc">if</span><span class="w" id="mwAYg"> </span><span class="o" id="mwAYk">(</span><span class="n" id="mwAYo">x</span><span class="o" id="mwAYs">*</span><span class="n" id="mwAYw">x</span><span class="w" id="mwAY0"> </span><span class="o" id="mwAY4">+</span><span class="w" id="mwAY8"> </span><span class="n" id="mwAZA">y</span><span class="o" id="mwAZE">*</span><span class="n" id="mwAZI">y</span><span class="w" id="mwAZM"> </span><span class="o" id="mwAZQ">==</span><span class="w" id="mwAZU"> </span><span class="n" id="mwAZY">z</span><span class="o" id="mwAZc">*</span><span class="n" id="mwAZg">z</span><span class="o" id="mwAZk">)</span><span class="w" id="mwAZo"> </span><span class="o" id="mwAZs">[</span><span class="n" id="mwAZw">x</span><span class="o" id="mwAZ0">,</span><span class="n" id="mwAZ4">y</span><span class="o" id="mwAZ8">,</span><span class="n" id="mwAaA">z</span><span class="o" id="mwAaE">]</span><span class="w" id="mwAaI"> </span><span class="o" id="mwAaM">};</span> <span class="c1" id="mwAaQ">// type of triples is Iterable<Integer[3]></span>

Clojure

An infinite lazy sequence:

<span id="mwAas"></span><span class="w" id="mwAaw"> </span><span class="p" id="mwAa0">(</span><span class="nv" id="mwAa4">for</span><span class="w" id="mwAa8"> </span><span class="nv" id="mwAbA">[x</span><span class="w" id="mwAbE"> </span><span class="p" id="mwAbI">(</span><span class="nv" id="mwAbM">iterate</span><span class="w" id="mwAbQ"> </span><span class="nv" id="mwAbU">inc</span><span class="w" id="mwAbY"> </span><span class="mi" id="mwAbc">0</span><span class="p" id="mwAbg">)</span><span class="w" id="mwAbk"> </span> <span class="w" id="mwAbo"> </span><span class="ss" id="mwAbs">:when</span><span class="w" id="mwAbw"> </span><span class="p" id="mwAb0">(</span><span class="nb" id="mwAb4">></span><span class="w" id="mwAb8"> </span><span class="p" id="mwAcA">(</span><span class="nb" id="mwAcE">*</span><span class="w" id="mwAcI"> </span><span class="nv" id="mwAcM">x</span><span class="w" id="mwAcQ"> </span><span class="nv" id="mwAcU">x</span><span class="p" id="mwAcY">)</span><span class="w" id="mwAcc"> </span><span class="mi" id="mwAcg">3</span><span class="p" id="mwAck">)</span><span class="nv" id="mwAco">]</span> <span class="w" id="mwAcs"> </span><span class="p" id="mwAcw">(</span><span class="nb" id="mwAc0">*</span><span class="w" id="mwAc4"> </span><span class="mi" id="mwAc8">2</span><span class="w" id="mwAdA"> </span><span class="nv" id="mwAdE">x</span><span class="p" id="mwAdI">))</span>

A list comprehension using multiple generators:

<span id="mwAdY"></span><span class="w" id="mwAdc"> </span><span class="p" id="mwAdg">(</span><span class="nv" id="mwAdk">for</span><span class="w" id="mwAdo"> </span><span class="nv" id="mwAds">[x</span><span class="w" id="mwAdw"> </span><span class="p" id="mwAd0">(</span><span class="nv" id="mwAd4">range</span><span class="w" id="mwAd8"> </span><span class="mi" id="mwAeA">20</span><span class="p" id="mwAeE">)</span> <span class="w" id="mwAeI"> </span><span class="nv" id="mwAeM">y</span><span class="w" id="mwAeQ"> </span><span class="p" id="mwAeU">(</span><span class="nv" id="mwAeY">range</span><span class="w" id="mwAec"> </span><span class="mi" id="mwAeg">20</span><span class="p" id="mwAek">)</span> <span class="w" id="mwAeo"> </span><span class="nv" id="mwAes">z</span><span class="w" id="mwAew"> </span><span class="p" id="mwAe0">(</span><span class="nv" id="mwAe4">range</span><span class="w" id="mwAe8"> </span><span class="mi" id="mwAfA">20</span><span class="p" id="mwAfE">)</span> <span class="w" id="mwAfI"> </span><span class="ss" id="mwAfM">:when</span><span class="w" id="mwAfQ"> </span><span class="p" id="mwAfU">(</span><span class="nv" id="mwAfY">==</span><span class="w" id="mwAfc"> </span><span class="p" id="mwAfg">(</span><span class="nb" id="mwAfk">+</span><span class="w" id="mwAfo"> </span><span class="p" id="mwAfs">(</span><span class="nb" id="mwAfw">*</span><span class="w" id="mwAf0"> </span><span class="nv" id="mwAf4">x</span><span class="w" id="mwAf8"> </span><span class="nv" id="mwAgA">x</span><span class="p" id="mwAgE">)</span><span class="w" id="mwAgI"> </span><span class="p" id="mwAgM">(</span><span class="nb" id="mwAgQ">*</span><span class="w" id="mwAgU"> </span><span class="nv" id="mwAgY">y</span><span class="w" id="mwAgc"> </span><span class="nv" id="mwAgg">y</span><span class="p" id="mwAgk">))</span><span class="w" id="mwAgo"> </span><span class="p" id="mwAgs">(</span><span class="nb" id="mwAgw">*</span><span class="w" id="mwAg0"> </span><span class="nv" id="mwAg4">z</span><span class="w" id="mwAg8"> </span><span class="nv" id="mwAhA">z</span><span class="p" id="mwAhE">))</span><span class="nv" id="mwAhI">]</span> <span class="w" id="mwAhM"> </span><span class="nv" id="mwAhQ">[x</span><span class="w" id="mwAhU"> </span><span class="nv" id="mwAhY">y</span><span class="w" id="mwAhc"> </span><span class="nv" id="mwAhg">z]</span><span class="p" id="mwAhk">)</span>

CoffeeScript

<span id="mwAh8"></span><span class="nv" id="mwAiA">largeNumbers</span><span class="w" id="mwAiE"> </span><span class="o" id="mwAiI">=</span><span class="w" id="mwAiM"> </span><span class="p" id="mwAiQ">(</span><span class="nx" id="mwAiU">number</span><span class="w" id="mwAiY"> </span><span class="k" id="mwAic">for</span><span class="w" id="mwAig"> </span><span class="nx" id="mwAik">number</span><span class="w" id="mwAio"> </span><span class="k" id="mwAis">in</span><span class="w" id="mwAiw"> </span><span class="nx" id="mwAi0">list</span><span class="w" id="mwAi4"> </span><span class="k" id="mwAi8">when</span><span class="w" id="mwAjA"> </span><span class="nx" id="mwAjE">number</span><span class="w" id="mwAjI"> </span><span class="o" id="mwAjM">></span><span class="w" id="mwAjQ"> </span><span class="mi" id="mwAjU">100</span><span class="p" id="mwAjY">)</span>

Common Lisp

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

<span id="mwAkA"></span><span class="p" id="mwAkE">(</span><span class="nb" id="mwAkI">loop</span><span class="w" id="mwAkM"> </span><span class="nv" id="mwAkQ">for</span><span class="w" id="mwAkU"> </span><span class="nv" id="mwAkY">x</span><span class="w" id="mwAkc"> </span><span class="nv" id="mwAkg">from</span><span class="w" id="mwAkk"> </span><span class="mi" id="mwAko">0</span><span class="w" id="mwAks"> </span><span class="nv" id="mwAkw">to</span><span class="w" id="mwAk0"> </span><span class="mi" id="mwAk4">100</span><span class="w" id="mwAk8"> </span><span class="k" id="mwAlA">if</span><span class="w" id="mwAlE"> </span><span class="p" id="mwAlI">(</span><span class="nb" id="mwAlM">></span><span class="w" id="mwAlQ"> </span><span class="p" id="mwAlU">(</span><span class="nb" id="mwAlY">*</span><span class="w" id="mwAlc"> </span><span class="nv" id="mwAlg">x</span><span class="w" id="mwAlk"> </span><span class="nv" id="mwAlo">x</span><span class="p" id="mwAls">)</span><span class="w" id="mwAlw"> </span><span class="mi" id="mwAl0">3</span><span class="p" id="mwAl4">)</span><span class="w" id="mwAl8"> </span><span class="nv" id="mwAmA">collect</span><span class="w" id="mwAmE"> </span><span class="p" id="mwAmI">(</span><span class="nb" id="mwAmM">*</span><span class="w" id="mwAmQ"> </span><span class="mi" id="mwAmU">2</span><span class="w" id="mwAmY"> </span><span class="nv" id="mwAmc">x</span><span class="p" id="mwAmg">))</span>

Cobra

List the names of customers:

<span id="mwAm8"></span><span class="n" id="mwAnA">names</span> <span class="o" id="mwAnE">=</span> <span class="k" id="mwAnI">for</span> <span class="n" id="mwAnM">cust</span> <span class="ow" id="mwAnQ">in</span> <span class="n" id="mwAnU">customers</span> <span class="n" id="mwAnY">get</span> <span class="n" id="mwAnc">cust</span><span class="o" id="mwAng">.</span><span class="n" id="mwAnk">name</span>

List the customers with balances:

<span id="mwAn0"></span><span class="n" id="mwAn4">names</span> <span class="o" id="mwAn8">=</span> <span class="k" id="mwAoA">for</span> <span class="n" id="mwAoE">cust</span> <span class="ow" id="mwAoI">in</span> <span class="n" id="mwAoM">customers</span> <span class="n" id="mwAoQ">where</span> <span class="n" id="mwAoU">cust</span><span class="o" id="mwAoY">.</span><span class="n" id="mwAoc">balance</span> <span class="o" id="mwAog">></span> <span class="mi" id="mwAok">0</span>

List the names of customers with balances:

<span id="mwAo0"></span><span class="n" id="mwAo4">names</span> <span class="o" id="mwAo8">=</span> <span class="k" id="mwApA">for</span> <span class="n" id="mwApE">cust</span> <span class="ow" id="mwApI">in</span> <span class="n" id="mwApM">customers</span> <span class="n" id="mwApQ">where</span> <span class="n" id="mwApU">cust</span><span class="o" id="mwApY">.</span><span class="n" id="mwApc">balance</span> <span class="o" id="mwApg">></span> <span class="mi" id="mwApk">0</span> <span class="n" id="mwApo">get</span> <span class="n" id="mwAps">cust</span><span class="o" id="mwApw">.</span><span class="n" id="mwAp0">name</span>

The general forms:

<span id="mwAqE"></span><span class="k" id="mwAqI">for</span> <span class="n" id="mwAqM">VAR</span> <span class="ow" id="mwAqQ">in</span> <span class="n" id="mwAqU">ENUMERABLE</span> <span class="p" id="mwAqY">[</span><span class="n" id="mwAqc">where</span> <span class="n" id="mwAqg">CONDITION</span><span class="p" id="mwAqk">]</span> <span class="n" id="mwAqo">get</span> <span class="n" id="mwAqs">EXPR</span> <span class="k" id="mwAqw">for</span> <span class="n" id="mwAq0">VAR</span> <span class="ow" id="mwAq4">in</span> <span class="n" id="mwAq8">ENUMERABLE</span> <span class="n" id="mwArA">where</span> <span class="n" id="mwArE">CONDITION</span>

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.

Dart

<span id="mwAro"></span><span class="p" id="mwArs">[</span><span class="k" id="mwArw">for</span><span class="w" id="mwAr0"> </span><span class="p" id="mwAr4">(</span><span class="kd" id="mwAr8">var</span><span class="w" id="mwAsA"> </span><span class="n" id="mwAsE">i</span><span class="w" id="mwAsI"> </span><span class="k" id="mwAsM">in</span><span class="w" id="mwAsQ"> </span><span class="n" id="mwAsU">range</span><span class="p" id="mwAsY">(</span><span class="m" id="mwAsc">0</span><span class="p" id="mwAsg">,</span><span class="w" id="mwAsk"> </span><span class="m" id="mwAso">100</span><span class="p" id="mwAss">))</span><span class="w" id="mwAsw"> </span><span class="k" id="mwAs0">if</span><span class="w" id="mwAs4"> </span><span class="p" id="mwAs8">(</span><span class="n" id="mwAtA">i</span><span class="w" id="mwAtE"> </span><span class="o" id="mwAtI">*</span><span class="w" id="mwAtM"> </span><span class="n" id="mwAtQ">i</span><span class="w" id="mwAtU"> </span><span class="o" id="mwAtY">></span><span class="w" id="mwAtc"> </span><span class="m" id="mwAtg">3</span><span class="p" id="mwAtk">)</span><span class="w" id="mwAto"> </span><span class="n" id="mwAts">i</span><span class="w" id="mwAtw"> </span><span class="o" id="mwAt0">*</span><span class="w" id="mwAt4"> </span><span class="m" id="mwAt8">2</span><span class="p" id="mwAuA">]</span>

<span id="mwAuM"></span><span class="kd" id="mwAuQ">var</span><span class="w" id="mwAuU"> </span><span class="n" id="mwAuY">pyth</span><span class="w" id="mwAuc"> </span><span class="o" id="mwAug">=</span><span class="w" id="mwAuk"> </span><span class="p" id="mwAuo">[</span> <span class="w" id="mwAus"> </span><span class="k" id="mwAuw">for</span><span class="w" id="mwAu0"> </span><span class="p" id="mwAu4">(</span><span class="kd" id="mwAu8">var</span><span class="w" id="mwAvA"> </span><span class="n" id="mwAvE">x</span><span class="w" id="mwAvI"> </span><span class="k" id="mwAvM">in</span><span class="w" id="mwAvQ"> </span><span class="n" id="mwAvU">range</span><span class="p" id="mwAvY">(</span><span class="m" id="mwAvc">1</span><span class="p" id="mwAvg">,</span><span class="w" id="mwAvk"> </span><span class="m" id="mwAvo">20</span><span class="p" id="mwAvs">))</span> <span class="w" id="mwAvw"> </span><span class="k" id="mwAv0">for</span><span class="w" id="mwAv4"> </span><span class="p" id="mwAv8">(</span><span class="kd" id="mwAwA">var</span><span class="w" id="mwAwE"> </span><span class="n" id="mwAwI">y</span><span class="w" id="mwAwM"> </span><span class="k" id="mwAwQ">in</span><span class="w" id="mwAwU"> </span><span class="n" id="mwAwY">range</span><span class="p" id="mwAwc">(</span><span class="n" id="mwAwg">x</span><span class="p" id="mwAwk">,</span><span class="w" id="mwAwo"> </span><span class="m" id="mwAws">20</span><span class="p" id="mwAww">))</span> <span class="w" id="mwAw0"> </span><span class="k" id="mwAw4">for</span><span class="w" id="mwAw8"> </span><span class="p" id="mwAxA">(</span><span class="kd" id="mwAxE">var</span><span class="w" id="mwAxI"> </span><span class="n" id="mwAxM">z</span><span class="w" id="mwAxQ"> </span><span class="k" id="mwAxU">in</span><span class="w" id="mwAxY"> </span><span class="n" id="mwAxc">range</span><span class="p" id="mwAxg">(</span><span class="n" id="mwAxk">y</span><span class="p" id="mwAxo">,</span><span class="w" id="mwAxs"> </span><span class="m" id="mwAxw">20</span><span class="p" id="mwAx0">))</span><span class="w" id="mwAx4"> </span><span class="k" id="mwAx8">if</span><span class="w" id="mwAyA"> </span><span class="p" id="mwAyE">(</span><span class="n" id="mwAyI">x</span><span class="w" id="mwAyM"> </span><span class="o" id="mwAyQ">*</span><span class="w" id="mwAyU"> </span><span class="n" id="mwAyY">x</span><span class="w" id="mwAyc"> </span><span class="o" id="mwAyg">+</span><span class="w" id="mwAyk"> </span><span class="n" id="mwAyo">y</span><span class="w" id="mwAys"> </span><span class="o" id="mwAyw">*</span><span class="w" id="mwAy0"> </span><span class="n" id="mwAy4">y</span><span class="w" id="mwAy8"> </span><span class="o" id="mwAzA">==</span><span class="w" id="mwAzE"> </span><span class="n" id="mwAzI">z</span><span class="w" id="mwAzM"> </span><span class="o" id="mwAzQ">*</span><span class="w" id="mwAzU"> </span><span class="n" id="mwAzY">z</span><span class="p" id="mwAzc">)</span><span class="w" id="mwAzg"> </span><span class="p" id="mwAzk">[</span><span class="n" id="mwAzo">x</span><span class="p" id="mwAzs">,</span><span class="w" id="mwAzw"> </span><span class="n" id="mwAz0">y</span><span class="p" id="mwAz4">,</span><span class="w" id="mwAz8"> </span><span class="n" id="mwA0A">z</span><span class="p" id="mwA0E">]</span> <span class="p" id="mwA0I">];</span>

<span id="mwA0U"></span><span class="n" id="mwA0Y">Iterable</span><span class="o" id="mwA0c"><</span><span class="kt" id="mwA0g">int</span><span class="o" id="mwA0k">></span><span class="w" id="mwA0o"> </span><span class="n" id="mwA0s">range</span><span class="p" id="mwA0w">(</span><span class="kt" id="mwA00">int</span><span class="w" id="mwA04"> </span><span class="n" id="mwA08">start</span><span class="p" id="mwA1A">,</span><span class="w" id="mwA1E"> </span><span class="kt" id="mwA1I">int</span><span class="w" id="mwA1M"> </span><span class="n" id="mwA1Q">end</span><span class="p" id="mwA1U">)</span><span class="w" id="mwA1Y"> </span><span class="o" id="mwA1c">=></span> <span class="w" id="mwA1g"> </span><span class="n" id="mwA1k">List</span><span class="p" id="mwA1o">.</span><span class="n" id="mwA1s">generate</span><span class="p" id="mwA1w">(</span><span class="n" id="mwA10">end</span><span class="w" id="mwA14"> </span><span class="o" id="mwA18">-</span><span class="w" id="mwA2A"> </span><span class="n" id="mwA2E">start</span><span class="p" id="mwA2I">,</span><span class="w" id="mwA2M"> </span><span class="p" id="mwA2Q">(</span><span class="n" id="mwA2U">i</span><span class="p" id="mwA2Y">)</span><span class="w" id="mwA2c"> </span><span class="o" id="mwA2g">=></span><span class="w" id="mwA2k"> </span><span class="n" id="mwA2o">start</span><span class="w" id="mwA2s"> </span><span class="o" id="mwA2w">+</span><span class="w" id="mwA20"> </span><span class="n" id="mwA24">i</span><span class="p" id="mwA28">);</span>

Elixir

<span id="mwA3U"></span><span class="k" id="mwA3Y">for</span><span class="w" id="mwA3c"> </span><span class="n" id="mwA3g">x</span><span class="w" id="mwA3k"> </span><span class="o" id="mwA3o"><-</span><span class="w" id="mwA3s"> </span><span class="mi" id="mwA3w">0</span><span class="o" id="mwA30">..</span><span class="mi" id="mwA34">100</span><span class="p" id="mwA38">,</span><span class="w" id="mwA4A"> </span><span class="n" id="mwA4E">x</span><span class="w" id="mwA4I"> </span><span class="o" id="mwA4M">*</span><span class="w" id="mwA4Q"> </span><span class="n" id="mwA4U">x</span><span class="w" id="mwA4Y"> </span><span class="o" id="mwA4c">></span><span class="w" id="mwA4g"> </span><span class="mi" id="mwA4k">3</span><span class="p" id="mwA4o">,</span><span class="w" id="mwA4s"> </span><span class="ss" id="mwA4w">do</span><span class="p" id="mwA40">:</span><span class="w" id="mwA44"> </span><span class="n" id="mwA48">x</span><span class="w" id="mwA5A"> </span><span class="o" id="mwA5E">*</span><span class="w" id="mwA5I"> </span><span class="mi" id="mwA5M">2</span>

Erlang

<span id="mwA5k"></span><span class="nv" id="mwA5o">L</span><span class="w" id="mwA5s"> </span><span class="o" id="mwA5w">=</span><span class="w" id="mwA50"> </span><span class="nn" id="mwA54">lists</span><span class="p" id="mwA58">:</span><span class="nf" id="mwA6A">seq</span><span class="p" id="mwA6E">(</span><span class="mi" id="mwA6I">0</span><span class="p" id="mwA6M">,</span><span class="mi" id="mwA6Q">100</span><span class="p" id="mwA6U">).</span> <span class="nv" id="mwA6Y">S</span><span class="w" id="mwA6c"> </span><span class="o" id="mwA6g">=</span><span class="w" id="mwA6k"> </span><span class="p" id="mwA6o">[</span><span class="mi" id="mwA6s">2</span><span class="o" id="mwA6w">*</span><span class="nv" id="mwA60">X</span><span class="w" id="mwA64"> </span><span class="p" id="mwA68">||</span><span class="w" id="mwA7A"> </span><span class="nv" id="mwA7E">X</span><span class="w" id="mwA7I"> </span><span class="o" id="mwA7M"><-</span><span class="w" id="mwA7Q"> </span><span class="nv" id="mwA7U">L</span><span class="p" id="mwA7Y">,</span><span class="w" id="mwA7c"> </span><span class="nv" id="mwA7g">X</span><span class="o" id="mwA7k">*</span><span class="nv" id="mwA7o">X</span><span class="w" id="mwA7s"> </span><span class="o" id="mwA7w">></span><span class="w" id="mwA70"> </span><span class="mi" id="mwA74">3</span><span class="p" id="mwA78">].</span>

F#

Lazily-evaluated sequences:

<span id="mwA8Y"></span><span class="n" id="mwA8c">seq</span><span class="w" id="mwA8g"> </span><span class="o" id="mwA8k">{</span><span class="w" id="mwA8o"> </span><span class="k" id="mwA8s">for</span><span class="w" id="mwA8w"> </span><span class="n" id="mwA80">x</span><span class="w" id="mwA84"> </span><span class="k" id="mwA88">in</span><span class="w" id="mwA9A"> </span><span class="mi" id="mwA9E">0</span><span class="w" id="mwA9I"> </span><span class="o" id="mwA9M">..</span><span class="w" id="mwA9Q"> </span><span class="mi" id="mwA9U">100</span><span class="w" id="mwA9Y"> </span><span class="k" id="mwA9c">do</span><span class="w" id="mwA9g"> </span><span class="k" id="mwA9k">if</span><span class="w" id="mwA9o"> </span><span class="n" id="mwA9s">x</span><span class="o" id="mwA9w">*</span><span class="n" id="mwA90">x</span><span class="w" id="mwA94"> </span><span class="o" id="mwA98">></span><span class="w" id="mwA-A"> </span><span class="mi" id="mwA-E">3</span><span class="w" id="mwA-I"> </span><span class="k" id="mwA-M">then</span><span class="w" id="mwA-Q"> </span><span class="k" id="mwA-U">yield</span><span class="w" id="mwA-Y"> </span><span class="mi" id="mwA-c">2</span><span class="o" id="mwA-g">*</span><span class="n" id="mwA-k">x</span><span class="w" id="mwA-o"> </span><span class="o" id="mwA-s">}</span>

Or, for floating point values

<span id="mwA-8"></span><span class="n" id="mwA_A">seq</span><span class="w" id="mwA_E"> </span><span class="o" id="mwA_I">{</span><span class="w" id="mwA_M"> </span><span class="k" id="mwA_Q">for</span><span class="w" id="mwA_U"> </span><span class="n" id="mwA_Y">x</span><span class="w" id="mwA_c"> </span><span class="k" id="mwA_g">in</span><span class="w" id="mwA_k"> </span><span class="mi" id="mwA_o">0</span><span class="o" id="mwA_s">.</span><span class="w" id="mwA_w"> </span><span class="o" id="mwA_0">..</span><span class="w" id="mwA_4"> </span><span class="mi" id="mwA_8">100</span><span class="o" id="mwBAA">.</span><span class="w" id="mwBAE"> </span><span class="k" id="mwBAI">do</span><span class="w" id="mwBAM"> </span><span class="k" id="mwBAQ">if</span><span class="w" id="mwBAU"> </span><span class="n" id="mwBAY">x</span><span class="o" id="mwBAc">**</span><span class="mi" id="mwBAg">2</span><span class="o" id="mwBAk">.</span><span class="w" id="mwBAo"> </span><span class="o" id="mwBAs">></span><span class="w" id="mwBAw"> </span><span class="mi" id="mwBA0">3</span><span class="o" id="mwBA4">.</span><span class="w" id="mwBA8"> </span><span class="k" id="mwBBA">then</span><span class="w" id="mwBBE"> </span><span class="k" id="mwBBI">yield</span><span class="w" id="mwBBM"> </span><span class="mi" id="mwBBQ">2</span><span class="o" id="mwBBU">.*</span><span class="n" id="mwBBY">x</span><span class="w" id="mwBBc"> </span><span class="o" id="mwBBg">}</span>

Lists and arrays:

<span id="mwBBw"></span><span class="o" id="mwBB0">[</span><span class="w" id="mwBB4"> </span><span class="k" id="mwBB8">for</span><span class="w" id="mwBCA"> </span><span class="n" id="mwBCE">x</span><span class="w" id="mwBCI"> </span><span class="k" id="mwBCM">in</span><span class="w" id="mwBCQ"> </span><span class="mi" id="mwBCU">0</span><span class="o" id="mwBCY">.</span><span class="w" id="mwBCc"> </span><span class="o" id="mwBCg">..</span><span class="w" id="mwBCk"> </span><span class="mi" id="mwBCo">100</span><span class="o" id="mwBCs">.</span><span class="w" id="mwBCw"> </span><span class="k" id="mwBC0">do</span><span class="w" id="mwBC4"> </span><span class="k" id="mwBC8">if</span><span class="w" id="mwBDA"> </span><span class="n" id="mwBDE">x</span><span class="o" id="mwBDI">**</span><span class="mi" id="mwBDM">2</span><span class="o" id="mwBDQ">.</span><span class="w" id="mwBDU"> </span><span class="o" id="mwBDY">></span><span class="w" id="mwBDc"> </span><span class="mi" id="mwBDg">3</span><span class="o" id="mwBDk">.</span><span class="w" id="mwBDo"> </span><span class="k" id="mwBDs">then</span><span class="w" id="mwBDw"> </span><span class="k" id="mwBD0">yield</span><span class="w" id="mwBD4"> </span><span class="mi" id="mwBD8">2</span><span class="o" id="mwBEA">.*</span><span class="n" id="mwBEE">x</span><span class="w" id="mwBEI"> </span><span class="o" id="mwBEM">]</span> <span class="o" id="mwBEQ">[|</span><span class="w" id="mwBEU"> </span><span class="k" id="mwBEY">for</span><span class="w" id="mwBEc"> </span><span class="n" id="mwBEg">x</span><span class="w" id="mwBEk"> </span><span class="k" id="mwBEo">in</span><span class="w" id="mwBEs"> </span><span class="mi" id="mwBEw">0</span><span class="o" id="mwBE0">.</span><span class="w" id="mwBE4"> </span><span class="o" id="mwBE8">..</span><span class="w" id="mwBFA"> </span><span class="mi" id="mwBFE">100</span><span class="o" id="mwBFI">.</span><span class="w" id="mwBFM"> </span><span class="k" id="mwBFQ">do</span><span class="w" id="mwBFU"> </span><span class="k" id="mwBFY">if</span><span class="w" id="mwBFc"> </span><span class="n" id="mwBFg">x</span><span class="o" id="mwBFk">**</span><span class="mi" id="mwBFo">2</span><span class="o" id="mwBFs">.</span><span class="w" id="mwBFw"> </span><span class="o" id="mwBF0">></span><span class="w" id="mwBF4"> </span><span class="mi" id="mwBF8">3</span><span class="o" id="mwBGA">.</span><span class="w" id="mwBGE"> </span><span class="k" id="mwBGI">then</span><span class="w" id="mwBGM"> </span><span class="k" id="mwBGQ">yield</span><span class="w" id="mwBGU"> </span><span class="mi" id="mwBGY">2</span><span class="o" id="mwBGc">.*</span><span class="n" id="mwBGg">x</span><span class="w" id="mwBGk"> </span><span class="o" id="mwBGo">|]</span>

List comprehensions are the part of a greater family of language constructs called computation expressions.

Haskell

<span id="mwBHM"></span><span class="p" id="mwBHQ">[</span><span class="n" id="mwBHU">x</span><span class="w" id="mwBHY"> </span><span class="o" id="mwBHc">*</span><span class="w" id="mwBHg"> </span><span class="mi" id="mwBHk">2</span><span class="w" id="mwBHo"> </span><span class="o" id="mwBHs">|</span><span class="w" id="mwBHw"> </span><span class="n" id="mwBH0">x</span><span class="w" id="mwBH4"> </span><span class="ow" id="mwBH8"><-</span><span class="w" id="mwBIA"> </span><span class="p" id="mwBIE">[</span><span class="mi" id="mwBII">0</span><span class="w" id="mwBIM"> </span><span class="o" id="mwBIQ">..</span><span class="w" id="mwBIU"> </span><span class="mi" id="mwBIY">99</span><span class="p" id="mwBIc">],</span><span class="w" id="mwBIg"> </span><span class="n" id="mwBIk">x</span><span class="w" id="mwBIo"> </span><span class="o" id="mwBIs">*</span><span class="w" id="mwBIw"> </span><span class="n" id="mwBI0">x</span><span class="w" id="mwBI4"> </span><span class="o" id="mwBI8">></span><span class="w" id="mwBJA"> </span><span class="mi" id="mwBJE">3</span><span class="p" id="mwBJI">]</span>

An example of a list comprehension using multiple generators:

<span id="mwBJY"></span><span class="nf" id="mwBJc">pyth</span><span class="w" id="mwBJg"> </span><span class="ow" id="mwBJk">=</span><span class="w" id="mwBJo"> </span><span class="p" id="mwBJs">[(</span><span class="n" id="mwBJw">x</span><span class="p" id="mwBJ0">,</span><span class="n" id="mwBJ4">y</span><span class="p" id="mwBJ8">,</span><span class="n" id="mwBKA">z</span><span class="p" id="mwBKE">)</span><span class="w" id="mwBKI"> </span><span class="o" id="mwBKM">|</span><span class="w" id="mwBKQ"> </span><span class="n" id="mwBKU">x</span><span class="w" id="mwBKY"> </span><span class="ow" id="mwBKc"><-</span><span class="w" id="mwBKg"> </span><span class="p" id="mwBKk">[</span><span class="mi" id="mwBKo">1</span><span class="o" id="mwBKs">..</span><span class="mi" id="mwBKw">20</span><span class="p" id="mwBK0">],</span><span class="w" id="mwBK4"> </span><span class="n" id="mwBK8">y</span><span class="w" id="mwBLA"> </span><span class="ow" id="mwBLE"><-</span><span class="w" id="mwBLI"> </span><span class="p" id="mwBLM">[</span><span class="n" id="mwBLQ">x</span><span class="o" id="mwBLU">..</span><span class="mi" id="mwBLY">20</span><span class="p" id="mwBLc">],</span><span class="w" id="mwBLg"> </span><span class="n" id="mwBLk">z</span><span class="w" id="mwBLo"> </span><span class="ow" id="mwBLs"><-</span><span class="w" id="mwBLw"> </span><span class="p" id="mwBL0">[</span><span class="n" id="mwBL4">y</span><span class="o" id="mwBL8">..</span><span class="mi" id="mwBMA">20</span><span class="p" id="mwBME">],</span><span class="w" id="mwBMI"> </span><span class="n" id="mwBMM">x</span><span class="o" id="mwBMQ">^</span><span class="mi" id="mwBMU">2</span><span class="w" id="mwBMY"> </span><span class="o" id="mwBMc">+</span><span class="w" id="mwBMg"> </span><span class="n" id="mwBMk">y</span><span class="o" id="mwBMo">^</span><span class="mi" id="mwBMs">2</span><span class="w" id="mwBMw"> </span><span class="o" id="mwBM0">==</span><span class="w" id="mwBM4"> </span><span class="n" id="mwBM8">z</span><span class="o" id="mwBNA">^</span><span class="mi" id="mwBNE">2</span><span class="p" id="mwBNI">]</span>

Io

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

<span id="mwBNk"></span><span class="n" id="mwBNo">Range</span><span class="w" id="mwBNs"> </span><span class="mf" id="mwBNw">0</span><span class="w" id="mwBN0"> </span><span class="n" id="mwBN4">to</span><span class="o" id="mwBN8">(</span><span class="mf" id="mwBOA">100</span><span class="o" id="mwBOE">)</span><span class="w" id="mwBOI"> </span><span class="n" id="mwBOM">asList</span><span class="w" id="mwBOQ"> </span><span class="n" id="mwBOU">select</span><span class="o" id="mwBOY">(</span><span class="n" id="mwBOc">x</span><span class="o" id="mwBOg">,</span><span class="w" id="mwBOk"> </span><span class="n" id="mwBOo">x</span><span class="o" id="mwBOs">*</span><span class="n" id="mwBOw">x</span><span class="o" id="mwBO0">></span><span class="mf" id="mwBO4">3</span><span class="o" id="mwBO8">)</span><span class="w" id="mwBPA"> </span><span class="n" id="mwBPE">map</span><span class="o" id="mwBPI">(*</span><span class="mf" id="mwBPM">2</span><span class="o" id="mwBPQ">)</span>

ISLISP

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

<span id="mwBP0"></span><span class="p" id="mwBP4">(</span><span class="nv" id="mwBP8">for</span><span class="w" id="mwBQA"> </span><span class="p" id="mwBQE">((</span><span class="nv" id="mwBQI">x</span><span class="w" id="mwBQM"> </span><span class="mi" id="mwBQQ">0</span><span class="w" id="mwBQU"> </span><span class="p" id="mwBQY">(</span><span class="nb" id="mwBQc">+</span><span class="w" id="mwBQg"> </span><span class="nv" id="mwBQk">x</span><span class="w" id="mwBQo"> </span><span class="mi" id="mwBQs">1</span><span class="p" id="mwBQw">))</span> <span class="w" id="mwBQ0"> </span><span class="p" id="mwBQ4">(</span><span class="nv" id="mwBQ8">collect</span><span class="w" id="mwBRA"> </span><span class="p" id="mwBRE">()))</span> <span class="w" id="mwBRI"> </span><span class="p" id="mwBRM">((</span><span class="nb" id="mwBRQ">>=</span><span class="w" id="mwBRU"> </span><span class="nv" id="mwBRY">x</span><span class="w" id="mwBRc"> </span><span class="mi" id="mwBRg">100</span><span class="p" id="mwBRk">)</span><span class="w" id="mwBRo"> </span><span class="p" id="mwBRs">(</span><span class="nb" id="mwBRw">reverse</span><span class="w" id="mwBR0"> </span><span class="nv" id="mwBR4">collect</span><span class="p" id="mwBR8">))</span> <span class="w" id="mwBSA"> </span><span class="p" id="mwBSE">(</span><span class="k" id="mwBSI">if</span><span class="w" id="mwBSM"> </span><span class="p" id="mwBSQ">(</span><span class="nb" id="mwBSU">></span><span class="w" id="mwBSY"> </span><span class="p" id="mwBSc">(</span><span class="nb" id="mwBSg">*</span><span class="w" id="mwBSk"> </span><span class="nv" id="mwBSo">x</span><span class="w" id="mwBSs"> </span><span class="nv" id="mwBSw">x</span><span class="p" id="mwBS0">)</span><span class="w" id="mwBS4"> </span><span class="mi" id="mwBS8">3</span><span class="p" id="mwBTA">)</span> <span class="w" id="mwBTE"> </span><span class="p" id="mwBTI">(</span><span class="k" id="mwBTM">setq</span><span class="w" id="mwBTQ"> </span><span class="nv" id="mwBTU">collect</span><span class="w" id="mwBTY"> </span><span class="p" id="mwBTc">(</span><span class="nb" id="mwBTg">cons</span><span class="w" id="mwBTk"> </span><span class="p" id="mwBTo">(</span><span class="nb" id="mwBTs">*</span><span class="w" id="mwBTw"> </span><span class="nv" id="mwBT0">x</span><span class="w" id="mwBT4"> </span><span class="mi" id="mwBT8">2</span><span class="p" id="mwBUA">)</span><span class="w" id="mwBUE"> </span><span class="nv" id="mwBUI">collect</span><span class="p" id="mwBUM">))))</span>

Julia

Julia supports comprehensions using the syntax:

<span id="mwBUw"></span><span class="w" id="mwBU0"> </span><span class="n" id="mwBU4">y</span><span class="w" id="mwBU8"> </span><span class="o" id="mwBVA">=</span><span class="w" id="mwBVE"> </span><span class="p" id="mwBVI">[</span><span class="n" id="mwBVM">x</span><span class="o" id="mwBVQ">^</span><span class="mi" id="mwBVU">2</span><span class="o" id="mwBVY">+</span><span class="mi" id="mwBVc">1</span><span class="w" id="mwBVg"> </span><span class="k" id="mwBVk">for</span><span class="w" id="mwBVo"> </span><span class="n" id="mwBVs">x</span><span class="w" id="mwBVw"> </span><span class="k" id="mwBV0">in</span><span class="w" id="mwBV4"> </span><span class="mi" id="mwBV8">1</span><span class="o" id="mwBWA">:</span><span class="mi" id="mwBWE">10</span><span class="p" id="mwBWI">]</span>

and multidimensional comprehensions like:

<span id="mwBWY"></span><span class="w" id="mwBWc"> </span><span class="n" id="mwBWg">z</span><span class="w" id="mwBWk"> </span><span class="o" id="mwBWo">=</span><span class="w" id="mwBWs"> </span><span class="p" id="mwBWw">[(</span><span class="n" id="mwBW0">x</span><span class="o" id="mwBW4">-</span><span class="mi" id="mwBW8">5</span><span class="p" id="mwBXA">)</span><span class="o" id="mwBXE">^</span><span class="mi" id="mwBXI">2</span><span class="o" id="mwBXM">+</span><span class="p" id="mwBXQ">(</span><span class="n" id="mwBXU">y</span><span class="o" id="mwBXY">-</span><span class="mi" id="mwBXc">5</span><span class="p" id="mwBXg">)</span><span class="o" id="mwBXk">^</span><span class="mi" id="mwBXo">2</span><span class="w" id="mwBXs"> </span><span class="k" id="mwBXw">for</span><span class="w" id="mwBX0"> </span><span class="n" id="mwBX4">x</span><span class="w" id="mwBX8"> </span><span class="o" id="mwBYA">=</span><span class="w" id="mwBYE"> </span><span class="mi" id="mwBYI">0</span><span class="o" id="mwBYM">:</span><span class="mi" id="mwBYQ">10</span><span class="p" id="mwBYU">,</span><span class="w" id="mwBYY"> </span><span class="n" id="mwBYc">y</span><span class="w" id="mwBYg"> </span><span class="o" id="mwBYk">=</span><span class="w" id="mwBYo"> </span><span class="mi" id="mwBYs">0</span><span class="o" id="mwBYw">:</span><span class="mi" id="mwBY0">10</span><span class="p" id="mwBY4">]</span>

It is also possible to add a condition:

<span id="mwBZI"></span><span class="n" id="mwBZM">v</span><span class="w" id="mwBZQ"> </span><span class="o" id="mwBZU">=</span><span class="w" id="mwBZY"> </span><span class="p" id="mwBZc">[</span><span class="mi" id="mwBZg">3</span><span class="n" id="mwBZk">x</span><span class="o" id="mwBZo">^</span><span class="mi" id="mwBZs">2</span><span class="w" id="mwBZw"> </span><span class="o" id="mwBZ0">+</span><span class="w" id="mwBZ4"> </span><span class="mi" id="mwBZ8">2</span><span class="n" id="mwBaA">y</span><span class="o" id="mwBaE">^</span><span class="mi" id="mwBaI">2</span><span class="w" id="mwBaM"> </span><span class="k" id="mwBaQ">for</span><span class="w" id="mwBaU"> </span><span class="n" id="mwBaY">x</span><span class="w" id="mwBac"> </span><span class="k" id="mwBag">in</span><span class="w" id="mwBak"> </span><span class="mi" id="mwBao">1</span><span class="o" id="mwBas">:</span><span class="mi" id="mwBaw">7</span><span class="w" id="mwBa0"> </span><span class="k" id="mwBa4">for</span><span class="w" id="mwBa8"> </span><span class="n" id="mwBbA">y</span><span class="w" id="mwBbE"> </span><span class="k" id="mwBbI">in</span><span class="w" id="mwBbM"> </span><span class="mi" id="mwBbQ">1</span><span class="o" id="mwBbU">:</span><span class="mi" id="mwBbY">7</span><span class="w" id="mwBbc"> </span><span class="k" id="mwBbg">if</span><span class="w" id="mwBbk"> </span><span class="n" id="mwBbo">x</span><span class="w" id="mwBbs"> </span><span class="o" id="mwBbw">%</span><span class="w" id="mwBb0"> </span><span class="n" id="mwBb4">y</span><span class="w" id="mwBb8"> </span><span class="o" id="mwBcA">==</span><span class="w" id="mwBcE"> </span><span class="mi" id="mwBcI">0</span><span class="p" id="mwBcM">]</span>

And just changing square brackets to the round one, we get a generator:

<span id="mwBcc"></span><span class="n" id="mwBcg">g</span><span class="w" id="mwBck"> </span><span class="o" id="mwBco">=</span><span class="w" id="mwBcs"> </span><span class="p" id="mwBcw">(</span><span class="mi" id="mwBc0">3</span><span class="n" id="mwBc4">x</span><span class="o" id="mwBc8">^</span><span class="mi" id="mwBdA">2</span><span class="w" id="mwBdE"> </span><span class="o" id="mwBdI">+</span><span class="w" id="mwBdM"> </span><span class="mi" id="mwBdQ">2</span><span class="n" id="mwBdU">y</span><span class="o" id="mwBdY">^</span><span class="mi" id="mwBdc">2</span><span class="w" id="mwBdg"> </span><span class="k" id="mwBdk">for</span><span class="w" id="mwBdo"> </span><span class="n" id="mwBds">x</span><span class="w" id="mwBdw"> </span><span class="k" id="mwBd0">in</span><span class="w" id="mwBd4"> </span><span class="mi" id="mwBd8">1</span><span class="o" id="mwBeA">:</span><span class="mi" id="mwBeE">7</span><span class="w" id="mwBeI"> </span><span class="k" id="mwBeM">for</span><span class="w" id="mwBeQ"> </span><span class="n" id="mwBeU">y</span><span class="w" id="mwBeY"> </span><span class="k" id="mwBec">in</span><span class="w" id="mwBeg"> </span><span class="mi" id="mwBek">1</span><span class="o" id="mwBeo">:</span><span class="mi" id="mwBes">7</span><span class="w" id="mwBew"> </span><span class="k" id="mwBe0">if</span><span class="w" id="mwBe4"> </span><span class="n" id="mwBe8">x</span><span class="w" id="mwBfA"> </span><span class="o" id="mwBfE">%</span><span class="w" id="mwBfI"> </span><span class="n" id="mwBfM">y</span><span class="w" id="mwBfQ"> </span><span class="o" id="mwBfU">==</span><span class="w" id="mwBfY"> </span><span class="mi" id="mwBfc">0</span><span class="p" id="mwBfg">)</span>

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

<span id="mwBgI"></span><span class="o" id="mwBgM">$[</span><span class="n" id="mwBgQ">x</span><span class="o" id="mwBgU">*</span><span class="mi" id="mwBgY">2</span> <span class="o" id="mwBgc">|</span> <span class="n" id="mwBgg">x</span> <span class="k" id="mwBgk">in</span> <span class="o" id="mwBgo">[</span><span class="mi" id="mwBgs">0</span> <span class="o" id="mwBgw">..</span> <span class="mi" id="mwBg0">100</span><span class="o" id="mwBg4">],</span> <span class="n" id="mwBg8">x</span><span class="o" id="mwBhA">*</span><span class="n" id="mwBhE">x</span> <span class="o" id="mwBhI">></span> <span class="mi" id="mwBhM">3</span><span class="o" id="mwBhQ">]</span>

Nim

Nim has built-in seq, set, table and object comprehensions on the sugar standard library module:

<span id="mwBh4"></span><span class="kn" id="mwBh8">import</span><span class="w" id="mwBiA"> </span><span class="n" id="mwBiE">sugar</span> <span class="k" id="mwBiI">let</span><span class="w" id="mwBiM"> </span><span class="n" id="mwBiQ">variable</span><span class="w" id="mwBiU"> </span><span class="o" id="mwBiY">=</span><span class="w" id="mwBic"> </span><span class="n" id="mwBig">collect</span><span class="p" id="mwBik">(</span><span class="n" id="mwBio">newSeq</span><span class="p" id="mwBis">):</span> <span class="w" id="mwBiw"> </span><span class="k" id="mwBi0">for</span><span class="w" id="mwBi4"> </span><span class="n" id="mwBi8">item</span><span class="w" id="mwBjA"> </span><span class="ow" id="mwBjE">in</span><span class="w" id="mwBjI"> </span><span class="o" id="mwBjM">@[-</span><span class="mi" id="mwBjQ">9</span><span class="p" id="mwBjU">,</span><span class="w" id="mwBjY"> </span><span class="mi" id="mwBjc">1</span><span class="p" id="mwBjg">,</span><span class="w" id="mwBjk"> </span><span class="mi" id="mwBjo">42</span><span class="p" id="mwBjs">,</span><span class="w" id="mwBjw"> </span><span class="mi" id="mwBj0">0</span><span class="p" id="mwBj4">,</span><span class="w" id="mwBj8"> </span><span class="o" id="mwBkA">-</span><span class="mi" id="mwBkE">1</span><span class="p" id="mwBkI">,</span><span class="w" id="mwBkM"> </span><span class="mi" id="mwBkQ">9</span><span class="o" id="mwBkU">]</span><span class="p" id="mwBkY">:</span><span class="w" id="mwBkc"> </span><span class="n" id="mwBkg">item</span><span class="w" id="mwBkk"> </span><span class="o" id="mwBko">+</span><span class="w" id="mwBks"> </span><span class="mi" id="mwBkw">1</span> <span class="n" id="mwBk0">assert</span><span class="w" id="mwBk4"> </span><span class="n" id="mwBk8">variable</span><span class="w" id="mwBlA"> </span><span class="o" id="mwBlE">==</span><span class="w" id="mwBlI"> </span><span class="o" id="mwBlM">@[-</span><span class="mi" id="mwBlQ">8</span><span class="p" id="mwBlU">,</span><span class="w" id="mwBlY"> </span><span class="mi" id="mwBlc">2</span><span class="p" id="mwBlg">,</span><span class="w" id="mwBlk"> </span><span class="mi" id="mwBlo">43</span><span class="p" id="mwBls">,</span><span class="w" id="mwBlw"> </span><span class="mi" id="mwBl0">1</span><span class="p" id="mwBl4">,</span><span class="w" id="mwBl8"> </span><span class="mi" id="mwBmA">0</span><span class="p" id="mwBmE">,</span><span class="w" id="mwBmI"> </span><span class="mi" id="mwBmM">10</span><span class="o" id="mwBmQ">]</span>

The comprehension is implemented as a macro that is expanded at compile time, you can see the expanded code using the expandMacro compiler option:

<span id="mwBmk"></span><span class="kd" id="mwBmo">var</span><span class="w" id="mwBms"> </span><span class="n" id="mwBmw">collectResult</span><span class="w" id="mwBm0"> </span><span class="o" id="mwBm4">=</span><span class="w" id="mwBm8"> </span><span class="n" id="mwBnA">newSeq</span><span class="p" id="mwBnE">(</span><span class="n" id="mwBnI">Natural</span><span class="p" id="mwBnM">(</span><span class="mi" id="mwBnQ">0</span><span class="p" id="mwBnU">))</span> <span class="k" id="mwBnY">for</span><span class="w" id="mwBnc"> </span><span class="n" id="mwBng">item</span><span class="w" id="mwBnk"> </span><span class="ow" id="mwBno">in</span><span class="w" id="mwBns"> </span><span class="n" id="mwBnw">items</span><span class="p" id="mwBn0">(</span><span class="o" id="mwBn4">@[-</span><span class="mi" id="mwBn8">9</span><span class="p" id="mwBoA">,</span><span class="w" id="mwBoE"> </span><span class="mi" id="mwBoI">1</span><span class="p" id="mwBoM">,</span><span class="w" id="mwBoQ"> </span><span class="mi" id="mwBoU">42</span><span class="p" id="mwBoY">,</span><span class="w" id="mwBoc"> </span><span class="mi" id="mwBog">0</span><span class="p" id="mwBok">,</span><span class="w" id="mwBoo"> </span><span class="o" id="mwBos">-</span><span class="mi" id="mwBow">1</span><span class="p" id="mwBo0">,</span><span class="w" id="mwBo4"> </span><span class="mi" id="mwBo8">9</span><span class="o" id="mwBpA">]</span><span class="p" id="mwBpE">):</span> <span class="w" id="mwBpI"> </span><span class="n" id="mwBpM">add</span><span class="p" id="mwBpQ">(</span><span class="n" id="mwBpU">collectResult</span><span class="p" id="mwBpY">,</span><span class="w" id="mwBpc"> </span><span class="n" id="mwBpg">item</span><span class="w" id="mwBpk"> </span><span class="o" id="mwBpo">+</span><span class="w" id="mwBps"> </span><span class="mi" id="mwBpw">1</span><span class="p" id="mwBp0">)</span> <span class="n" id="mwBp4">collectResult</span>

The comprehensions can be nested and multi-line:

<span id="mwBqI"></span><span class="kn" id="mwBqM">import</span><span class="w" id="mwBqQ"> </span><span class="n" id="mwBqU">sugar</span> <span class="k" id="mwBqY">let</span><span class="w" id="mwBqc"> </span><span class="n" id="mwBqg">values</span><span class="w" id="mwBqk"> </span><span class="o" id="mwBqo">=</span><span class="w" id="mwBqs"> </span><span class="n" id="mwBqw">collect</span><span class="p" id="mwBq0">(</span><span class="n" id="mwBq4">newSeq</span><span class="p" id="mwBq8">):</span> <span class="w" id="mwBrA"> </span><span class="k" id="mwBrE">for</span><span class="w" id="mwBrI"> </span><span class="n" id="mwBrM">val</span><span class="w" id="mwBrQ"> </span><span class="ow" id="mwBrU">in</span><span class="w" id="mwBrY"> </span><span class="o" id="mwBrc">[</span><span class="mi" id="mwBrg">1</span><span class="p" id="mwBrk">,</span><span class="w" id="mwBro"> </span><span class="mi" id="mwBrs">2</span><span class="o" id="mwBrw">]</span><span class="p" id="mwBr0">:</span> <span class="w" id="mwBr4"> </span><span class="n" id="mwBr8">collect</span><span class="p" id="mwBsA">(</span><span class="n" id="mwBsE">newSeq</span><span class="p" id="mwBsI">):</span> <span class="w" id="mwBsM"> </span><span class="k" id="mwBsQ">for</span><span class="w" id="mwBsU"> </span><span class="n" id="mwBsY">val2</span><span class="w" id="mwBsc"> </span><span class="ow" id="mwBsg">in</span><span class="w" id="mwBsk"> </span><span class="o" id="mwBso">[</span><span class="mi" id="mwBss">3</span><span class="p" id="mwBsw">,</span><span class="w" id="mwBs0"> </span><span class="mi" id="mwBs4">4</span><span class="o" id="mwBs8">]</span><span class="p" id="mwBtA">:</span> <span class="w" id="mwBtE"> </span><span class="k" id="mwBtI">if</span><span class="w" id="mwBtM"> </span><span class="p" id="mwBtQ">(</span><span class="n" id="mwBtU">val</span><span class="p" id="mwBtY">,</span><span class="w" id="mwBtc"> </span><span class="n" id="mwBtg">val2</span><span class="p" id="mwBtk">)</span><span class="w" id="mwBto"> </span><span class="o" id="mwBts">!=</span><span class="w" id="mwBtw"> </span><span class="p" id="mwBt0">(</span><span class="mi" id="mwBt4">1</span><span class="p" id="mwBt8">,</span><span class="w" id="mwBuA"> </span><span class="mi" id="mwBuE">2</span><span class="p" id="mwBuI">):</span> <span class="w" id="mwBuM"> </span><span class="p" id="mwBuQ">(</span><span class="n" id="mwBuU">val</span><span class="p" id="mwBuY">,</span><span class="w" id="mwBuc"> </span><span class="n" id="mwBug">val2</span><span class="p" id="mwBuk">)</span> <span class="w" id="mwBuo"> </span> <span class="n" id="mwBus">assert</span><span class="w" id="mwBuw"> </span><span class="n" id="mwBu0">values</span><span class="w" id="mwBu4"> </span><span class="o" id="mwBu8">==</span><span class="w" id="mwBvA"> </span><span class="o" id="mwBvE">@[@[</span><span class="p" id="mwBvI">(</span><span class="mi" id="mwBvM">1</span><span class="p" id="mwBvQ">,</span><span class="w" id="mwBvU"> </span><span class="mi" id="mwBvY">3</span><span class="p" id="mwBvc">),</span><span class="w" id="mwBvg"> </span><span class="p" id="mwBvk">(</span><span class="mi" id="mwBvo">1</span><span class="p" id="mwBvs">,</span><span class="w" id="mwBvw"> </span><span class="mi" id="mwBv0">4</span><span class="p" id="mwBv4">)</span><span class="o" id="mwBv8">]</span><span class="p" id="mwBwA">,</span><span class="w" id="mwBwE"> </span><span class="o" id="mwBwI">@[</span><span class="p" id="mwBwM">(</span><span class="mi" id="mwBwQ">2</span><span class="p" id="mwBwU">,</span><span class="w" id="mwBwY"> </span><span class="mi" id="mwBwc">3</span><span class="p" id="mwBwg">),</span><span class="w" id="mwBwk"> </span><span class="p" id="mwBwo">(</span><span class="mi" id="mwBws">2</span><span class="p" id="mwBww">,</span><span class="w" id="mwBw0"> </span><span class="mi" id="mwBw4">4</span><span class="p" id="mwBw8">)</span><span class="o" id="mwBxA">]]</span>

OCaml

OCaml supports List comprehension through OCaml Batteries.

Perl

<span id="mwBx8"></span><span class="k" id="mwByA">my</span><span class="w" id="mwByE"> </span><span class="nv" id="mwByI">@s</span><span class="w" id="mwByM"> </span><span class="o" id="mwByQ">=</span><span class="w" id="mwByU"> </span><span class="nb" id="mwByY">map</span><span class="w" id="mwByc"> </span><span class="p" id="mwByg">{</span><span class="mi" id="mwByk">2</span><span class="w" id="mwByo"> </span><span class="o" id="mwBys">*</span><span class="w" id="mwByw"> </span><span class="nv" id="mwBy0">$_</span><span class="p" id="mwBy4">}</span><span class="w" id="mwBy8"> </span><span class="nb" id="mwBzA">grep</span><span class="w" id="mwBzE"> </span><span class="p" id="mwBzI">{</span><span class="nv" id="mwBzM">$_</span><span class="w" id="mwBzQ"> </span><span class="o" id="mwBzU">**</span><span class="w" id="mwBzY"> </span><span class="mi" id="mwBzc">2</span><span class="w" id="mwBzg"> </span><span class="o" id="mwBzk">></span><span class="w" id="mwBzo"> </span><span class="mi" id="mwBzs">3</span><span class="p" id="mwBzw">}</span><span class="w" id="mwBz0"> </span><span class="mi" id="mwBz4">0</span><span class="o" id="mwBz8">..</span><span class="mi" id="mwB0A">99</span><span class="p" id="mwB0E">;</span>

Array with all the doubles from 1 to 9 inclusive:

<span id="mwB0U"></span><span class="k" id="mwB0Y">my</span><span class="w" id="mwB0c"> </span><span class="nv" id="mwB0g">@doubles</span><span class="w" id="mwB0k"> </span><span class="o" id="mwB0o">=</span><span class="w" id="mwB0s"> </span><span class="nb" id="mwB0w">map</span><span class="w" id="mwB00"> </span><span class="p" id="mwB04">{</span><span class="nv" id="mwB08">$_</span><span class="w" id="mwB1A"> </span><span class="o" id="mwB1E">*</span><span class="w" id="mwB1I"> </span><span class="mi" id="mwB1M">2</span><span class="p" id="mwB1Q">}</span><span class="w" id="mwB1U"> </span><span class="mi" id="mwB1Y">1</span><span class="o" id="mwB1c">..</span><span class="mi" id="mwB1g">9</span><span class="p" id="mwB1k">;</span>

Array with the names of the customers based in Rio de Janeiro (from array of hashes):

<span id="mwB10"></span><span class="k" id="mwB14">my</span><span class="w" id="mwB18"> </span><span class="nv" id="mwB2A">@rjCustomers</span><span class="w" id="mwB2E"> </span><span class="o" id="mwB2I">=</span><span class="w" id="mwB2M"> </span><span class="nb" id="mwB2Q">map</span><span class="w" id="mwB2U"> </span><span class="p" id="mwB2Y">{</span><span class="nv" id="mwB2c">$_</span><span class="o" id="mwB2g">-></span><span class="p" id="mwB2k">{</span><span class="n" id="mwB2o">state</span><span class="p" id="mwB2s">}</span><span class="w" id="mwB2w"> </span><span class="ow" id="mwB20">eq</span><span class="w" id="mwB24"> </span><span class="s" id="mwB28">"RJ"</span><span class="w" id="mwB3A"> </span><span class="p" id="mwB3E">?</span><span class="w" id="mwB3I"> </span><span class="nv" id="mwB3M">$_</span><span class="o" id="mwB3Q">-></span><span class="p" id="mwB3U">{</span><span class="n" id="mwB3Y">name</span><span class="p" id="mwB3c">}</span><span class="w" id="mwB3g"> </span><span class="p" id="mwB3k">:</span><span class="w" id="mwB3o"> </span><span class="p" id="mwB3s">()}</span><span class="w" id="mwB3w"> </span><span class="nv" id="mwB30">@customers</span><span class="p" id="mwB34">;</span>

Filtering numbers divisible by 3:

<span id="mwB4I"></span><span class="k" id="mwB4M">my</span><span class="w" id="mwB4Q"> </span><span class="nv" id="mwB4U">@divisibleBy3</span><span class="w" id="mwB4Y"> </span><span class="o" id="mwB4c">=</span><span class="w" id="mwB4g"> </span><span class="nb" id="mwB4k">grep</span><span class="w" id="mwB4o"> </span><span class="p" id="mwB4s">{</span><span class="nv" id="mwB4w">$_</span><span class="w" id="mwB40"> </span><span class="nv" id="mwB44">%</span><span class="w" id="mwB48"> </span><span class="nv" id="mwB5A">3</span><span class="w" id="mwB5E"> </span><span class="o" id="mwB5I">==</span><span class="w" id="mwB5M"> </span><span class="mi" id="mwB5Q">0</span><span class="p" id="mwB5U">}</span><span class="w" id="mwB5Y"> </span><span class="mi" id="mwB5c">0</span><span class="o" id="mwB5g">..</span><span class="mi" id="mwB5k">100</span><span class="p" id="mwB5o">;</span>

PowerShell

<span id="mwB6A"></span><span class="nv" id="mwB6E">$s</span> <span class="p" id="mwB6I">=</span> <span class="p" id="mwB6M">(</span> <span class="n" id="mwB6Q">0</span><span class="p" id="mwB6U">..</span><span class="n" id="mwB6Y">100</span> <span class="p" id="mwB6c">|</span> <span class="p" id="mwB6g">?</span> <span class="p" id="mwB6k">{</span><span class="nv" id="mwB6o">$_</span><span class="p" id="mwB6s">*</span><span class="nv" id="mwB6w">$_</span> <span class="o" id="mwB60">-gt</span> <span class="n" id="mwB64">3</span><span class="p" id="mwB68">}</span> <span class="p" id="mwB7A">|</span> <span class="p" id="mwB7E">%</span> <span class="p" id="mwB7I">{</span><span class="n" id="mwB7M">2</span><span class="p" id="mwB7Q">*</span><span class="nv" id="mwB7U">$_</span><span class="p" id="mwB7Y">}</span> <span class="p" id="mwB7c">)</span>

which is short-hand notation of:

<span id="mwB7s"></span><span class="nv" id="mwB7w">$s</span> <span class="p" id="mwB70">=</span> <span class="n" id="mwB74">0</span><span class="p" id="mwB78">..</span><span class="n" id="mwB8A">100</span> <span class="p" id="mwB8E">|</span> <span class="nb" id="mwB8I">where-object</span> <span class="p" id="mwB8M">{</span><span class="nv" id="mwB8Q">$_</span><span class="p" id="mwB8U">*</span><span class="nv" id="mwB8Y">$_</span> <span class="o" id="mwB8c">-gt</span> <span class="n" id="mwB8g">3</span><span class="p" id="mwB8k">}</span> <span class="p" id="mwB8o">|</span> <span class="k" id="mwB8s">foreach</span><span class="n" id="mwB8w">-object</span> <span class="p" id="mwB80">{</span><span class="n" id="mwB84">2</span><span class="p" id="mwB88">*</span><span class="nv" id="mwB9A">$_</span><span class="p" id="mwB9E">}</span>

Python

Python uses the following syntax to express list comprehensions over finite lists:

<span id="mwB9k"></span><span class="n" id="mwB9o">s</span><span class="p" id="mwB9s">:</span> <span class="nb" id="mwB9w">list</span><span class="p" id="mwB90">[</span><span class="nb" id="mwB94">int</span><span class="p" id="mwB98">]</span> <span class="o" id="mwB-A">=</span> <span class="p" id="mwB-E">[</span><span class="mi" id="mwB-I">2</span> <span class="o" id="mwB-M">*</span> <span class="n" id="mwB-Q">x</span> <span class="k" id="mwB-U">for</span> <span class="n" id="mwB-Y">x</span> <span class="ow" id="mwB-c">in</span> <span class="nb" id="mwB-g">range</span><span class="p" id="mwB-k">(</span><span class="mi" id="mwB-o">100</span><span class="p" id="mwB-s">)</span> <span class="k" id="mwB-w">if</span> <span class="n" id="mwB-0">x</span> <span class="o" id="mwB-4">**</span> <span class="mi" id="mwB-8">2</span> <span class="o" id="mwB_A">></span> <span class="mi" id="mwB_E">3</span><span class="p" id="mwB_I">]</span>

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:

<span id="mwB_k"></span><span class="kn" id="mwB_o">import</span><span class="w" id="mwB_s"> </span><span class="nn" id="mwB_w">itertools</span> <span class="kn" id="mwB_0">from</span><span class="w" id="mwB_4"> </span><span class="nn" id="mwB_8">typing</span><span class="w" id="mwCAA"> </span><span class="kn" id="mwCAE">import</span> <span class="n" id="mwCAI">Iterator</span> <span class="n" id="mwCAM">s</span><span class="p" id="mwCAQ">:</span> <span class="n" id="mwCAU">Iterator</span><span class="p" id="mwCAY">[</span><span class="nb" id="mwCAc">int</span><span class="p" id="mwCAg">]</span> <span class="o" id="mwCAk">=</span> <span class="p" id="mwCAo">(</span><span class="mi" id="mwCAs">2</span> <span class="o" id="mwCAw">*</span> <span class="n" id="mwCA0">x</span> <span class="k" id="mwCA4">for</span> <span class="n" id="mwCA8">x</span> <span class="ow" id="mwCBA">in</span> <span class="n" id="mwCBE">itertools</span><span class="o" id="mwCBI">.</span><span class="n" id="mwCBM">count</span><span class="p" id="mwCBQ">()</span> <span class="k" id="mwCBU">if</span> <span class="n" id="mwCBY">x</span> <span class="o" id="mwCBc">**</span> <span class="mi" id="mwCBg">2</span> <span class="o" id="mwCBk">></span> <span class="mi" id="mwCBo">3</span><span class="p" id="mwCBs">)</span>

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

R

<span id="mwCCI"></span><span class="w" id="mwCCM"> </span><span class="n" id="mwCCQ">x</span><span class="w" id="mwCCU"> </span><span class="o" id="mwCCY"><-</span><span class="w" id="mwCCc"> </span><span class="m" id="mwCCg">0</span><span class="o" id="mwCCk">:</span><span class="m" id="mwCCo">100</span> <span class="w" id="mwCCs"> </span><span class="n" id="mwCCw">S</span><span class="w" id="mwCC0"> </span><span class="o" id="mwCC4"><-</span><span class="w" id="mwCC8"> </span><span class="m" id="mwCDA">2</span><span class="w" id="mwCDE"> </span><span class="o" id="mwCDI">*</span><span class="w" id="mwCDM"> </span><span class="n" id="mwCDQ">x</span><span class="p" id="mwCDU">[</span><span class="n" id="mwCDY">x</span><span class="w" id="mwCDc"> </span><span class="o" id="mwCDg">^</span><span class="w" id="mwCDk"> </span><span class="m" id="mwCDo">2</span><span class="w" id="mwCDs"> </span><span class="o" id="mwCDw">></span><span class="w" id="mwCD0"> </span><span class="m" id="mwCD4">3</span><span class="p" id="mwCD8">]</span>

Racket

<span id="mwCEU"></span><span class="p" id="mwCEY">(</span><span class="k" id="mwCEc">for/list</span><span class="w" id="mwCEg"> </span><span class="p" id="mwCEk">([</span><span class="n" id="mwCEo">x</span><span class="w" id="mwCEs"> </span><span class="mi" id="mwCEw">100</span><span class="p" id="mwCE0">]</span><span class="w" id="mwCE4"> </span><span class="kd" id="mwCE8">#:when</span><span class="w" id="mwCFA"> </span><span class="p" id="mwCFE">(</span><span class="nb" id="mwCFI">></span><span class="w" id="mwCFM"> </span><span class="p" id="mwCFQ">(</span><span class="nb" id="mwCFU">*</span><span class="w" id="mwCFY"> </span><span class="n" id="mwCFc">x</span><span class="w" id="mwCFg"> </span><span class="n" id="mwCFk">x</span><span class="p" id="mwCFo">)</span><span class="w" id="mwCFs"> </span><span class="mi" id="mwCFw">3</span><span class="p" id="mwCF0">))</span><span class="w" id="mwCF4"> </span><span class="p" id="mwCF8">(</span><span class="nb" id="mwCGA">*</span><span class="w" id="mwCGE"> </span><span class="n" id="mwCGI">x</span><span class="w" id="mwCGM"> </span><span class="mi" id="mwCGQ">2</span><span class="p" id="mwCGU">))</span>

An example with multiple generators:

<span id="mwCGk"></span><span class="p" id="mwCGo">(</span><span class="k" id="mwCGs">for*/list</span><span class="w" id="mwCGw"> </span><span class="p" id="mwCG0">([</span><span class="n" id="mwCG4">x</span><span class="w" id="mwCG8"> </span><span class="p" id="mwCHA">(</span><span class="nb" id="mwCHE">in-range</span><span class="w" id="mwCHI"> </span><span class="mi" id="mwCHM">1</span><span class="w" id="mwCHQ"> </span><span class="mi" id="mwCHU">21</span><span class="p" id="mwCHY">)]</span><span class="w" id="mwCHc"> </span><span class="p" id="mwCHg">[</span><span class="n" id="mwCHk">y</span><span class="w" id="mwCHo"> </span><span class="p" id="mwCHs">(</span><span class="nb" id="mwCHw">in-range</span><span class="w" id="mwCH0"> </span><span class="mi" id="mwCH4">1</span><span class="w" id="mwCH8"> </span><span class="mi" id="mwCIA">21</span><span class="p" id="mwCIE">)]</span><span class="w" id="mwCII"> </span><span class="p" id="mwCIM">[</span><span class="n" id="mwCIQ">z</span><span class="w" id="mwCIU"> </span><span class="p" id="mwCIY">(</span><span class="nb" id="mwCIc">in-range</span><span class="w" id="mwCIg"> </span><span class="mi" id="mwCIk">1</span><span class="w" id="mwCIo"> </span><span class="mi" id="mwCIs">21</span><span class="p" id="mwCIw">)]</span> <span class="w" id="mwCI0"> </span><span class="kd" id="mwCI4">#:when</span><span class="w" id="mwCI8"> </span><span class="p" id="mwCJA">(</span><span class="nb" id="mwCJE">=</span><span class="w" id="mwCJI"> </span><span class="p" id="mwCJM">(</span><span class="nb" id="mwCJQ">+</span><span class="w" id="mwCJU"> </span><span class="p" id="mwCJY">(</span><span class="nb" id="mwCJc">*</span><span class="w" id="mwCJg"> </span><span class="n" id="mwCJk">x</span><span class="w" id="mwCJo"> </span><span class="n" id="mwCJs">x</span><span class="p" id="mwCJw">)</span><span class="w" id="mwCJ0"> </span><span class="p" id="mwCJ4">(</span><span class="nb" id="mwCJ8">*</span><span class="w" id="mwCKA"> </span><span class="n" id="mwCKE">y</span><span class="w" id="mwCKI"> </span><span class="n" id="mwCKM">y</span><span class="p" id="mwCKQ">))</span><span class="w" id="mwCKU"> </span><span class="p" id="mwCKY">(</span><span class="nb" id="mwCKc">*</span><span class="w" id="mwCKg"> </span><span class="n" id="mwCKk">z</span><span class="w" id="mwCKo"> </span><span class="n" id="mwCKs">z</span><span class="p" id="mwCKw">)))</span> <span class="w" id="mwCK0"> </span><span class="p" id="mwCK4">(</span><span class="nb" id="mwCK8">list</span><span class="w" id="mwCLA"> </span><span class="n" id="mwCLE">x</span><span class="w" id="mwCLI"> </span><span class="n" id="mwCLM">y</span><span class="w" id="mwCLQ"> </span><span class="n" id="mwCLU">z</span><span class="p" id="mwCLY">))</span>

Raku

<span id="mwCLw"></span> <span class="k" id="mwCL0">my</span> <span class="nv" id="mwCL4">@s</span> = (<span class="nv" id="mwCL8">$_</span> * <span class="mi" id="mwCMA">2</span> <span class="k" id="mwCME">if</span> <span class="nv" id="mwCMI">$_</span> ** <span class="mi" id="mwCMM">2</span> > <span class="mi" id="mwCMQ">3</span> <span class="k" id="mwCMU">for</span> <span class="mi" id="mwCMY">0</span> .. <span class="mi" id="mwCMc">99</span>);

Scala

Using the for-comprehension:

<span id="mwCM4"></span><span class="kd" id="mwCM8">val</span><span class="w" id="mwCNA"> </span><span class="n" id="mwCNE">s</span><span class="w" id="mwCNI"> </span><span class="o" id="mwCNM">=</span><span class="w" id="mwCNQ"> </span><span class="k" id="mwCNU">for</span><span class="w" id="mwCNY"> </span><span class="p" id="mwCNc">(</span><span class="n" id="mwCNg">x</span><span class="w" id="mwCNk"> </span><span class="o" id="mwCNo"><-</span><span class="w" id="mwCNs"> </span><span class="mi" id="mwCNw">0</span><span class="w" id="mwCN0"> </span><span class="n" id="mwCN4">to</span><span class="w" id="mwCN8"> </span><span class="mi" id="mwCOA">100</span><span class="p" id="mwCOE">;</span><span class="w" id="mwCOI"> </span><span class="k" id="mwCOM">if</span><span class="w" id="mwCOQ"> </span><span class="n" id="mwCOU">x</span><span class="o" id="mwCOY">*</span><span class="n" id="mwCOc">x</span><span class="w" id="mwCOg"> </span><span class="o" id="mwCOk">></span><span class="w" id="mwCOo"> </span><span class="mi" id="mwCOs">3</span><span class="p" id="mwCOw">)</span><span class="w" id="mwCO0"> </span><span class="k" id="mwCO4">yield</span><span class="w" id="mwCO8"> </span><span class="mi" id="mwCPA">2</span><span class="o" id="mwCPE">*</span><span class="n" id="mwCPI">x</span>

Scheme

List comprehensions are supported in Scheme through the use of the SRFI-42 library.

<span id="mwCP4"></span><span class="p" id="mwCP8">(</span><span class="nf" id="mwCQA">list-ec</span><span class="w" id="mwCQE"> </span><span class="p" id="mwCQI">(</span><span class="nf" id="mwCQM">:</span><span class="w" id="mwCQQ"> </span><span class="nv" id="mwCQU">x</span><span class="w" id="mwCQY"> </span><span class="mi" id="mwCQc">100</span><span class="p" id="mwCQg">)</span><span class="w" id="mwCQk"> </span><span class="p" id="mwCQo">(</span><span class="k" id="mwCQs">if</span><span class="w" id="mwCQw"> </span><span class="p" id="mwCQ0">(</span><span class="nb" id="mwCQ4">></span><span class="w" id="mwCQ8"> </span><span class="p" id="mwCRA">(</span><span class="nb" id="mwCRE">*</span><span class="w" id="mwCRI"> </span><span class="nv" id="mwCRM">x</span><span class="w" id="mwCRQ"> </span><span class="nv" id="mwCRU">x</span><span class="p" id="mwCRY">)</span><span class="w" id="mwCRc"> </span><span class="mi" id="mwCRg">3</span><span class="p" id="mwCRk">))</span><span class="w" id="mwCRo"> </span><span class="p" id="mwCRs">(</span><span class="nb" id="mwCRw">*</span><span class="w" id="mwCR0"> </span><span class="nv" id="mwCR4">x</span><span class="w" id="mwCR8"> </span><span class="mi" id="mwCSA">2</span><span class="p" id="mwCSE">))</span>