List comprehensions: Difference between revisions

 

A [[wp:List_comprehension|list comprehension]] is a special syntax in some programming languages to describe lists. It is similar to the way mathematicians describe sets, with a ''set comprehension'', hence the name.

 

# They should return either a list or an iterator (something that returns successive members of a collection, in order).

# The syntax has parts corresponding to that of [[wp:Set-builder_notation|set-builder notation]].

 

 

=={{header|ALGOL 68}}==

 

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

 

OP +:= = (REF FLEX[]XYZ lhs, XYZ rhs)FLEX[]XYZ: (

FOR x TO n DO FOR y FROM x+1 TO n DO FOR z FROM y+1 TO n DO IF x*x + y*y = z*z THEN xyz +:= XYZ(x,y,z) FI OD OD OD;

xyz), new line

Output:

<div style="width:full;overflow:scroll"><pre>

+3 +4 +5 +5 +12 +13 +6 +8 +10 +8 +15 +17 +9 +12 +15 +12 +16 +20

</pre></div>

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

comprehend("show", range(1, 20), "triples")

return

return set

}

=={{header|C sharp|C#}}==

===LINQ===

 

static class Program

}

}

 

=={{header|C++}}==

 

#include <cmath>

#include <iostream>

}

}

 

This produces the following output:

<pre>3 4 5 5 12 13 6 8 10 8 15 17 9 12 15 12 16 20</pre>

 

 

#include <iostream>

 

std::cout << x << "," << y << "," << z << "\n";

});

 

Output:

 

=={{header|Clojure}}==

(for [x (range 1 (inc n))

y (range x (inc n))

z (range y (inc n))

:when (= (+ (* x x) (* y y)) (* z z))]

 

=={{header|Common Lisp}}==

Here are the Pythagorean triples:

 

(loop for x from 1 to n

append (loop for y from x to n

append (loop for z from y to n

when (= (+ (* x x) (* y y)) (* z z))

 

We can also define a new macro for list comprehensions. We can implement them easily with the help of the <code>iterate</code> package.

 

(if (cdr l)

`(,@(car l) ,(nest (cdr l)))

`((iter ,outer ,form)

,@(mapcar #'desugar-listc-form forms)

 

We can then define a function to compute Pythagorean triples as follows:

 

(listc (list x y z)

(for x from 1 to n)

(for y from x to n)

(for z from y to n)

 

=={{header|D}}==

D doesn't have list comprehensions. One implementation:

 

TA[] select(TA, TI1, TC1, TI2, TC2, TI3, TC3, TP)

lazy TP where) {

Appender!(TA[]) result;

 

foreach (el1; items1) {

iter3 = el3;

if (where())

}

}

}

 

return result.data;

}

enum int n = 21;

int x, y, z;

writeln(r);

<pre>[[3, 4, 5], [5, 12, 13], [6, 8, 10], [8, 15, 17], [9, 12, 15], [12, 16, 20]]</pre>

 

=={{header|E}}==

 

 

 

=={{header|Efene}}==

 

[(A, B, C) for A in lists.seq(1, N) \

for B in lists.seq(A, N) \

io.format("~p~n", [pythag(20)])

}

 

=={{header|Erlang}}==

 

[ {A,B,C} || A <- lists:seq(1,N),

B <- lists:seq(A,N),

C <- lists:seq(B,N),

A+B+C =< N,

 

=={{header|F Sharp|F#}}==

for b in [a..n] do

for c in [b..n] do

=={{header|GAP}}==

pyth := n ->

Filtered(Cartesian([1 .. n], [1 .. n], [1 .. n]),

# [ [ 3, 4, 5 ], [ 5, 12, 13 ], [ 7, 24, 25 ], [ 8, 15, 17 ], [ 9, 40, 41 ], [ 11, 60, 61 ], [ 12, 35, 37 ],

# [ 13, 84, 85 ], [ 16, 63, 65 ], [ 20, 21, 29 ], [ 28, 45, 53 ], [ 33, 56, 65 ], [ 36, 77, 85 ], [ 39, 80, 89 ],

 

=={{header|Haskell}}==

 

 

 

pyth n = do

 

=={{header|Ioke}}==

x <- 1..20,

y <- x..20,

x * x + y * y == z * z,

[x, y, z]

 

=={{header|J}}==

buildSet=:conjunction def '(#~ v) u y'

triples=: 1 + 3&comb

isPyth=: 2&{"1 = 1&{"1 +&.:*: 0&{"1

 

The idiom here has two major elements:

Example use:

 

3 4 5

5 12 13

8 15 17

9 12 15

 

=={{header|JavaScript}}==

{{trans|Python}}

 

See [https://developer.mozilla.org/en/New_in_JavaScript_1.7#Array_comprehensions here] for more details

 

yield i;

}

 

function triples(n) {

}

 

 

outputs:

9,12,15

12,16,20</pre>

 

=={{header|Lua}}==

Lua doesn't have list comprehensions built in, but they can be constructed from chained coroutines:

 

LC={}

LC.__index = LC

return self:add_iter(function(arg) if pred(arg) then coroutine.yield(arg) end end)

end

 

We can then define a function to compute Pythagorean triples as follows:

 

function get(key)

return (function(arg) return arg[key] end)

print(arg.x, arg.y, arg.z)

end

 

 

=={{header|OCaml}}==

 

 

 

 

 

=={{header|Oz}}==

However, there is a list comprehension package available [http://oz-code.googlecode.com/files/ListComprehension.zip here]. It uses the <em>unofficial and deprecated</em> macro system. Usage example:

 

import

LazyList

 

{Application.exit 0}

 

=={{header|Perl}}==

Perl 5 does not have built-in list comprehension syntax. The closest approach are the list <code>map</code> and <code>grep</code> (elsewhere often known as filter) operators:

 

my ($n) = @_;

map { my $x = $_; map { my $y = $_; map { [$x, $y, $_] } grep { $x**2 + $y**2 == $_**2 } 1..$n } 1..$n } 1..$n;

 

<code>map</code> binds <code>$_</code> to each element of the input list and collects the results from the block. <code>grep</code> returns every element of the input list for which the block returns true. The <code>..</code> operator generates a list of numbers in a specific range.

 

print "@$t\n";

 

 

=={{header|PicoLisp}}==

PicoLisp doesn't have list comprehensions.

===Using a generator function===

(job '((X . 1) (Y . 1) (Z . 0))

(loop

 

(while (pythag 20)

===Using a pipe===

(for X 20

(for Y (range X 20)

(pr (list X Y Z)) ) ) ) )

(while (rd)

===Using a coroutine===

Coroutines are available only in the 64-bit version.

(co 'pythag

(for X N

 

(while (pythag 20)

 

Output in all three cases:

(9 12 15)

(12 16 20)</pre>

 

=={{header|Python}}==

 

 

 

 

=={{header|R}}==

 

 

=={{header|Racket}}==

(for*/list ([x (in-range 1 21)]

[y (in-range x 21)]

#:when (= (+ (* x x) (* y y)) (* z z)))

(list x y z))

 

 

 

 

 

say

 

 

 

 

</pre>

 

=={{header|Ruby}}==

 

Ruby's object-oriented style enforces writing 1..100 before x. Think not of x in 1..100. Think of 1..100 giving x.

 

=== Ruby 1.9.2 ===

{{works with|Ruby|1.9.2}}

 

# select Pythagorean triplets

[[x, y, z]].keep_if { x * x + y * y == z * z }}}})

 

 

Output: <tt>[[3, 4, 5], [5, 12, 13], [6, 8, 10], [8, 15, 17], [9, 12, 15], [12, 16, 20]]</tt>

* The outer <tt>(1..n).flat_map { ... }</tt> concatenates the middle arrays for all x.

 

 

 

 

 

 

 

=={{header|Scala}}==

x <- 1 to 21

y <- x to 21

z <- y to 21

if x * x + y * y == z * z

 

which is a syntactic sugar for:

 

(x to n) flatMap (y =>

(y to n) filter (z => x * x + y * y == z * z) map (z =>

 

Alas, the type of collection returned depends on the type of the collection

To get a <code>List</code> out of it, just pass a <code>List</code> to it:

 

x <- List.range(1, n + 1)

y <- x to 21

z <- y to 21

if x * x + y * y == z * z

 

Sample:

Scheme has no native list comprehensions, but SRFI-42 [http://srfi.schemers.org/srfi-42/srfi-42.html] provides them:

 

(list-ec (:range x 1 21)

(:range y x 21)

(if (= (* z z) (+ (* x x) (* y y))))

(list x y z))

 

<pre>

((3 4 5) (5 12 13) (6 8 10) (8 15 17) (9 12 15) (12 16 20))

</pre>

 

=={{header|Tcl}}==

Tcl does not have list comprehensions built-in to the language, but they can be constructed.

 

# from http://wiki.tcl.tk/12574

 

set range {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20}

<pre>{3 4 5} {5 12 13} {6 8 10} {8 15 17} {9 12 15} {12 16 20}</pre>

 

TI-89 BASIC does not have a true list comprehension, but it has the seq() operator which can be used for some similar purposes.

 

 

produces {1, 4, 9, 16}. When the input is simply a numeric range, an input list is not needed; this produces the same result:

 

 

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Sub Main()

Dim ts = From a In Enumerable.Range(1, 20) _

Next

End Sub

 

Output:

12, 16, 20

</pre>

 

=={{header|Wrapl}}==