List comprehensions: Difference between revisions

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

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

#include <stdlib.h>

#include <stdio.h>

List * intRangeList(int f, int t) {

List * l = listNew(sizeof f, &f), * e = l;

return l;

}

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

[x, y, z]

))

 

 

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

Here are the Pythagorean triples:

 

(loop for x from 1 to n

append (loop for y from x to n

append (loop for z from y to n

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

 

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

 

(if (cdr l)

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

`((iter ,outer ,form)

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

 

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

 

(listc (list x y z)

(for x from 1 to n)

(for y from x to n)

(for z from y to n)

 

=={{header|D}}==

D doesn't have list comprehensions. One implementation:

 

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

lazy TP where) {

Appender!(TA[]) result;

 

foreach (el1; items1) {

}

 

return result.data;

}

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

 

 

Icon's (and Unicon's) natural goal-directly evaluation produces result

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:

12 16 20

->

</pre>

 

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

 

type ListComprehension = object

var lc*: ListComprehension

 

expectLen(x, 3)

expectKind(x, nnkInfix)

expectKind(x[0], nnkIdent)

 

result = newCall(

expectKind(y, nnkInfix)

expectMinLen(y, 1)

expectLen(y, 3)

result = newNimNode(nnkForStmt).add(y[1], y[2], result)

 

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>

=={{header|OCaml}}==

 

 

 

 

 

 

=={{header|Oz}}==

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

 

import

LazyList

 

{Application.exit 0}

 

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

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:

{{out}}

<pre>

{{3,4,5},{5,12,13},{6,8,10},{8,15,17},{9,12,15},{12,16,20}}

</pre>

 

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

 

=={{header|Python}}==

 

 

 

 

 

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

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

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

 

 

 

 

 

from operator import (add)

 

# pts :: Int -> [(Int, Int, Int)]

 

 

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

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

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

}

}

 

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

}

a = grid(n,n)

a = a,sqrt(a[.,1]:^2+a[.,2]:^2)

 

'''Output'''

 

=={{header|SuperCollider}}==

var pyth = { |n|

all {: [x,y,z],

};

 

returns

 

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

 

typealias F2 = (Int) -> Bool

 

}

 

 

{{out}}

=={{header|Tcl}}==

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

 

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

 

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

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

 

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

 

 

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

 

 

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

{{trans|C#}}

 

Sub Main()

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

Next

End Sub

 

Output:

VP7 has explicit list comprehension syntax.

 

implement main

open core, std

goal

mainExe::run(main::run).

 

=={{header|Wrapl}}==

 

=={{header|Wren}}==

Using a generator.

(1..n-2).each { |x|

(x+1..n-1).each { |y|

var res = pythTriples.call(n)

res && System.print(res)

 

{{out}}

 

=={{header|zkl}}==

[[(x,y,z); [1..n]; {[x..n]}; {[y..n]},{ x*x + y*y == z*z }; _]]

Lazy:

lp:=[& (x,y,z); // three variables, [& means lazy/iterator

[1..n]; // x: a range

// with values x,y,z, or just _ (which means return arglist)

]];