List comprehensions: Difference between revisions

m
→‎{{header|Wren}}: Changed to Wren S/H
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(144 intermediate revisions by 36 users not shown)
Line 1:
{{task|Basic language learning}}{{Omit From|C}}{{Omit From|Java}}{{Omit From|Modula-3}}{{omit from|ACL2}}{{omit from|BBC BASIC}}
{{Omit From|Modula-3}}
{{omit from|ACL2}}
{{omit from|BBC BASIC}}
 
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.
 
Some attributes of a list comprehension are that:
# They should be distinct from (nested) for loops and the use of map &and filter functions within the syntax of the language.
# 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]].
 
 
Write a list comprehension that builds the list of all [[Pythagorean triples]] with elements between 1 and n. If the language has multiple ways for expressing such a construct (for example, direct list comprehensions and generators), write one example for each.
;Task:
Write a list comprehension that builds the list of all [[Pythagorean triples]] with elements between   '''1'''   and   '''n'''.
 
If the language has multiple ways for expressing such a construct (for example, direct list comprehensions and generators), write one example for each.
<br><br>
 
=={{header|11l}}==
{{trans|Python}}
 
print(cart_product(1..20, 1..20, 1..20).filter((x, y, z) -> x ^ 2 + y ^ 2 == z ^ 2 & y C x .. z))
 
{{out}}
<pre>
[(3, 4, 5), (5, 12, 13), (6, 8, 10), (8, 15, 17), (9, 12, 15), (12, 16, 20)]
</pre>
 
=={{header|ABAP}}==
 
<syntaxhighlight lang="abap">
<lang ABAP>
CLASS lcl_pythagorean_triplet DEFINITION CREATE PUBLIC.
PUBLIC SECTION.
Line 60 ⟶ 78:
START-OF-SELECTION.
cl_demo_output=>display( lcl_pythagorean_triplet=>get_triplets( n = 20 ) ).
</syntaxhighlight>
</lang>
{{out}}
Line 77 ⟶ 95:
There is no equivalent construct in Ada. In Ada05, the predefined library Ada.Containers
implements 3 types of Doubly_Linked_Lists : Basic; Indefinite; Restricted.
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO; use Ada.Text_IO;
with Ada.Containers.Doubly_Linked_Lists;
 
Line 122 ⟶ 140:
end loop;
end Pythagore_Set;
</syntaxhighlight>
</lang>
 
program output:
Line 139 ⟶ 157:
 
{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}
<langsyntaxhighlight lang="algol68">MODE XYZ = STRUCT(INT x,y,z);
 
OP +:= = (REF FLEX[]XYZ lhs, XYZ rhs)FLEX[]XYZ: (
Line 153 ⟶ 171:
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
))</langsyntaxhighlight>
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|AppleScript}}==
 
AppleScript does not provide built-in notation for list comprehensions. The list monad pattern which underlies list comprehension notation can, however, be used in any language which supports the use of higher order functions and closures. AppleScript can do that, although with limited elegance and clarity, and not entirely without coercion.
 
{{trans|JavaScript}}
<syntaxhighlight lang="applescript">-- List comprehension by direct and unsugared use of list monad
 
-- pythagoreanTriples :: Int -> [(Int, Int, Int)]
on pythagoreanTriples(n)
script x
on |λ|(x)
script y
on |λ|(y)
script z
on |λ|(z)
if x * x + y * y = z * z then
[[x, y, z]]
else
[]
end if
end |λ|
end script
|>>=|(enumFromTo(1 + y, n), z)
end |λ|
end script
|>>=|(enumFromTo(1 + x, n), y)
end |λ|
end script
|>>=|(enumFromTo(1, n), x)
end pythagoreanTriples
 
-- TEST -----------------------------------------------------------------------
on run
-- Pythagorean triples drawn from integers in the range [1..n]
-- {(x, y, z) | x <- [1..n], y <- [x+1..n], z <- [y+1..n], (x^2 + y^2 = z^2)}
pythagoreanTriples(25)
--> {{3, 4, 5}, {5, 12, 13}, {6, 8, 10}, {7, 24, 25}, {8, 15, 17},
-- {9, 12, 15}, {12, 16, 20}, {15, 20, 25}}
end run
 
 
-- GENERIC FUNCTIONS ----------------------------------------------------------
 
-- Monadic (>>=) (or 'bind') for lists is simply flip concatMap
-- (concatMap with arguments reversed)
-- It applies a function f directly to each value in the list,
-- and returns the set of results as a concat-flattened list
 
-- The concatenation eliminates any empty lists,
-- combining list-wrapped results into a single results list
 
-- (>>=) :: Monad m => m a -> (a -> m b) -> m b
on |>>=|(xs, f)
concatMap(f, xs)
end |>>=|
 
-- concatMap :: (a -> [b]) -> [a] -> [b]
on concatMap(f, xs)
set acc to {}
tell mReturn(f)
repeat with x in xs
set acc to acc & |λ|(contents of x)
end repeat
end tell
return acc
end concatMap
 
-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
if n < m then
set d to -1
else
set d to 1
end if
set lst to {}
repeat with i from m to n by d
set end of lst to i
end repeat
return lst
end enumFromTo
 
-- Lift 2nd class handler function into 1st class script wrapper
-- mReturn :: Handler -> Script
on mReturn(f)
if class of f is script then
f
else
script
property |λ| : f
end script
end if
end mReturn</syntaxhighlight>
{{Out}}
<pre>{{3, 4, 5}, {5, 12, 13}, {6, 8, 10}, {7, 24, 25}, {8, 15, 17}, {9, 12, 15}, {12, 16, 20}, {15, 20, 25}}</pre>
 
=={{header|Arturo}}==
 
<syntaxhighlight lang="rebol">n: 20
triplets: @[
loop 1..n 'x [
loop x..n 'y [
loop y..n 'z [if (z^2) = (x^2)+(y^2) -> @[x y z]]
]
]
]
print triplets</syntaxhighlight>
 
{{out}}
 
<pre>[3 4 5] [5 12 13] [6 8 10] [8 15 17] [9 12 15] [12 16 20]</pre>
 
=={{header|AutoHotkey}}==
{{works with|AutoHotkey_L}}
List Comprehension is not built in. <langsyntaxhighlight AutoHotkeylang="autohotkey">
comprehend("show", range(1, 20), "triples")
return
Line 229 ⟶ 364:
return set
}
</syntaxhighlight>
</lang>
 
=={{header|Bracmat}}==
Bracmat does not have built-in list comprehension, but nevertheless there is a solution for fixed n that does not employ explicit loop syntax. By their positions in the pattern and the monotonically increasing values in the subject, it is guaranteed that <code>x</code> always is smaller than <code>y</code> and that <code>y</code> always is smaller than <code>z</code>. The combination of flags <code>%@</code> ensures that <code>x</code>, <code>y</code> and <code>z</code> pick minimally one (<code>%</code>) and at most one (<code>@</code>) element from the subject list.
<langsyntaxhighlight lang="bracmat">
:?py { Initialize the accumulating result list. }
& ( 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 { This is the subject }
Line 249 ⟶ 384:
| out$!py { You get here when backtracking has
exhausted all combinations of x, y and z }
);</langsyntaxhighlight>
Output:
<pre> (12,16,20)
Line 262 ⟶ 397:
C doesn't have a built-in syntax for this, but any problem can be solved if you throw enough macros at it:
{{works with|GCC}}
The program below is C11 compliant. For C99 compilers note the change on line 57 (output remains unchanged).
<lang c>
<syntaxhighlight lang="c">
#include <stdlib.h>
#include <stdio.h>
Line 319 ⟶ 455:
List * intRangeList(int f, int t) {
List * l = listNew(sizeof f, &f), * e = l;
for (int i = f + 1; i <= t; i ++) { e = e->nx = listNew(sizeof i, &i); } // C11 compliant
//int i;
//for (i = f + 1; i <= t; i ++) { e = e->nx = listNew(sizeof i, &i); } // use this for C99
return l;
}
Line 341 ⟶ 479:
return 0;
}
</syntaxhighlight>
</lang>
Output:
<pre>3, 4, 5
Line 355 ⟶ 493:
=={{header|C sharp|C#}}==
===LINQ===
<langsyntaxhighlight lang="csharp">using System.Linq;
 
static class Program
Line 372 ⟶ 510:
}
}
</syntaxhighlight>
</lang>
 
=={{header|C++}}==
There is no equivalent construct in C++. The code below uses two nested loops and an ''if'' statement:
 
<langsyntaxhighlight lang="cpp">#include <vector>
#include <cmath>
#include <iostream>
Line 408 ⟶ 546:
}
}
</syntaxhighlight>
</lang>
 
This produces the following output:
Line 415 ⟶ 553:
{{works with|C++11}}
 
<langsyntaxhighlight lang="cpp">#include <functional>
#include <iostream>
 
Line 438 ⟶ 576:
});
return 0;
}</langsyntaxhighlight>
 
Output:
Line 450 ⟶ 588:
 
=={{header|Clojure}}==
<langsyntaxhighlight lang="lisp">(defn pythagorean-triples [n]
(for [x (range 1 (inc n))
y (range x (inc n))
z (range y (inc n))
:when (= (+ (* x x) (* y y)) (* z z))]
[x y z]))</langsyntaxhighlight>
 
=={{header|CoffeeScript}}==
<langsyntaxhighlight lang="coffeescript">flatten = (arr) -> arr.reduce ((memo, b) -> memo.concat b), []
 
pyth = (n) ->
Line 466 ⟶ 604:
[x, y, z]
))
# pyth can also be written more concisely as
# pyth = (n) -> flatten (flatten ([x, y, z] for z in [y..n] when x*x + y*y is z*z for y in [x..n]) for x in [1..n])
 
console.dir pyth 20</langsyntaxhighlight>
 
<code>pyth</code> can also be written more concisely as
 
<lang coffeescript>pyth = (n) -> flatten (flatten ([x, y, z] for z in [y..n] when x*x + y*y is z*z for y in [x..n]) for x in [1..n])</lang>
 
=={{header|Common Lisp}}==
Line 478 ⟶ 614:
Here are the Pythagorean triples:
 
<langsyntaxhighlight lang="lisp">(defun pythagorean-triples (n)
(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))
collect (list x y z)))))</langsyntaxhighlight>
 
We can also define a new macro for list comprehensions. We can implement them easily with the help of the <code>iterate</code> package.
 
<langsyntaxhighlight lang="lisp">(defun nest (l)
(if (cdr l)
`(,@(car l) ,(nest (cdr l)))
Line 501 ⟶ 637:
`((iter ,outer ,form)
,@(mapcar #'desugar-listc-form forms)
(in ,outer (collect ,expr)))))</langsyntaxhighlight>
 
We can then define a function to compute Pythagorean triples as follows:
 
<langsyntaxhighlight lang="lisp">(defun pythagorean-triples (n)
(listc (list x y z)
(for x from 1 to n)
(for y from x to n)
(for z from y to n)
(when (= (+ (expt x 2) (expt y 2)) (expt z 2)))))</langsyntaxhighlight>
 
=={{header|D}}==
D doesn't have list comprehensions. One implementation:
<langsyntaxhighlight lang="d">import std.stdio, std.typetuplemeta, std.range;
 
TA[] select(TA, TI1, TC1, TI2, TC2, TI3, TC3, TP)
Line 523 ⟶ 659:
lazy TP where) {
Appender!(TA[]) result;
auto iters = TypeTupleAliasSeq!(iter1, iter2, iter3);
 
foreach (el1; items1) {
Line 537 ⟶ 673:
}
 
TypeTupleAliasSeq!(iter1, iter2, iter3) = iters;
return result.data;
}
Line 547 ⟶ 683:
iota(y, n + 1), x*x + y*y == z*z);
writeln(r);
}</langsyntaxhighlight>
{{out}}
<pre>[[3, 4, 5], [5, 12, 13], [6, 8, 10], [8, 15, 17], [9, 12, 15], [12, 16, 20]]</pre>
Line 553 ⟶ 689:
=={{header|E}}==
 
<langsyntaxhighlight lang="e">pragma.enable("accumulator") # considered experimental
 
accum [] for x in 1..n { for y in x..n { for z in y..n { if (x**2 + y**2 <=> z**2) { _.with([x,y,z]) } } } }</langsyntaxhighlight>
 
=={{header|EchoLisp}}==
<langsyntaxhighlight lang="lisp">
;; copied from Racket
 
Line 567 ⟶ 703:
(list x y z))
→ ((3 4 5) (5 12 13) (6 8 10) (8 15 17) (9 12 15) (12 16 20))
</syntaxhighlight>
</lang>
 
=={{header|Efene}}==
 
<langsyntaxhighlight lang="efene">pythag = fn (N) {
[(A, B, C) for A in lists.seq(1, N) \
for B in lists.seq(A, N) \
Line 582 ⟶ 718:
io.format("~p~n", [pythag(20)])
}
</syntaxhighlight>
</lang>
 
=={{header|Ela}}==
 
<langsyntaxhighlight lang="ela">pyth n = [(x,y,z) \\ x <- [1..n], y <- [x..n], z <- [y..n] | x**2 + y**2 == z**2]</langsyntaxhighlight>
 
=={{header|Elixir}}==
Line 600 ⟶ 736:
=={{header|Erlang}}==
 
<langsyntaxhighlight lang="erlang">pythag(N) ->
[ {A,B,C} || A <- lists:seq(1,N),
B <- lists:seq(A,N),
C <- lists:seq(B,N),
A+B+C =< N,
A*A+B*B == C*C ].</langsyntaxhighlight>
 
=={{header|F Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">let pyth n = [ for a in [1..n] do
for b in [a..n] do
for c in [b..n] do
if (a*a+b*b = c*c) then yield (a,b,c)]</langsyntaxhighlight>
 
=={{header|Factor}}==
Factor does not support list comprehensions by default. The <code>backtrack</code> vocabulary can make for a faithful imitation, however.
<syntaxhighlight lang="factor">USING: backtrack kernel locals math math.ranges ;
 
:: pythagorean-triples ( n -- seq )
[
n [1,b] amb-lazy :> a
a n [a,b] amb-lazy :> b
b n [a,b] amb-lazy :> c
a a * b b * + c c * = must-be-true { a b c }
] bag-of ;</syntaxhighlight>
 
=={{header|Fortran}}==
 
Complex numbers simplify the task. However, the reshape intrinsic function along with implicit do loops can generate high rank matrices.
<syntaxhighlight lang="fortran">
<lang FORTRAN>
!-*- mode: compilation; default-directory: "/tmp/" -*-
!Compilation started at Fri Jun 7 23:39:20
Line 648 ⟶ 796:
print '(3i4)',d(:,:i)
end program list_comprehension
</syntaxhighlight>
</lang>
 
 
=={{header|FreeBASIC}}==
{{trans|Run BASIC}}
FreeBASIC no tiene listas de comprensión. Una implementación:
<syntaxhighlight lang="freebasic">Dim As Integer x, y, z, n = 25
For x = 1 To n
For y = x To n
For z = y To n
If x^2 + y^2 = z^2 Then Print Using "{##_, ##_, ##}"; x; y; z
Next z
Next y
Next x
Sleep</syntaxhighlight>
{{out}}
<pre>
{ 3, 4, 5}
{ 5, 12, 13}
{ 6, 8, 10}
{ 7, 24, 25}
{ 8, 15, 17}
{ 9, 12, 15}
{12, 16, 20}
{15, 20, 25}
</pre>
 
 
=={{header|FunL}}==
<langsyntaxhighlight lang="funl">def triples( n ) = [(a, b, c) | a <- 1..n-2, b <- a+1..n-1, c <- b+1..n if a^2 + b^2 == c^2]
 
println( triples(20) )</langsyntaxhighlight>
 
{{out}}
Line 662 ⟶ 836:
 
=={{header|GAP}}==
<langsyntaxhighlight lang="gap"># We keep only primitive pythagorean triples
pyth := n ->
Filtered(Cartesian([1 .. n], [1 .. n], [1 .. n]),
Line 671 ⟶ 845:
# [ [ 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 ],
# [ 48, 55, 73 ], [ 65, 72, 97 ] ]</langsyntaxhighlight>
 
=={{header|Go}}==
Go doesn't have special syntax for list comprehensions but we can build a function which behaves similarly.
<syntaxhighlight lang="go">package main
 
import "fmt"
 
type (
seq []int
sofs []seq
)
 
func newSeq(start, end int) seq {
if end < start {
end = start
}
s := make(seq, end-start+1)
for i := 0; i < len(s); i++ {
s[i] = start + i
}
return s
}
 
func newSofs() sofs {
return sofs{seq{}}
}
 
func (s sofs) listComp(in seq, expr func(sofs, seq) sofs, pred func(seq) bool) sofs {
var s2 sofs
for _, t := range expr(s, in) {
if pred(t) {
s2 = append(s2, t)
}
}
return s2
}
 
func (s sofs) build(t seq) sofs {
var u sofs
for _, ss := range s {
for _, tt := range t {
uu := make(seq, len(ss))
copy(uu, ss)
uu = append(uu, tt)
u = append(u, uu)
}
}
return u
}
 
func main() {
pt := newSofs()
in := newSeq(1, 20)
expr := func(s sofs, t seq) sofs {
return s.build(t).build(t).build(t)
}
pred := func(t seq) bool {
if len(t) != 3 {
return false
}
return t[0]*t[0]+t[1]*t[1] == t[2]*t[2] && t[0] < t[1] && t[1] < t[2]
}
pt = pt.listComp(in, expr, pred)
fmt.Println(pt)
}</syntaxhighlight>
 
{{out}}
<pre>
[[3 4 5] [5 12 13] [6 8 10] [8 15 17] [9 12 15] [12 16 20]]
</pre>
 
=={{header|Haskell}}==
<syntaxhighlight lang ="haskell">pyth n:: = [(x,y,z) | xInt <-> [1..n](Int, y <- [x..n]Int, z <- [y..nInt)], x^2 + y^2 == z^2]</lang>
pyth n =
[ (x, y, z)
| x <- [1 .. n]
, y <- [x .. n]
, z <- [y .. n]
, x ^ 2 + y ^ 2 == z ^ 2 ]</syntaxhighlight>
 
List-comprehensions and do notation are two alternative and equivalent forms of syntactic sugar in Haskell.
Since lists are [http://haskell.org/haskellwiki/Monad monads], one can alternatively also use the do-notation (which is practical if the comprehension is large):
 
The list comprehension above could be re-sugared in Do notation as:
<lang haskell>import Control.Monad
 
<syntaxhighlight lang="haskell">pyth :: Int -> [(Int, Int, Int)]
pyth n = do
x <- [1 .. n]
y <- [x .. n]
z <- [y .. n]
guard $if x ^ 2 + y ^ 2 == z ^ 2
returnthen [(x, y, z)</lang>]
else []</syntaxhighlight>
 
and both of the above could be de-sugared to:
=={{header|Icon}} and {{header|unicon}} ==
<syntaxhighlight lang="haskell">pyth :: Int -> [(Int, Int, Int)]
pyth n =
[1 .. n] >>=
\x ->
[x .. n] >>=
\y ->
[y .. n] >>=
\z ->
case x ^ 2 + y ^ 2 == z ^ 2 of
True -> [(x, y, z)]
_ -> []</syntaxhighlight>
 
which can be further specialised (given the particular context of the list monad,
 
in which (>>=) is flip concatMap, pure is flip (:) [], and empty is []) to:
 
<syntaxhighlight lang="haskell">pyth :: Int -> [(Int, Int, Int)]
pyth n =
concatMap
(\x ->
concatMap
(\y ->
concatMap
(\z ->
if x ^ 2 + y ^ 2 == z ^ 2
then [(x, y, z)]
else [])
[y .. n])
[x .. n])
[1 .. n]
 
main :: IO ()
main = print $ pyth 25</syntaxhighlight>
{{Out}}
<pre>[(3,4,5),(5,12,13),(6,8,10),(7,24,25),(8,15,17),(9,12,15),(12,16,20),(15,20,25)]</pre>
 
Finally an alternative to the list comprehension from the beginning. First introduce all triplets:
 
<syntaxhighlight lang="haskell">triplets n = [(x, y, z) | x <- [1 .. n], y <- [x .. n], z <- [y .. n]]</syntaxhighlight>
 
If we apply this to our list comprehension we get this tidy line of code:
 
<syntaxhighlight lang="haskell">[(x, y, z) | (x, y, z) <- triplets n, x^2 + y^2 == z^2]</syntaxhighlight>
 
=={{header|Hy}}==
<syntaxhighlight lang="clojure">(defn triples [n]
(list-comp (, a b c) [a (range 1 (inc n))
b (range a (inc n))
c (range b (inc n))]
(= (pow c 2)
(+ (pow a 2)
(pow b 2)))))
 
(print (triples 15))
; [(3, 4, 5), (5, 12, 13), (6, 8, 10), (9, 12, 15)]</syntaxhighlight>
 
=={{header|Icon}} and {{header|Unicon}}==
 
Icon's (and Unicon's) natural goal-directly evaluation produces result
Line 693 ⟶ 1,002:
expression:
 
<langsyntaxhighlight lang="unicon">
|(x := seq(), x^2 > 3, x*2)
</syntaxhighlight>
</lang>
 
is capable of producing successive elements from the infinite list described in the
Wikipedia article. For example, to produce the first 100 elements:
 
<langsyntaxhighlight lang="unicon">
procedure main()
every write(|(x := seq(), x^2 > 3, x*2) \ 100
end
</syntaxhighlight>
</lang>
 
While result sequences are lexically bound to the code that describes them,
Line 711 ⟶ 1,020:
with (works in both languages):
 
<langsyntaxhighlight lang="unicon">procedure main(a)
n := integer(!a) | 20
s := create (x := 1 to n, y := x to n, z := y to n, x^2+y^2 = z^2, [x,y,z])
while a := @s do write(a[1]," ",a[2]," ",a[3])
end</langsyntaxhighlight>
 
Sample output:
Line 727 ⟶ 1,036:
12 16 20
->
</pre>
 
=={{header|Insitux}}==
 
{{Trans|Clojure}}
 
<syntaxhighlight lang="insitux">
(function pythagorean-triples n
(let n+1 (inc n))
(for x (range 1 n+1)
y (range x n+1)
z (range y n+1)
(unless (= (+ (* x x) (* y y)) (* z z))
(continue))
[x y z]))
 
(pythagorean-triples 20)
</syntaxhighlight>
{{out}}
<pre>
[[3 4 5] [5 12 13] [6 8 10] [8 15 17] [9 12 15] [12 16 20]]
</pre>
 
=={{header|Ioke}}==
<langsyntaxhighlight lang="ioke">for(
x <- 1..20,
y <- x..20,
Line 736 ⟶ 1,066:
x * x + y * y == z * z,
[x, y, z]
)</langsyntaxhighlight>
 
=={{header|J}}==
<langsyntaxhighlight Jlang="j">require'stats'
buildSet=:conjunction def '(#~ v) u y'
triples=: 1 + 3&comb
isPyth=: 2&{"1 = 1&{"1 +&.:*: 0&{"1
pythTr=: triples buildSet isPyth</langsyntaxhighlight>
 
The idiom here has two major elements:
Line 759 ⟶ 1,089:
Example use:
 
<langsyntaxhighlight Jlang="j"> pythTr 20
3 4 5
5 12 13
Line 765 ⟶ 1,095:
8 15 17
9 12 15
12 16 20</langsyntaxhighlight>
 
=={{header|Java}}==
Java can stream a list, allowing something like a list comprehension. The syntax is (unsurprisingly) verbose, so you might wonder how good the likeness is. I've labeled the parts according to the description in Wikipedia.
 
Using list-of-arrays made the syntax easier than list-of-lists, but meant that you need the "output expression" part to get to something easily printable.
<syntaxhighlight lang="java">// Boilerplate
import java.util.Arrays;
import java.util.List;
import static java.util.function.Function.identity;
import static java.util.stream.Collectors.toList;
import static java.util.stream.IntStream.range;
public interface PythagComp{
static void main(String... args){
System.out.println(run(20));
}
 
static List<List<Integer>> run(int n){
return
// Here comes the list comprehension bit
// input stream - bit clunky
range(1, n).mapToObj(
x -> range(x, n).mapToObj(
y -> range(y, n).mapToObj(
z -> new Integer[]{x, y, z}
)
)
)
.flatMap(identity())
.flatMap(identity())
// predicate
.filter(a -> a[0]*a[0] + a[1]*a[1] == a[2]*a[2])
// output expression
.map(Arrays::asList)
// the result is a list
.collect(toList())
;
}
}
</syntaxhighlight>
{{Out}}
<pre>[[3, 4, 5], [5, 12, 13], [6, 8, 10], [8, 15, 17], [9, 12, 15]]</pre>
 
=={{header|JavaScript}}==
 
{{objection expresses misapprehension and divergence from terms of reference. List comprehension syntax shown is identical to that of Mathematica example. *All* syntax renames lambda applications}}
===ES5===
 
ES5 does not provide built-in notation for list comprehensions. The list monad pattern which underlies list comprehension notation can, however, be used in any language which supports the use of higher order functions. The following shows how we can achieve the same result by directly using a list monad in ES5, without the abbreviating convenience of any specific syntactic sugar.
 
<syntaxhighlight lang="javascript">// USING A LIST MONAD DIRECTLY, WITHOUT SPECIAL SYNTAX FOR LIST COMPREHENSIONS
 
(function (n) {
 
return mb(r(1, n), function (x) { // x <- [1..n]
return mb(r(1 + x, n), function (y) { // y <- [1+x..n]
return mb(r(1 + y, n), function (z) { // z <- [1+y..n]
return x * x + y * y === z * z ? [[x, y, z]] : [];
})})});
 
 
// LIBRARY FUNCTIONS
// Monadic bind for lists
function mb(xs, f) {
return [].concat.apply([], xs.map(f));
}
// Monadic return for lists is simply lambda x -> [x]
// as in [[x, y, z]] : [] above
 
// Integer range [m..n]
function r(m, n) {
return Array.apply(null, Array(n - m + 1))
.map(function (n, x) {
return m + x;
});
}
 
})(100);</syntaxhighlight>
 
Output:
 
<pre>[[3, 4, 5], [5, 12, 13], [6, 8, 10], [7, 24, 25], [8, 15, 17], [9, 12, 15], [9, 40, 41], [10, 24, 26], [11, 60, 61], [12, 16, 20], [12, 35, 37], [13, 84, 85], [14, 48, 50], [15, 20, 25], [15, 36, 39], [16, 30, 34], [16, 63, 65], [18, 24, 30], [18, 80, 82], [20, 21, 29], [20, 48, 52], [21, 28, 35], [21, 72, 75], [24, 32, 40], [24, 45, 51], [24, 70, 74], [25, 60, 65], [27, 36, 45], [28, 45, 53], [28, 96, 100], [30, 40, 50], [30, 72, 78], [32, 60, 68], [33, 44, 55], [33, 56, 65], [35, 84, 91], [36, 48, 60], [36, 77, 85], [39, 52, 65], [39, 80, 89], [40, 42, 58], [40, 75, 85], [42, 56, 70], [45, 60, 75], [48, 55, 73], [48, 64, 80], [51, 68, 85], [54, 72, 90], [57, 76, 95], [60, 63, 87], [60, 80, 100], [65, 72, 97]]</pre>
 
===ES6===
{{trans|Python}}
 
Line 775 ⟶ 1,188:
See [https://developer.mozilla.org/en/New_in_JavaScript_1.7#Array_comprehensions here] for more details
 
<langsyntaxhighlight lang="javascript">function range(begin, end) {
for (let i = begin; i < end; ++i)
yield i;
}
 
function triples(n) {
return [[x,y,z] for each (x in range(1,n+1))
[x, for each (y in range(x,n+1)) z]
for each (zx in range(y1, n + 1))
for each(y in if range(x*x, n + y*y == z*z1)) ]
for each(z in range(y, n + 1))
if (x * x + y * y == z * z)
]
}
 
for each (var triple in triples(20))
print(triple);</langsyntaxhighlight>
 
outputs:
Line 799 ⟶ 1,215:
 
 
List comprehension notation was not, in the end, included in the final ES6 standard, and the code above will not run in fully ES6-compliant browsers or interpreters, but we can still go straight to the underlying monadic logic of list comprehensions and obtain:
In JavaScript 1.6 onwards (while we await JavaScript 1.7's syntactic sugar for array comprehensions) we can write a list comprehension by applying an anonymous function (returning a boolean value) over a functionally defined set (without recourse to iteration), using the same syntax as the [[#Mathematica|Mathematica]] example:
 
<code>[ (x, y, z)
<lang javascript>select(nTuples(range(1, 100), 3), function ([x, y, z]) {
| x <- [1 return.. n], y <- [x *.. n], z <- [y .. n], x ^ 2 + y *^ y2 === z *^ z;2 ]</code>
});
 
by using <code>concatMap</code> (the monadic bind function for lists), and <code>x => [x]</code> (monadic pure/return for lists):
// nTuples(range(20), 3) --> [[1, 2, 3], [1, 2, 4] ... [17, 19, 20], [18, 19, 20]] (1140 tuples)
function nTuples(lst, n) {
var m = lst.length,
x = m ? [lst[0]] : null,
xs = m ? lst.slice(1) : null;
 
<syntaxhighlight lang="javascript">(n => {
return (!n || m < n) ? [] : (
'use strict';
n === 1 ? lst.map(function (p) {
return [p];
}) : (
nTuples(xs, n - 1).map(function (t) {
return x.concat(t);
}).concat(nTuples(xs, n))
)
)
}
 
// GENERIC FUNCTIONS ------------------------------------------------------
// range(1, 20) --> [1..20]
function range(m, n) {
return Array.apply(null, Array(n - m + 1)).map(
function (x, i) {
return m + i;
}
)
}
 
// concatMap :: (a -> [b]) -> [a] -> [b]
function select(lstSet, fnPredicate) {
const concatMap = (f, xs) => [].concat.apply([], xs.map(f));
return lstSet.filter(fnPredicate);
}</lang>
 
// enumFromTo :: Int -> Int -> [Int]
Output:
const enumFromTo = (m, n) =>
Array.from({
length: Math.floor(n - m) + 1
}, (_, i) => m + i);
 
 
<pre>[[3, 4, 5], [5, 12, 13], [6, 8, 10], [7, 24, 25], [8, 15, 17], [9, 12, 15], [9, 40, 41], [10, 24, 26], [11, 60, 61], [12, 16, 20], [12, 35, 37], [13, 84, 85], [14, 48, 50], [15, 20, 25], [15, 36, 39], [16, 30, 34], [16, 63, 65], [18, 24, 30], [18, 80, 82], [20, 21, 29], [20, 48, 52], [21, 28, 35], [21, 72, 75], [24, 32, 40], [24, 45, 51], [24, 70, 74], [25, 60, 65], [27, 36, 45], [28, 45, 53], [28, 96, 100], [30, 40, 50], [30, 72, 78], [32, 60, 68], [33, 44, 55], [33, 56, 65], [35, 84, 91], [36, 48, 60], [36, 77, 85], [39, 52, 65], [39, 80, 89], [40, 42, 58], [40, 75, 85], [42, 56, 70], [45, 60, 75], [48, 55, 73], [48, 64, 80], [51, 68, 85], [54, 72, 90], [57, 76, 95], [60, 63, 87], [60, 80, 100], [65, 72, 97]]</pre>
// EXAMPLE ----------------------------------------------------------------
 
// [(x, y, z) | x <- [1..n], y <- [x..n], z <- [y..n], x ^ 2 + y ^ 2 == z ^ 2]
 
return concatMap(x =>
concatMap(y =>
concatMap(z =>
 
x * x + y * y === z * z ? [
[x, y, z]
] : [],
 
enumFromTo(y, n)),
enumFromTo(x, n)),
enumFromTo(1, n));
})(20);</syntaxhighlight>
 
Or, expressed in terms of bind (>>=)
 
<syntaxhighlight lang="javascript">(n => {
'use strict';
 
// GENERIC FUNCTIONS ------------------------------------------------------
 
// bind (>>=) :: Monad m => m a -> (a -> m b) -> m b
const bind = (m, mf) =>
Array.isArray(m) ? (
bindList(m, mf)
) : bindMay(m, mf);
 
// bindList (>>=) :: [a] -> (a -> [b]) -> [b]
const bindList = (xs, mf) => [].concat.apply([], xs.map(mf));
 
// enumFromTo :: Enum a => a -> a -> [a]
const enumFromTo = (m, n) =>
(typeof m !== 'number' ? (
enumFromToChar
) : enumFromToInt)
.apply(null, [m, n]);
 
// enumFromToInt :: Int -> Int -> [Int]
const enumFromToInt = (m, n) =>
Array.from({
length: Math.floor(n - m) + 1
}, (_, i) => m + i);
 
 
// EXAMPLE ----------------------------------------------------------------
 
// [(x, y, z) | x <- [1..n], y <- [x..n], z <- [y..n], x ^ 2 + y ^ 2 == z ^ 2]
 
return bind(enumFromTo(1, n),
x => bind(enumFromTo(x, n),
y => bind(enumFromTo(y, n),
z => x * x + y * y === z * z ? [
[x, y, z]
] : []
)));
 
})(20);</syntaxhighlight>
{{Out}}
<syntaxhighlight lang="javascript">[[3, 4, 5], [5, 12, 13], [6, 8, 10], [8, 15, 17], [9, 12, 15], [12, 16, 20]]</syntaxhighlight>
 
=={{header|jq}}==
'''Direct approach''':<langsyntaxhighlight lang="jq">def triples(n):
range(1;n+1) as $x | range($x;n+1) as $y | range($y;n+1) as $z
| select($x*$x + $y*$y == $z*$z)
| [$x, $y, $z] ;
</syntaxhighlight>
</lang>
 
'''Using listof(stream; criterion)'''
<syntaxhighlight lang="jq"># listof( stream; criterion) constructs an array of those
<lang jq>
# listof( stream; criterion) constructs an array of those
# elements in the stream that satisfy the criterion
def listof( stream; criterion): [ stream|select(criterion) ];
Line 857 ⟶ 1,317:
.[0] * .[0] + .[1] * .[1] == .[2] * .[2] ) ;
 
listof_triples(20)</syntaxhighlight>
{{out}}
</lang>
<pre>
# {{Out}}
$ jq -c -n -f list_of_triples.jq
[[3,4,5],[5,12,13],[6,8,10],[8,15,17],[9,12,15],[12,16,20]]
</pre>
 
=={{header|Julia}}==
Array comprehension:
<lang Julia>const n = 20
 
sort(filter(x -> x[1] < x[2] && x[1]^2 + x[2]^2 == x[3]^2, [(a, b, c) for a=1:n, b=1:n, c=1:n]))</lang>
<syntaxhighlight lang="julia">
julia> n = 20
20
 
julia> [(x, y, z) for x = 1:n for y = x:n for z = y:n if x^2 + y^2 == z^2]
6-element Array{Tuple{Int64,Int64,Int64},1}:
(3,4,5)
(5,12,13)
(6,8,10)
(8,15,17)
(9,12,15)
(12,16,20)
</syntaxhighlight>
 
A Julia generator comprehension (note the outer round brackets), returns an iterator over the same result rather than an explicit array:
 
<syntaxhighlight lang="julia">
julia> ((x, y, z) for x = 1:n for y = x:n for z = y:n if x^2 + y^2 == z^2)
Base.Flatten{Base.Generator{UnitRange{Int64},##33#37}}(Base.Generator{UnitRange{Int64},##33#37}(#33,1:20))
 
julia> collect(ans)
6-element Array{Tuple{Int64,Int64,Int64},1}:
(3,4,5)
(5,12,13)
(6,8,10)
(8,15,17)
(9,12,15)
(12,16,20)
</syntaxhighlight>
 
Array comprehensions may also be N-dimensional, not just vectors:
 
<syntaxhighlight lang="julia">
julia> [i + j for i in 1:5, j in 1:5]
5×5 Array{Int64,2}:
2 3 4 5 6
3 4 5 6 7
4 5 6 7 8
5 6 7 8 9
6 7 8 9 10
 
julia> [i + j for i in 1:5, j in 1:5, k in 1:2]
5×5×2 Array{Int64,3}:
[:, :, 1] =
2 3 4 5 6
3 4 5 6 7
4 5 6 7 8
5 6 7 8 9
6 7 8 9 10
 
[:, :, 2] =
2 3 4 5 6
3 4 5 6 7
4 5 6 7 8
5 6 7 8 9
6 7 8 9 10
</syntaxhighlight>
 
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.0.6
 
fun pythagoreanTriples(n: Int) =
(1..n).flatMap {
x -> (x..n).flatMap {
y -> (y..n).filter {
z -> x * x + y * y == z * z
}.map { Triple(x, y, it) }
}
}
 
fun main(args: Array<String>) {
println(pythagoreanTriples(20))
}</syntaxhighlight>
 
{{out}}
<pre>
<pre>[(3,4,5),(5,12,13),(6,8,10),(8,15,17),(9,12,15),(12,16,20)]</pre>
[(3, 4, 5), (5, 12, 13), (6, 8, 10), (8, 15, 17), (9, 12, 15), (12, 16, 20)]
</pre>
 
=={{header|Lasso}}==
Lasso uses query expressions for list manipulation.
<langsyntaxhighlight lang="lasso">#!/usr/bin/lasso9
 
local(n = 20)
Line 882 ⟶ 1,418:
select (:#x, #y, #z)
)
#triples->join('\n')</langsyntaxhighlight>
Output:
<langsyntaxhighlight lang="lasso">staticarray(3, 4, 5)
staticarray(5, 12, 13)
staticarray(6, 8, 10)
staticarray(8, 15, 17)
staticarray(9, 12, 15)
staticarray(12, 16, 20)</langsyntaxhighlight>
 
=={{header|Lua}}==
Lua doesn't have list comprehensions built in, but they can be constructed from chained coroutines:
 
<langsyntaxhighlight lang="lua">
LC={}
LC.__index = LC
Line 929 ⟶ 1,465:
return self:add_iter(function(arg) if pred(arg) then coroutine.yield(arg) end end)
end
</syntaxhighlight>
</lang>
 
We can then define a function to compute Pythagorean triples as follows:
 
<langsyntaxhighlight lang="lua">
function get(key)
return (function(arg) return arg[key] end)
Line 949 ⟶ 1,485:
print(arg.x, arg.y, arg.z)
end
</syntaxhighlight>
</lang>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight lang="mathematica">Select[Tuples[Range[100], 3], #1[[1]]^2 + #1[[2]]^2 == #1[[3]]^2 &]</langsyntaxhighlight>
 
<langsyntaxhighlight lang="mathematica">Pick[#, (#^2).{1, 1, -1}, 0] &@Tuples[Range[100], 3]</langsyntaxhighlight>
 
=={{header|MATLAB}} / {{header|Octave}}==
 
In Matlab/Octave, one does not think much about lists rather than vectors and matrices. Probably, the find() operation comes closes to the task
<langsyntaxhighlight Matlablang="matlab">N = 20
[a,b] = meshgrid(1:N, 1:N);
c = sqrt(a.^2 + b.^2);
[x,y] = find(c == fix(c));
disp([x, y, sqrt(x.^2 + y.^2)])</langsyntaxhighlight>
 
{{out}}
Line 987 ⟶ 1,523:
''Solutions'' behaves like list comprehension since compound goals resemble set-builder notation.
 
<langsyntaxhighlight lang="mercury">
:- module pythtrip.
:- interface.
Line 1,012 ⟶ 1,548:
solutions((pred(Triple::out) is nondet :- pythTrip(20,Triple)),Result),
write(Result,!IO).
</syntaxhighlight>
</lang>
 
=={{header|Nemerle}}==
Demonstrating a list comprehension and an iterator. List comprehension adapted from Haskell example, iterator adapted from C# example.
<langsyntaxhighlight Nemerlelang="nemerle">using System;
using System.Console;
using System.Collections.Generic;
Line 1,054 ⟶ 1,590:
}
}
}</langsyntaxhighlight>
 
=={{header|Nim}}==
 
There are no list comprehensions in Nim, but thanks to the strong metaprogramming capabilities we can implement our own:
List comprehension is done in the standard library with the collect() macro (which uses for-loop macros) from the sugar package:
<lang nim>import macros
<syntaxhighlight lang="nim">import sugar, math
 
let n = 20
let triplets = collect(newSeq):
for x in 1..n:
for y in x..n:
for z in y..n:
if x^2 + y^2 == z^2:
(x,y,z)
echo triplets</syntaxhighlight>
Output:
<pre>@[(3, 4, 5), (5, 12, 13), (6, 8, 10), (8, 15, 17), (9, 12, 15), (12, 16, 20)]</pre>
 
A special syntax for list comprehensions in Nim can be implemented thanks to the strong metaprogramming capabilities:
<syntaxhighlight lang="nim">import macros
 
type ListComprehension = object
var lc*: ListComprehension
 
macro `[]`*(lc: ListComprehension, x, t): expruntyped =
expectLen(x, 3)
expectKind(x, nnkInfix)
expectKind(x[0], nnkIdent)
assert($x[0].identstrVal == "|")
 
result = newCall(
Line 1,079 ⟶ 1,630:
expectKind(y, nnkInfix)
expectMinLen(y, 1)
if y[0].kind == nnkIdent and $y[0].identstrVal == "<-":
expectLen(y, 3)
result = newNimNode(nnkForStmt).add(y[1], y[2], result)
Line 1,106 ⟶ 1,657:
 
const n = 20
echo lc[(x,y,z) | (x <- 1..n, y <- x..n, z <- y..n, x*x + y*y == z*z), tuple[a,b,c: int]]</syntaxhighlight>
tuple[a,b,c: int]]</lang>
Output:
<pre>@[(a: 3, b: 4, c: 5), (a: 5, b: 12, c: 13), (a: 6, b: 8, c: 10), (a: 8, b: 15, c: 17), (a: 9, b: 12, c: 15), (a: 12, b: 16, c: 20)]</pre>
Line 1,113 ⟶ 1,663:
=={{header|OCaml}}==
 
As of OCaml 4.08 (2019), [https://v2.ocaml.org/manual/bindingops.html binding operators] were added to the language syntax. A general notion of "comprehension syntax" can be recovered using them.
[http://batteries.forge.ocamlcore.org/ OCaml Batteries Included] has uniform comprehension syntax for lists, arrays, enumerations (like streams), lazy lists (like lists but evaluated on-demand), sets, hashtables, etc.
 
ComprehensionAssuming area comprehension is of the form
<code>[? expression | x <- enumeration ; condition; condition ; ... ]</code>
We can rewrite it using binding operators like so
<syntaxhighlight lang="ocaml">let* x = enumeration in
if not condition then empty else
return expression
</syntaxhighlight>
 
For instance, we can write the required Pythagorean triples comprehension:
For instance,
<lang ocaml># [? 2 * x | x <- 0 -- max_int ; x * x > 3];;
- : int Enum.t = <abstr></lang>
or, to compute a list,
<lang ocaml># [? List: 2 * x | x <- 0 -- 100 ; x * x > 3];;
- : int list = [2; 4; 6; 8; 10]</lang>
or, to compute a set,
<lang ocaml># [? PSet: 2 * x | x <- 0 -- 100 ; x * x > 3];;
- : int PSet.t = <abstr></lang>
 
<syntaxhighlight lang="ocaml">let pyth n =
etc..
let* x = 1 -- n in
let* y = x -- n in
let* z = y -- n in
if x * x + y * y <> z * z then [] else
[x, y, z]
</syntaxhighlight>
 
where the <code>(let*)</code> and <code>(--)</code> operators are defined for the <code>List</code> module like so:
 
<syntaxhighlight lang="ocaml">let (let*) xs f = List.concat_map f xs
let (--) a b = List.init (b-a+1) ((+)a)
</syntaxhighlight>
 
=====Historical note=====
 
:OCaml never had a built-in list-comprehension syntax. However, there have been a couple of preprocessing syntax extensions which aimed to add list comprehensions sugar to the language. One of which was shipped directly with [https://github.com/camlp4/camlp4 camlp4], a tool for syntax extensions that was bundled with the OCaml compiler distribution, up to version 4.02 (2014), and was completely deprecated after version 4.08 (2019).
 
:Another, [https://github.com/ocaml-batteries-team/batteries-included OCaml Batteries Included], had uniform comprehension syntax for lists, arrays, enumerations (like streams), lazy lists (like lists but evaluated on-demand), sets, hashtables, etc. This later split into the now legacy package [https://github.com/murmour/pa_comprehension pa_comprehensions], which is similarly deprecated.
 
=={{header|Oz}}==
Line 1,135 ⟶ 1,700:
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:
 
<langsyntaxhighlight lang="oz">functor
import
LazyList
Line 1,154 ⟶ 1,719:
 
{Application.exit 0}
end</langsyntaxhighlight>
 
=={{header|PARI/GP}}==
GP 2.6.0 added support for a new comprehension syntax:
{{works with|PARI/GP|2.6.0 and above}}
<langsyntaxhighlight lang="parigp">f(n)=[v|v<-vector(n^3,i,vector(3,j,i\n^(j-1)%n)),norml2(v)==2*v[3]^2]</langsyntaxhighlight>
 
Older versions of GP can emulate this through <code>select</code>:
{{PARI/GP select}}
<langsyntaxhighlight lang="parigp">f(n)=select(v->norml2(v)==2*v[3]^2,vector(n^3,i,vector(3,j,i\n^(j-1)%n)))</langsyntaxhighlight>
 
Version 2.4.2 (obsolete, but widespread on Windows systems) requires inversion:
{{works with|PARI/GP|2.4.2}}
<langsyntaxhighlight lang="parigp">f(n)=select(vector(n^3,i,vector(3,j,i\n^(j-1)%n)),v->norml2(v)==2*v[3]^2)</langsyntaxhighlight>
 
=={{header|Perl}}==
Line 1,173 ⟶ 1,738:
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:
 
<langsyntaxhighlight lang="perl">sub triples ($) {
my ($n) = @_;
map { my $x = $_; map { my $y = $_; map { [$x, $y, $_] } grep { $x**2 + $y**2 == $_**2 } 1..$n } 1..$n } 1..$n;
}</langsyntaxhighlight>
 
<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.
 
<langsyntaxhighlight lang="perl">for my $t (triples(10)) {
print "@$t\n";
}</langsyntaxhighlight>
 
=={{header|Perl 6Phix}}==
Phix does not have builtin support for list comprehensions.
Perl 6 has single-dimensional list comprehensions that fall out naturally from nested modifiers; multidimensional comprehensions are also supported via the cross operator; however, Perl&nbsp;6 does not (yet) support multi-dimensional list comprehensions with dependencies between the lists, so the most straightforward way is currently:
 
<lang perl6>my $n = 20;
However, consider the fact that the compiler essentially converts an expression such as s[i] into calls
gather for 1..$n -> $x {
to the low-level back end (machine code) routines :%opRepe and :%opSubse depending on context (although
for $x..$n -> $y {
somtimes it will inline things and sometimes for better performance it will use opRepe1/opRepe1ip/opRepe1is and
for $y..$n -> $z {
opSubse1/opSubse1i/opSubse1is/opSubse1ip variants, but that's just detail). It also maps ? to hll print().
take $x,$y,$z if $x*$x + $y*$y == $z*$z;
 
}
Thinking laterally, Phix also does not have any special syntax for dictionaries, instead they are supported
}
via an autoinclude with the following standard hll routines:
}</lang>
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">global</span> <span style="color: #008080;">function</span> <span style="color: #7060A8;">new_dict</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">pool_only</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">global</span> <span style="color: #008080;">procedure</span> <span style="color: #7060A8;">destroy_dict</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">tid</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">justclear</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">global</span> <span style="color: #008080;">procedure</span> <span style="color: #7060A8;">setd</span><span style="color: #0000FF;">(</span><span style="color: #004080;">object</span> <span style="color: #000000;">key</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">object</span> <span style="color: #000000;">data</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">tid</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">global</span> <span style="color: #008080;">function</span> <span style="color: #7060A8;">getd</span><span style="color: #0000FF;">(</span><span style="color: #004080;">object</span> <span style="color: #000000;">key</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">tid</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">global</span> <span style="color: #008080;">procedure</span> <span style="color: #7060A8;">destroy_dict</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">tid</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">justclear</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">global</span> <span style="color: #008080;">function</span> <span style="color: #7060A8;">getd_index</span><span style="color: #0000FF;">(</span><span style="color: #004080;">object</span> <span style="color: #000000;">key</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">tid</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">global</span> <span style="color: #008080;">function</span> <span style="color: #7060A8;">getd_by_index</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">node</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">tid</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">global</span> <span style="color: #008080;">procedure</span> <span style="color: #7060A8;">deld</span><span style="color: #0000FF;">(</span><span style="color: #004080;">object</span> <span style="color: #000000;">key</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">tid</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">global</span> <span style="color: #008080;">procedure</span> <span style="color: #7060A8;">traverse_dict</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">rid</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">object</span> <span style="color: #000000;">user_data</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">tid</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">global</span> <span style="color: #008080;">function</span> <span style="color: #7060A8;">dict_size</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">tid</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
Clearly it would be relatively trivial for the compiler, just like it does with s[i], to map some other new
dictionary syntax to calls to these routines (not that it would ever use the default tid of 1, and admittedly
traverse_dict might prove a bit trickier than the rest). Since Phix is open source, needs no other tools, and
compiles itself in 10s, that is not as unreasonable for you (yes, you) to attempt as it might first sound.
 
With all that in mind, the following (which works just fine as it is) might be a first step to formal list comprehension support:
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #000080;font-style:italic;">-- demo\rosetta\List_comprehensions.exw</span>
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">list_comprehension</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">rid</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">level</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">args</span><span style="color: #0000FF;">={})</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
<span style="color: #000000;">args</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">args</span><span style="color: #0000FF;">[$]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">level</span><span style="color: #0000FF;"><</span><span style="color: #000000;">k</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #000000;">list_comprehension</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">rid</span><span style="color: #0000FF;">,</span><span style="color: #000000;">k</span><span style="color: #0000FF;">,</span><span style="color: #000000;">level</span><span style="color: #0000FF;">+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">deep_copy</span><span style="color: #0000FF;">(</span><span style="color: #000000;">args</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">else</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">&=</span> <span style="color: #7060A8;">call_func</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rid</span><span style="color: #0000FF;">,</span><span style="color: #000000;">args</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">triangle</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">a</span><span style="color: #0000FF;"><</span><span style="color: #000000;">b</span> <span style="color: #008080;">and</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">*</span><span style="color: #000000;">a</span><span style="color: #0000FF;">+</span><span style="color: #000000;">b</span><span style="color: #0000FF;">*</span><span style="color: #000000;">b</span><span style="color: #0000FF;">=</span><span style="color: #000000;">c</span><span style="color: #0000FF;">*</span><span style="color: #000000;">c</span> <span style="color: #008080;">then</span>
<span style="color: #008080;">return</span> <span style="color: #0000FF;">{{</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span><span style="color: #000000;">c</span><span style="color: #0000FF;">}}</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">return</span> <span style="color: #0000FF;">{}</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">list_comprehension</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">20</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">routine_id</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"triangle"</span><span style="color: #0000FF;">),</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
{{3,4,5},{5,12,13},{6,8,10},{8,15,17},{9,12,15},{12,16,20}}
</pre>
 
=={{header|Picat}}==
===List comprehensions===
<syntaxhighlight lang="picat">pyth(N) = [[A,B,C] : A in 1..N, B in A..N, C in B..N, A**2 + B**2 == C**2].</syntaxhighlight>
 
===Array comprehensions===
Picat also has array comprehensions. Arrays are generally used for faster access (using <code>{}</code> instead of <code>[]</code>).
 
<syntaxhighlight lang="picat">pyth(N) = {{A,B,C} : A in 1..N, B in A..N, C in B..N, A**2 + B**2 == C**2}.</syntaxhighlight>
 
===findall/2===
Note that <tt>gather</tt>/<tt>take</tt> is the primitive in Perl&nbsp;6 corresponding to generators or coroutines in other languages. It is not, however, tied to function call syntax in Perl&nbsp;6. We can get away with that because lists are lazy, and the demand for more of the list is implicit; it does not need to be driven by function calls.
A related construct is <code>findall/2</code> to get all solutions for the specific goal at the second parameter. Here this is shown with <code>member/2</code> for generating the numbers to test (which for this task is fairly inefficient).
<syntaxhighlight lang="text">pyth(N) = findall([A,B,C], (member(A,1..N), member(B,1..N), member(C,1..N), A < B, A**2 + B**2 == C**2)).</syntaxhighlight>
 
=={{header|PicoLisp}}==
Line 1,201 ⟶ 1,825:
We might use a generator function, pipe, coroutine or pilog predicate.
===Using a generator function===
<langsyntaxhighlight PicoLisplang="picolisp">(de pythag (N)
(job '((X . 1) (Y . 1) (Z . 0))
(loop
Line 1,213 ⟶ 1,837:
 
(while (pythag 20)
(println @) )</langsyntaxhighlight>
===Using a pipe===
<langsyntaxhighlight PicoLisplang="picolisp">(pipe
(for X 20
(for Y (range X 20)
Line 1,222 ⟶ 1,846:
(pr (list X Y Z)) ) ) ) )
(while (rd)
(println @) ) )</langsyntaxhighlight>
===Using a coroutine===
Coroutines are available only in the 64-bit version.
<langsyntaxhighlight PicoLisplang="picolisp">(de pythag (N)
(co 'pythag
(for X N
Line 1,234 ⟶ 1,858:
 
(while (pythag 20)
(println @) )</langsyntaxhighlight>
 
Output in all three cases:
Line 1,245 ⟶ 1,869:
===Using Pilog===
{{works with|PicoLisp|3.0.9.7}}
<langsyntaxhighlight PicoLisplang="picolisp">(be pythag (@N @X @Y @Z)
(for @X @N)
(for @Y @X @N)
Line 1,251 ⟶ 1,875:
(^ @
(let (X (-> @X) Y (-> @Y) Z (-> @Z))
(= (+ (* X X) (* Y Y)) (* Z Z)) ) ) )</langsyntaxhighlight>
Test:
<langsyntaxhighlight PicoLisplang="picolisp">: (? (pythag 20 @X @Y @Z))
@X=3 @Y=4 @Z=5
@X=5 @Y=12 @Z=13
Line 1,260 ⟶ 1,884:
@X=9 @Y=12 @Z=15
@X=12 @Y=16 @Z=20
-> NIL</langsyntaxhighlight>
 
=={{header|Prolog}}==
SWI-Prolog does not have list comprehension, however we can simulate it.
 
<langsyntaxhighlight Prologlang="prolog">% We need operators
:- op(700, xfx, <-).
:- op(450, xfx, ..).
Line 1,297 ⟶ 1,921:
Vs <- {Var & Dec} :-
findall(Var, maplist(call, [Dec]), Vs).
</syntaxhighlight>
</lang>
Examples of use :<BR>
List of Pythagorean triples :
Line 1,323 ⟶ 1,947:
 
=={{header|Python}}==
<syntaxhighlight lang="python">
List comprehension:
import itertools
n = 20
 
# List comprehension:
<lang python>[(x,y,z) for x in xrange(1,n+1) for y in xrange(x,n+1) for z in xrange(y,n+1) if x**2 + y**2 == z**2]</lang>
[(x,y,z) for x in xrange(1,n+1) for y in xrange(x,n+1) for z in xrange(y,n+1) if x**2 + y**2 == z**2]
 
# A Python generator comprehensionexpression (note the outer round brackets), returns an iterator over the same result rather than an explicit list:
# returns an iterator over the same result rather than an explicit list:
((x,y,z) for x in xrange(1,n+1) for y in xrange(x,n+1) for z in xrange(y,n+1) if x**2 + y**2 == z**2)
 
# A slower but more readable version:
<lang python>((x,y,z) for x in xrange(1,n+1) for y in xrange(x,n+1) for z in xrange(y,n+1) if x**2 + y**2 == z**2)</lang>
[(x, y, z) for (x, y, z) in itertools.product(xrange(1,n+1),repeat=3) if x**2 + y**2 == z**2 and x <= y <= z]
 
# Or as an iterator:
((x, y, z) for (x, y, z) in itertools.product(xrange(1,n+1),repeat=3) if x**2 + y**2 == z**2 and x <= y <= z)
 
# Alternatively we shorten the initial list comprehension but this time without compromising on speed.
# First we introduce a generator which generates all triplets:
def triplets(n):
for x in xrange(1, n + 1):
for y in xrange(x, n + 1):
for z in xrange(y, n + 1):
yield x, y, z
 
# Apply this to our list comprehension gives:
[(x, y, z) for (x, y, z) in triplets(n) if x**2 + y**2 == z**2]
 
# Or as an iterator:
((x, y, z) for (x, y, z) in triplets(n) if x**2 + y**2 == z**2)
 
# More generally, the list comprehension syntax can be understood as a concise syntactic sugaring
# of a use of the list monad, in which non-matches are returned as empty lists, matches are wrapped
# as single-item lists, and concatenation flattens the output, eliminating the empty lists.
 
# The monadic 'bind' operator for lists is concatMap, traditionally used with its first two arguments flipped.
# The following three formulations of a '''pts''' (pythagorean triangles) function are equivalent:
 
from functools import (reduce)
from operator import (add)
 
# pts :: Int -> [(Int, Int, Int)]
def pts(n):
m = 1 + n
return [(x, y, z) for x in xrange(1, m)
for y in xrange(x, m)
for z in xrange(y, m) if x**2 + y**2 == z**2]
 
 
# pts2 :: Int -> [(Int, Int, Int)]
def pts2(n):
m = 1 + n
return bindList(
xrange(1, m)
)(lambda x: bindList(
xrange(x, m)
)(lambda y: bindList(
xrange(y, m)
)(lambda z: [(x, y, z)] if x**2 + y**2 == z**2 else [])))
 
 
# pts3 :: Int -> [(Int, Int, Int)]
def pts3(n):
m = 1 + n
return concatMap(
lambda x: concatMap(
lambda y: concatMap(
lambda z: [(x, y, z)] if x**2 + y**2 == z**2 else []
)(xrange(y, m))
)(xrange(x, m))
)(xrange(1, m))
 
 
# GENERIC ---------------------------------------------------------
 
# concatMap :: (a -> [b]) -> [a] -> [b]
def concatMap(f):
return lambda xs: (
reduce(add, map(f, xs), [])
)
 
 
# (flip concatMap)
# bindList :: [a] -> (a -> [b]) -> [b]
def bindList(xs):
return lambda f: (
reduce(add, map(f, xs), [])
)
 
 
def main():
for f in [pts, pts2, pts3]:
print (f(20))
 
 
main()
</syntaxhighlight>
{{Out}}
<pre>[(3, 4, 5), (5, 12, 13), (6, 8, 10), (8, 15, 17), (9, 12, 15), (12, 16, 20)]
[(3, 4, 5), (5, 12, 13), (6, 8, 10), (8, 15, 17), (9, 12, 15), (12, 16, 20)]
[(3, 4, 5), (5, 12, 13), (6, 8, 10), (8, 15, 17), (9, 12, 15), (12, 16, 20)]</pre>
 
=={{header|R}}==
R has inherent list comprehension:
<syntaxhighlight lang="r">
<lang R>
x = (0:10)
> x^2
Line 1,341 ⟶ 2,059:
> x[x[(0:length(x))] %% 2==0]
[1] 0 2 4 6 8 10
</syntaxhighlight>
</lang>
 
R's "data frame" functions can be used to achieve the same code clarity (at the cost of expanding the entire grid into memory before the filtering step)
 
<syntaxhighlight lang="r">
<lang R>
subset(expand.grid(x=1:n, y=1:n, z=1:n), x^2 + y^2 == z^2)
</syntaxhighlight>
</lang>
 
=={{header|Racket}}==
<langsyntaxhighlight lang="racket">
#lang racket
(for*/list ([x (in-range 1 21)]
Line 1,357 ⟶ 2,075:
#:when (= (+ (* x x) (* y y)) (* z z)))
(list x y z))
</syntaxhighlight>
</lang>
 
=={{header|Raku}}==
(formerly Perl 6)
Raku has single-dimensional list comprehensions that fall out naturally from nested modifiers; multidimensional comprehensions are also supported via the cross operator; however, Raku does not (yet) support multi-dimensional list comprehensions with dependencies between the lists, so the most straightforward way is currently:
<syntaxhighlight lang="raku" line>my $n = 20;
say gather for 1..$n -> $x {
for $x..$n -> $y {
for $y..$n -> $z {
take $x,$y,$z if $x*$x + $y*$y == $z*$z;
}
}
}</syntaxhighlight>
{{out}}
<pre>((3 4 5) (5 12 13) (6 8 10) (8 15 17) (9 12 15) (12 16 20))</pre>
 
Note that <tt>gather</tt>/<tt>take</tt> is the primitive in Raku corresponding to generators or coroutines in other languages. It is not, however, tied to function call syntax in Raku. We can get away with that because lists are lazy, and the demand for more of the list is implicit; it does not need to be driven by function calls.
 
=={{header|Rascal}}==
<syntaxhighlight lang="rascal">
<lang Rascal>
public list[tuple[int, int, int]] PythTriples(int n) = [<a, b, c> | a <- [1..n], b <- [1..n], c <- [1 .. n], a*a + b*b == c*c];
</syntaxhighlight>
</lang>
 
=={{header|REXX}}==
There is no native comprehensive supoortsupport for lists ''per se'', &nbsp; except that
<br>normal lists can be processed quite easily and without much effort.
 
===vertical list===
<langsyntaxhighlight lang="rexx">/*REXX program listsdisplays a vertical list of Pythagorean triples up to a specified number. */
parse arg n . /*get theobtain optional argument. from the CL.*/
if n=='' | n=="," then n= 100 /*Not specified? Then assumeuse 100the default.*/
$= say 'Pythagorean triples (a² + = c², c ≤' n"):" /*assigndisplay athe nulllist's to triples listtitle. */
$= do a=1 for n-2; aa=a*a /*Note:assign a A*A isnull faster thanto the triples list. A**2,*/
do b a=a+1 to for n-12; aabbaa=aa+ba*b /* ··· but not by much.*/a
do c= b=a+1 to n-1; ab=aa + b*b
if aabb==c*c then $ do c=$b+1 '('a","to n ||; cc= b','c")"*c
if ab<cc then leave /*Too small? Then try the next B. */
end /*c*/
if ab==cc then do; $=$ '{'a"," || b','c"}"; leave; end
end /*b*/
end end /*ac*/
end /*b*/
end /*a*/
#= words($); sat
do j=1 for #
say left('', 20) word($, j) /*display a member of the list, */
end /*j*/ /* [↑] list the members vertically. */
say
say # ' members listed.' /*stick a fork in it, we're all done. */</syntaxhighlight>
{{out|output|text=&nbsp; when using the default input:}}
<pre style="height:45ex">
Pythagorean triples (a² + b² = c², c ≤ 100):
 
{3,4,5}
if 'f5'x==5 then do; sup2='b2'x; le='8c'x; end /*EBCDIC?*/
else do; sup2='fd'x; le='f3'x; end /* ASCII?*/{5,12,13}
{6,8,10}
say 'Pythagorean triples (a'sup2 "+ b"sup2 '= c'sup2", c "le n'):'
w=words($) /*number of members in the list. */{7,24,25}
say; do j=1 for w /*display the members of the list*/{8,15,17}
say word($,j) /*display a member of the list*/{9,12,15}
end /*j*/ /* [↑] list members vertically.*/{9,40,41}
{10,24,26}
 
say; say w 'members listed.' /*stick a fork in it, we're done.*/</lang>{11,60,61}
{12,16,20}
'''output''' when using the default input:
{12,35,37}
<pre style="height:40ex">
{13,84,85}
Pythagorean triples (a² + b² = c², c ≤ 100):
{14,48,50}
 
{15,20,25}
[3-4-5]
{15,36,39}
[5-12-13]
{16,30,34}
[6-8-10]
{16,63,65}
[7-24-25]
{18,24,30}
[8-15-17]
{18,80,82}
[9-12-15]
{20,21,29}
[9-40-41]
{20,48,52}
[10-24-26]
{21,28,35}
[11-60-61]
{21,72,75}
[12-16-20]
{24,32,40}
[12-35-37]
{24,45,51}
[13-84-85]
{24,70,74}
[14-48-50]
{25,60,65}
[15-20-25]
{27,36,45}
[15-36-39]
{28,45,53}
[16-30-34]
{28,96,100}
[16-63-65]
{30,40,50}
[18-24-30]
{30,72,78}
[18-80-82]
{32,60,68}
[20-21-29]
{33,44,55}
[20-48-52]
{33,56,65}
[21-28-35]
{35,84,91}
[21-72-75]
{36,48,60}
[24-32-40]
{36,77,85}
[24-45-51]
{39,52,65}
[24-70-74]
{39,80,89}
[25-60-65]
{40,42,58}
[27-36-45]
{40,75,85}
[28-45-53]
{42,56,70}
[28-96-100]
{45,60,75}
[30-40-50]
{48,55,73}
[30-72-78]
{48,64,80}
[32-60-68]
{51,68,85}
[33-44-55]
{54,72,90}
[33-56-65]
{57,76,95}
[35-84-91]
{60,63,87}
[36-48-60]
{60,80,100}
[36-77-85]
{65,72,97}
[39-52-65]
52 members listed.
[39-80-89]
[40-42-58]
[40-75-85]
[42-56-70]
[45-60-75]
[48-55-73]
[48-64-80]
[51-68-85]
[54-72-90]
[57-76-95]
[60-63-87]
[60-80-100]
[65-72-97]
 
52 members listed.
</pre>
 
===horizontal list===
<langsyntaxhighlight lang="rexx">/*REXX program listsshows a horizontal list of Pythagorean triples up to a specified number. */
parse arg n . /*get theobtain optional argument. from the CL.*/
if n=='' | n=="," then n= 100 /*Not specified? Then assumeuse 100the default.*/
$= do k=1 for n; @.k= k*k /*assignprecompute athe nullsquares toof triplesusable list#'s. */
do a=1 for n-2; aa=a*a end /*Note: A*A is faster than A**2,k*/
sw= linesize() - 1 do b=a+1 to n-1; aabb=aa+b*b /*obtain the ··· butterminal notwidth by(less muchone).*/
say 'Pythagorean triples (a² + b² = c², c ≤' n"):" /*display the list's title. */
do c=b+1 to n
$= if aabb==c*c then $=$ '(' /*assign a"," null || to the b','c")"triples list. */
do a=1 for n-2; bump= a//2 /*Note: A*A is faster than A**2. */
end /*c*/
end /* do b*/=a+1 to n-1 by 1+bump
ab= @.a + @.b /*AB: a shortcut for the sum of A² & B²*/
end /*a*/
if bump==0 & b//2==0 then cump= 2
if 'f5'x==5 then do; sup2='b2'x; le='8c'x; end /*EBCDIC?*/
else do; sup2='fd'x; le='f3'x; end /* ASCII?*/ else cump= 1
do c=b+cump to n by cump
say 'Pythagorean triples (a'sup2 "+ b"sup2 '= c'sup2", c "le n'):'
say; say strip($) if ab<@.c then leave /*showToo small? Then try the Pythagoreannext triples B. */
if ab==@.c then do; $=$ '{'a"," || b','c"}"; leave; end
say; say words($) 'members listed.' /*triples listed in order of 1st#*/
end /*stick a fork in it, we're done.c*/</lang>
end /*b*/
'''output''' when using for the input: &nbsp; <tt> 35 </tt>
end /*a*/
#= words($); say
do j=1 until p==0; p= lastPos('}', $, sw) /*find the last } */
if p\==0 then do; _= left($, p)
say strip(_)
$= substr($, p+1)
end
end /*j*/
say strip($); say
say # ' members listed.' /*stick a fork in it, we're all done. */</syntaxhighlight>
{{out|output|text=&nbsp; when using the following input: &nbsp; <tt> 35 </tt>}}
<pre>
Pythagorean triples (a² + b² = c², c ≤ 35):
 
({3,4,5)} ({5,12,13)} ({6,8,10)} ({7,24,25)} ({8,15,17)} ({9,12,15)} ({10,24,26)} ({12,16,20)} ({15,20,25)} ({16,30,34)} ({18,24,30)} ({20,21,29)} ({21,28,35)}
 
13 members listed.
</pre>
 
=={{header|Ring}}==
<syntaxhighlight lang="ring">
for x = 1 to 20
for y = x to 20
for z = y to 20
if pow(x,2) + pow(y,2) = pow(z,2)
see "[" + x + "," + y + "," + z + "]" + nl ok
next
next
next
</syntaxhighlight>
 
=={{header|Ruby}}==
Line 1,487 ⟶ 2,241:
 
Ruby's object-oriented style enforces writing 1..100 before x. Think not of x in 1..100. Think of 1..100 giving x.
 
There is no elegant way to comprise a list from multiple variables. Pythagorean triplets need three variables, with 1..n giving x, then x..n giving y, then y..n giving z. A less than elegant way is to nest three blocks.
 
=== Ruby 1.9.2 ===
{{works with|Ruby|1.9.2}}
 
<langsyntaxhighlight lang="ruby">n = 20
# select Pythagorean triplets
Line 1,501 ⟶ 2,253:
[[x, y, z]].keep_if { x * x + y * y == z * z }}}})
 
p r # print the array _r_</langsyntaxhighlight>
 
Output: <tt>[[3, 4, 5], [5, 12, 13], [6, 8, 10], [8, 15, 17], [9, 12, 15], [12, 16, 20]]</tt>
Line 1,512 ⟶ 2,264:
* The outer <tt>(1..n).flat_map { ... }</tt> concatenates the middle arrays for all x.
 
=== Ruby 1.8.6 ===
{{works with|Ruby|1.8.6 or later}}
 
<lang ruby>n = 20
 
Illustrating a way to avoid all loops (but no list comprehensions) :
unless Enumerable.method_defined? :flat_map
<syntaxhighlight lang="ruby">n = 20
module Enumerable
p (1..n).to_a.combination(3).select{|a,b,c| a*a + b*b == c*c}
def flat_map
</syntaxhighlight>
inject([]) { |a, x| a.concat yield(x) }
end
end
end
 
unless Array.method_defined? :keep_if
class Array
def keep_if
delete_if { |x| not yield(x) }
end
end
end
# select Pythagorean triplets
r = ((1..n).flat_map { |x|
(x..n).flat_map { |y|
(y..n).flat_map { |z|
[[x, y, z]].keep_if { x * x + y * y == z * z }}}})
 
p r # print the array _r_</lang>
 
This is the exact same code, except that it now defines Enumerable#flat_map and Array#keep_if when those methods are missing. It now works with older versions of Ruby, like 1.8.6.
 
=={{header|Run BASIC}}==
<langsyntaxhighlight lang="runbasic">for x = 1 to 20
for y = x to 20
for z = y to 20
Line 1,550 ⟶ 2,278:
next z
next y
next x</langsyntaxhighlight>Output:
<pre>[3,4,5]
[5,12,13]
Line 1,557 ⟶ 2,285:
[9,12,15]
[12,16,20]</pre>
 
 
=={{header|Rust}}==
 
Rust doesn't have comprehension-syntax, but it has powerful lazy-iteration mechanisms topped with a powerful macro system, as such you can implement comprehensions on top of the language fairly easily.
 
=== Iterator ===
 
First using the built-in iterator trait, we can simply flat-map and then filter-map:
 
<syntaxhighlight lang="rust">fn pyth(n: u32) -> impl Iterator<Item = [u32; 3]> {
(1..=n).flat_map(move |x| {
(x..=n).flat_map(move |y| {
(y..=n).filter_map(move |z| {
if x.pow(2) + y.pow(2) == z.pow(2) {
Some([x, y, z])
} else {
None
}
})
})
})
}</syntaxhighlight>
 
* Using <code>flat_map</code> we can map and flatten an iterator.
 
* Use <code>filter_map</code> we can return an <code>Option</code> where <code>Some(value)</code> is returned or <code>None</code> isn't. Technically we could also use <code>flat_map</code> instead, because <code>Option</code> implements <code>IntoIterator</code>.
 
* Using the <code>impl Trait</code> syntax, we return the <code>Iterator</code> generically, because it's statically known.
 
* Using the <code>move</code> syntax on the closure, means the closure will take ownership of the values (copying them) which is what we wan't because the captured variables will be returned multiple times.
 
=== Comprehension Macro ===
 
Using the above and <code>macro_rules!</code> we can implement comprehension with a reasonably sized macro:
 
<syntaxhighlight lang="rust">macro_rules! comp {
($e:expr, for $x:pat in $xs:expr $(, if $c:expr)?) => {{
$xs.filter_map(move |$x| if $($c &&)? true { Some($e) } else { None })
}};
($e:expr, for $x:pat in $xs:expr $(, for $y:pat in $ys:expr)+ $(, if $c:expr)?) => {{
$xs.flat_map(move |$x| comp!($e, $(for $y in $ys),+ $(, if $c)?))
}};
}</syntaxhighlight>
 
The way to understand a Rust macro is it's a bit like regular expressions. The input matches a type of token, and expands it into the block, for example take the follow pattern:
 
<syntaxhighlight lang="rust">($e:expr, for $x:pat in $xs:expr $(, if $c:expr)?)</syntaxhighlight>
 
# matches an <code>expr</code> expression, defines it to <code>$e</code>
# matches the tokens <code>, for</code>
# matches a <code>pat</code> pattern, defines it to <code>$x</code>
# matches the tokens <code>in</code>
# matches an <code>expr</code> expression, defines it to <code>$xs</code>
# matches <code>$(..)?</code> optional group
## patches tokens <code>, if</code>
## matches an <code>expr</code> expression, defines it to <code>$c</code>
 
This makes the two following blocks equivalent:
 
<syntaxhighlight lang="rust">comp!(x, for x in 0..10, if x != 5)</syntaxhighlight>
 
<syntaxhighlight lang="rust">(0..10).filter_map(move |x| {
if x != 5 && true {
Some(x)
} else {
None
}
})</syntaxhighlight>
 
The most interesting part of <code>comp!</code> is that it's a recursive macro (it expands within itself), and that means it can handle any number of iterators as inputs.
 
=== Iterator Comprehension ===
 
The pythagorean function could as such be defined as the following:
 
<syntaxhighlight lang="rust">fn pyth(n: u32) -> impl Iterator<Item = [u32; 3]> {
comp!(
[x, y, z],
for x in 1..=n,
for y in x..=n,
for z in y..=n,
if x.pow(2) + y.pow(2) == z.pow(2)
)
}</syntaxhighlight>
 
 
=={{header|Scala}}==
<langsyntaxhighlight lang="scala">def pythagoranTriangles(n: Int) = for {
x <- 1 to 21
y <- x to 21
z <- y to 21
if x * x + y * y == z * z
} yield (x, y, z)</langsyntaxhighlight>
 
which is a syntactic sugar for:
 
<langsyntaxhighlight lang="scala"> def pythagoranTriangles(n: Int) = (1 to n) flatMap (x =>
(x to n) flatMap (y =>
(y to n) filter (z => x * x + y * y == z * z) map (z =>
(x, y, z))))</langsyntaxhighlight>
 
Alas, the type of collection returned depends on the type of the collection
Line 1,580 ⟶ 2,394:
To get a <code>List</code> out of it, just pass a <code>List</code> to it:
 
<langsyntaxhighlight lang="scala">def pythagoranTriangles(n: Int) = for {
x <- List.range(1, n + 1)
y <- x to 21
z <- y to 21
if x * x + y * y == z * z
} yield (x, y, z)</langsyntaxhighlight>
 
Sample:
Line 1,597 ⟶ 2,411:
Scheme has no native list comprehensions, but SRFI-42 [http://srfi.schemers.org/srfi-42/srfi-42.html] provides them:
 
<langsyntaxhighlight lang="scheme">
(list-ec (:range x 1 21)
(:range y x 21)
Line 1,603 ⟶ 2,417:
(if (= (* z z) (+ (* x x) (* y y))))
(list x y z))
</syntaxhighlight>
</lang>
 
<pre>
((3 4 5) (5 12 13) (6 8 10) (8 15 17) (9 12 15) (12 16 20))
</pre>
 
=={{header|Sidef}}==
{{trans|Raku}}
<syntaxhighlight lang="ruby">var n = 20
say gather {
for x in (1 .. n) {
for y in (x .. n) {
for z in (y .. n) {
take([x,y,z]) if (x*x + y*y == z*z)
}
}
}
}</syntaxhighlight>
{{out}}
<pre>
[[3, 4, 5], [5, 12, 13], [6, 8, 10], [8, 15, 17], [9, 12, 15], [12, 16, 20]]
</pre>
 
=={{header|Smalltalk}}==
{{works with|Pharo|1.3-13315}}
<langsyntaxhighlight lang="smalltalk">
| test |
 
Line 1,628 ⟶ 2,459:
#(9 12 15)
#(12 16 20)"
</syntaxhighlight>
</lang>
 
=={{header|Stata}}==
 
Stata does no have list comprehensions, but the Mata matrix language helps simplify this task.
 
<syntaxhighlight lang="stata">function grid(n,p) {
return(colshape(J(1,p,1::n),1),J(n,1,1::p))
}
 
n = 20
a = grid(n,n)
a = a,sqrt(a[.,1]:^2+a[.,2]:^2)
a[selectindex(floor(a[.,3]):==a[.,3] :& a[.,3]:<=n),]</syntaxhighlight>
 
'''Output'''
 
<pre> 1 2 3
+----------------+
1 | 3 4 5 |
2 | 4 3 5 |
3 | 5 12 13 |
4 | 6 8 10 |
5 | 8 6 10 |
6 | 8 15 17 |
7 | 9 12 15 |
8 | 12 5 13 |
9 | 12 9 15 |
10 | 12 16 20 |
11 | 15 8 17 |
12 | 16 12 20 |
+----------------+</pre>
 
=={{header|SuperCollider}}==
<syntaxhighlight lang ="supercollider">var pyth = {
var pyth = { |n|
arg n = 10; // default
all {: [x,y,z],
x <- (1..n),
Line 1,638 ⟶ 2,500:
z <- (y..n),
(x**2) + (y**2) == (z**2)
};
};
 
pyth.value(20); // example call</langsyntaxhighlight>
returns
<langsyntaxhighlight lang="supercollider">[ [ 3, 4, 5 ], [ 5, 12, 13 ], [ 6, 8, 10 ], [ 8, 15, 17 ], [ 9, 12, 15 ], [ 12, 16, 20 ] ]</langsyntaxhighlight>
 
=={{header|Swift}}==
{{incorrect|Swift|They should be distinct from (nested) for loops and the use of map and filter functions within the syntax of the language.}}
 
<syntaxhighlight lang="swift">typealias F1 = (Int) -> [(Int, Int, Int)]
typealias F2 = (Int) -> Bool
 
func pythagoreanTriples(n: Int) -> [(Int, Int, Int)] {
(1...n).flatMap({x in
(x...n).flatMap({y in
(y...n).filter({z in
x * x + y * y == z * z
} as F2).map({ (x, y, $0) })
} as F1)
} as F1)
}
 
print(pythagoreanTriples(n: 20))</syntaxhighlight>
 
{{out}}
 
<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.
<langsyntaxhighlight lang="tcl">package require Tcl 8.5
 
# from http://wiki.tcl.tk/12574
Line 1,691 ⟶ 2,575:
 
set range {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20}
puts [lcomp {$x $y $z} x $range y $range z $range {$x < $y && $x**2 + $y**2 == $z**2}]</langsyntaxhighlight>
<pre>{3 4 5} {5 12 13} {6 8 10} {8 15 17} {9 12 15} {12 16 20}</pre>
 
Line 1,698 ⟶ 2,582:
TI-89 BASIC does not have a true list comprehension, but it has the seq() operator which can be used for some similar purposes.
 
<langsyntaxhighlight lang="ti89b">{1, 2, 3, 4} → a
seq(a[i]^2, i, 1, dim(a))</langsyntaxhighlight>
 
produces {1, 4, 9, 16}. When the input is simply a numeric range, an input list is not needed; this produces the same result:
 
<langsyntaxhighlight lang="ti89b">seq(x^2, x, 1, 4)</langsyntaxhighlight>
 
=={{header|Transd}}==
The language's construct for list comprehension closely follows the established set-builder notation:
 
<pre>
FOR x IN <SET>
WHERE predicate(x)
PROJECT f(x)
</pre>
The special form of 'for' construct performs list comprehension and returns a collection with selected elements.
 
In basic form, the returned vector is created and filled automatically:
 
<syntaxhighlight lang="Scheme">
(with v (for x in Range(10)
project (* x x))
(textout v))
</syntaxhighlight>
{{out}}
<pre>
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
</pre>
 
Basic form with 'WHERE' clause:
 
<syntaxhighlight lang="Scheme">
(with v (for x in Range(10)
where (mod x 2)
project Vector<ULong>([x,(* x x)]))
(textout v))
</syntaxhighlight>
{{out}}
<pre>
[[1, 1], [3, 9], [5, 25], [7, 49], [9, 81]]
</pre>
 
In cases when more customized behaviour is required, there is an option to define
and fill the returned collection directly:
 
<syntaxhighlight lang="Scheme">
(with v (for x in Range(1 n) project<Vector<ULong>>
(for y in Range(x n) do
(for z in Range(y n)
where (== (* z z) (+ (* y y) (* x x)))
do (append @projRes Vector<ULong>([x,y,z])))))
(textout "Pythagorean triples:\n" v))
}</syntaxhighlight>
{{out}}
<pre>
Pythagorean triples:
[[3, 4, 5], [5, 12, 13], [6, 8, 10], [9, 12, 15]]
</pre>
 
=={{header|Visual Basic .NET}}==
Line 1,709 ⟶ 2,645:
{{trans|C#}}
 
<langsyntaxhighlight lang="vbnet">Module ListComp
Sub Main()
Dim ts = From a In Enumerable.Range(1, 20) _
Line 1,721 ⟶ 2,657:
Next
End Sub
End Module</langsyntaxhighlight>
 
Output:
Line 1,737 ⟶ 2,673:
VP7 has explicit list comprehension syntax.
 
<syntaxhighlight lang="visualprolog">
<lang visualProlog>
implement main
open core, std
Line 1,764 ⟶ 2,700:
goal
mainExe::run(main::run).
</syntaxhighlight>
</lang>
 
=={{header|Wrapl}}==
<langsyntaxhighlight lang="wrapl">ALL WITH x <- 1:to(n), y <- x:to(n), z <- y:to(n) DO (x^2 + y^2 = z^2) & [x, y, z];</langsyntaxhighlight>
 
=={{header|Wren}}==
Using a generator.
<syntaxhighlight lang="wren">var pythTriples = Fiber.new { |n|
(1..n-2).each { |x|
(x+1..n-1).each { |y|
(y+1..n).each { |z| (x*x + y*y == z*z) && Fiber.yield([x, y, z]) }
}
}
}
 
var n = 20
while (!pythTriples.isDone) {
var res = pythTriples.call(n)
res && System.print(res)
}</syntaxhighlight>
 
{{out}}
<pre>
[3, 4, 5]
[5, 12, 13]
[6, 8, 10]
[8, 15, 17]
[9, 12, 15]
[12, 16, 20]
</pre>
 
=={{header|zkl}}==
<langsyntaxhighlight lang="zkl">var n=20;
[[(x,y,z); [1..n]; {[x..n]}; {[y..n]},{ x*x + y*y == z*z }; _]]
//-->L(L(3,4,5),L(5,12,13),L(6,8,10),L(8,15,17),L(9,12,15),L(12,16,20))</langsyntaxhighlight>
Lazy:
<langsyntaxhighlight lang="zkl">var n=20;
lp:=[& (x,y,z); // three variables, [& means lazy/iterator
[1..n]; // x: a range
Line 1,784 ⟶ 2,746:
// with values x,y,z, or just _ (which means return arglist)
]];
lp.walk(2) //-->L(L(3,4,5),L(5,12,13))</langsyntaxhighlight>
 
 
{{omit from|Go}}
{{omit from|Maxima}}
{{omit from|Axe}}
{{omit from|Maxima}}
9,482

edits