List comprehensions: Difference between revisions

{{trans|Python}}

{{out}}

=={{header|ABAP}}==

CLASS lcl_pythagorean_triplet DEFINITION CREATE PUBLIC.

PUBLIC SECTION.

START-OF-SELECTION.

cl_demo_output=>display( lcl_pythagorean_triplet=>get_triplets( n = 20 ) ).

{{out}}

There is no equivalent construct in Ada. In Ada05, the predefined library Ada.Containers

implements 3 types of Doubly_Linked_Lists : Basic; Indefinite; Restricted.

with Ada.Containers.Doubly_Linked_Lists;

end loop;

end Pythagore_Set;

program output:

{{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>

{{trans|JavaScript}}

-- pythagoreanTriples :: Int -> [(Int, Int, Int)]

end script

end if

{{Out}}

=={{header|Arturo}}==

triplets: @[

loop 1..n 'x [

]

]

{{out}}

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}

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

return

return set

}

=={{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.

:?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 }

| out$!py { You get here when backtracking has

exhausted all combinations of x, y and z }

Output:

<pre> (12,16,20)

{{works with|GCC}}

The program below is C11 compliant. For C99 compilers change line 57 :

for (int i = f + 1; i <= t; i ++) { e = e->nx = listNew(sizeof i, &i); }

to

int i;

for (i = f + 1; i <= t; i ++) { e = e->nx = listNew(sizeof i, &i); }

Output remains unchanged.

#include <stdlib.h>

#include <stdio.h>

return 0;

}

Output:

<pre>3, 4, 5

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

===LINQ===

static class Program

}

}

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

There is no equivalent construct in C++. The code below uses two nested loops and an ''if'' statement:

#include <cmath>

#include <iostream>

}

}

This produces the following output:

{{works with|C++11}}

#include <iostream>

});

return 0;

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|CoffeeScript}}==

pyth = (n) ->

))

<code>pyth</code> can also be written more concisely as

=={{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)

iota(y, n + 1), x*x + y*y == z*z);

writeln(r);

{{out}}

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

=={{header|E}}==

=={{header|EchoLisp}}==

;; copied from Racket

(list x y z))

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

=={{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|Ela}}==

=={{header|Elixir}}==

=={{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|Factor}}==

Factor does not support list comprehensions by default. The <code>backtrack</code> vocabulary can make for a faithful imitation, however.

:: pythagorean-triples ( n -- seq )

b n [a,b] amb-lazy :> c

a a * b b * + c c * = must-be-true { a b c }

=={{header|Fortran}}==

Complex numbers simplify the task. However, the reshape intrinsic function along with implicit do loops can generate high rank matrices.

!-*- mode: compilation; default-directory: "/tmp/" -*-

!Compilation started at Fri Jun 7 23:39:20

print '(3i4)',d(:,:i)

end program list_comprehension

{{trans|Run BASIC}}

FreeBASIC no tiene listas de comprensión. Una implementación:

For x = 1 To n

For y = x To n

Next y

Next x

{{out}}

<pre>

=={{header|FunL}}==

{{out}}

=={{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|Go}}==

Go doesn't have special syntax for list comprehensions but we can build a function which behaves similarly.

import "fmt"

pt = pt.listComp(in, expr, pred)

fmt.Println(pt)

{{out}}

=={{header|Haskell}}==

pyth n =

[ (x, y, z)

, y <- [x .. n]

, z <- [y .. n]

List-comprehensions and do notation are two alternative and equivalent forms of syntactic sugar in Haskell.

The list comprehension above could be re-sugared in Do notation as:

pyth n = do

x <- [1 .. n]

if x ^ 2 + y ^ 2 == z ^ 2

then [(x, y, z)]

and both of the above could be de-sugared to:

pyth n =

[1 .. n] >>=

case x ^ 2 + y ^ 2 == z ^ 2 of

True -> [(x, y, z)]

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:

pyth n =

concatMap

main :: IO ()

{{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:

If we apply this to our list comprehension we get this tidy line of code:

=={{header|Hy}}==

(list-comp (, a b c) [a (range 1 (inc n))

b (range a (inc n))

(print (triples 15))

=={{header|Icon}} and {{header|Unicon}}==

expression:

|(x := seq(), x^2 > 3, x*2)

is capable of producing successive elements from the infinite list described in the

Wikipedia article. For example, to produce the first 100 elements:

procedure main()

every write(|(x := seq(), x^2 > 3, x*2) \ 100

end

While result sequences are lexically bound to the code that describes them,

with (works in both languages):

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])

Sample output:

=={{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|Java}}==

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.

import java.util.Arrays;

import java.util.List;

}

}

{{Out}}

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

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.

(function (n) {

}

Output:

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

for (let i = begin; i < end; ++i)

yield i;

for each(var triple in triples(20))

outputs:

by using <code>concatMap</code> (the monadic bind function for lists), and <code>x => [x]</code> (monadic pure/return for lists):

'use strict';

enumFromTo(x, n)),

enumFromTo(1, n));

Or, expressed in terms of bind (>>=)

'use strict';

)));

{{Out}}

=={{header|jq}}==

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] ;

'''Using listof(stream; criterion)'''

# elements in the stream that satisfy the criterion

def listof( stream; criterion): [ stream|select(criterion) ];

.[0] * .[0] + .[1] * .[1] == .[2] * .[2] ) ;

{{out}}

<pre>

Array comprehension:

julia> n = 20

20

(9,12,15)

(12,16,20)

A Julia generator comprehension (note the outer round brackets), returns an iterator over the same result rather than an explicit array:

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))

(9,12,15)

(12,16,20)

Array comprehensions may also be N-dimensional, not just vectors:

julia> [i + j for i in 1:5, j in 1:5]

5×5 Array{Int64,2}:

5 6 7 8 9

6 7 8 9 10

=={{header|Kotlin}}==

fun pythagoreanTriples(n: Int) =

fun main(args: Array<String>) {

println(pythagoreanTriples(20))

{{out}}

=={{header|Lasso}}==

Lasso uses query expressions for list manipulation.

local(n = 20)

select (:#x, #y, #z)

)

Output:

staticarray(5, 12, 13)

staticarray(6, 8, 10)

staticarray(8, 15, 17)

staticarray(9, 12, 15)

=={{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|Mathematica}}/{{header|Wolfram Language}}==

=={{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

[a,b] = meshgrid(1:N, 1:N);

c = sqrt(a.^2 + b.^2);

[x,y] = find(c == fix(c));

{{out}}

''Solutions'' behaves like list comprehension since compound goals resemble set-builder notation.

:- module pythtrip.

:- interface.

solutions((pred(Triple::out) is nondet :- pythTrip(20,Triple)),Result),

write(Result,!IO).

=={{header|Nemerle}}==

Demonstrating a list comprehension and an iterator. List comprehension adapted from Haskell example, iterator adapted from C# example.

using System.Console;

using System.Collections.Generic;

}

}

=={{header|Nim}}==

List comprehension is done in the standard library with the collect() macro (which uses for-loop macros) from the sugar package:

let n = 20

if x^2 + y^2 == z^2:

(x,y,z)

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:

type ListComprehension = object

const n = 20

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>

For instance,

or, to compute a list,

or, to compute a set,

etc..

A standard OCaml distribution also includes a number of camlp4 extensions, including one that provides list comprehensions:

# #require "camlp4.listcomprehension";;

/home/user//.opam/4.06.1+trunk+flambda/lib/ocaml/camlp4/Camlp4Parsers/Camlp4ListComprehension.cmo: loaded

- : int list = [2; 4; 6; 8]

# [ x * 2 | x <- [1;2;3;4]; x > 2 ];;

=={{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|PARI/GP}}==

GP 2.6.0 added support for a new comprehension syntax:

{{works with|PARI/GP|2.6.0 and above}}

Older versions of GP can emulate this through <code>select</code>:

{{PARI/GP select}}

Version 2.4.2 (obsolete, but widespread on Windows systems) requires inversion:

{{works with|PARI/GP|2.4.2}}

=={{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|Phix}}==

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:

<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;">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>

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

With all that in mind, the following (which works just fine as it is) might be a first step to formal list comprehension support:

<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: #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>

{{out}}

<pre>

=={{header|Picat}}==

===List comprehensions===

===Array comprehensions===

Picat also has array comprehensions. Arrays are generally used for faster access (using <code>{}</code> instead of <code>[]</code>).

===findall/2===

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).

=={{header|PicoLisp}}==

We might use a generator function, pipe, coroutine or pilog predicate.

===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:

===Using Pilog===

{{works with|PicoLisp|3.0.9.7}}

(for @X @N)

(for @Y @X @N)

(^ @

(let (X (-> @X) Y (-> @Y) Z (-> @Z))

Test:

@X=3 @Y=4 @Z=5

@X=5 @Y=12 @Z=13

@X=9 @Y=12 @Z=15

@X=12 @Y=16 @Z=20

=={{header|Prolog}}==

SWI-Prolog does not have list comprehension, however we can simulate it.

:- op(700, xfx, <-).

:- op(450, xfx, ..).

Vs <- {Var & Dec} :-

findall(Var, maplist(call, [Dec]), Vs).

Examples of use :<BR>

List of Pythagorean triples :

List comprehension:

A Python generator expression (note the outer round brackets), returns an iterator over the same result rather than an explicit list:

A slower but more readable version:

Or as an iterator:

Alternatively we shorten the initial list comprehension but this time without compromising on speed. First we introduce a generator which generates all triplets:

for x in xrange(1, n + 1):

for y in xrange(x, n + 1):

for z in xrange(y, n + 1):

Apply this to our list comprehension gives:

Or as an iterator:

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 operator import (add)

{{Out}}

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

=={{header|R}}==

R has inherent list comprehension:

x = (0:10)

> x^2

> x[x[(0:length(x))] %% 2==0]

[1] 0 2 4 6 8 10

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)

subset(expand.grid(x=1:n, y=1:n, z=1:n), x^2 + y^2 == z^2)

=={{header|Racket}}==

#lang racket

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

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

(list x y z))

=={{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:

gather for 1..$n -> $x {

for $x..$n -> $y {

}

}

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}}==

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];

=={{header|REXX}}==

===vertical list===

parse arg n . /*obtain optional argument from the CL.*/

if n=='' | n=="," then n= 100 /*Not specified? Then use the default.*/

end /*j*/ /* [↑] list the members vertically. */

say

{{out|output|text=&nbsp; when using the default input:}}

<pre style="height:45ex">

===horizontal list===

parse arg n . /*obtain optional argument from the CL.*/

if n=='' | n=="," then n= 100 /*Not specified? Then use the default.*/

end /*j*/

say strip($); say

{{out|output|text=&nbsp; when using the following input: &nbsp; <tt> 35 </tt>}}

<pre>

=={{header|Ring}}==

for x = 1 to 20

for y = x to 20

next

next

=={{header|Ruby}}==

{{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>

Illustrating a way to avoid all loops (but no list comprehensions) :

p (1..n).to_a.combination(3).select{|a,b,c| a*a + b*b == c*c}

=={{header|Run BASIC}}==

for y = x to 20

for z = y to 20

next z

next y

<pre>[3,4,5]

[5,12,13]

First using the built-in iterator trait, we can simply flat-map and then filter-map:

(1..=n).flat_map(move |x| {

(x..=n).flat_map(move |y| {

})

})

* Using <code>flat_map</code> we can map and flatten an iterator.

Using the above and <code>macro_rules!</code> we can implement comprehension with a reasonably sized macro:

($e:expr, for $x:pat in $xs:expr $(, if $c:expr)?) => {{

$xs.filter_map(move |$x| if $($c &&)? true { Some($e) } else { None })

$xs.flat_map(move |$x| comp!($e, $(for $y in $ys),+ $(, if $c)?))

}};

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:

# matches an <code>expr</code> expression, defines it to <code>$e</code>

This makes the two following blocks equivalent:

if x != 5 && true {

Some(x)

None

}

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.

The pythagorean function could as such be defined as the following:

comp!(

[x, y, z],

if x.pow(2) + y.pow(2) == z.pow(2)

)

=={{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>

=={{header|Sidef}}==

{{trans|Raku}}

say gather {

for x in (1 .. n) {

}

}

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|Pharo|1.3-13315}}

| test |

#(9 12 15)

#(12 16 20)"

=={{header|Stata}}==

Stata does no have list comprehensions, but the Mata matrix language helps simplify this task.

return(colshape(J(1,p,1::n),1),J(n,1,1::p))