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>

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

</pre></div>

 

=={{header|AppleScript}}==

 

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

 

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

System.out.println(run(20));

}

static List<List<Integer>> run(int n){

return

// Here comes the list comprehension bit

// predicate

.filter(a -> a[0]*a[0] + a[1]*a[1] == a[2]*a[2])

// output expression

// the result is a 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}}==

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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

say 'Pythagorean triples (a² + b² = c², c ≤' n"):" /*display the list's title. */

$= /*assign a null to the triples list. */

end /*c*/

end /*b*/

end /*a*/

do j=1 for #

say left('', 20) word($, j) /*display a member of the list, */

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

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

<pre style="height:45ex">

Pythagorean triples (a² + b² = c², c ≤ 100):

{3,4,5}

{5,12,13}

{60,80,100}

{65,72,97}

</pre>

 

===horizontal list===

say 'Pythagorean triples (a² + b² = c², c ≤' n"):" /*display the list's title. */

$= /*assign a null to the triples list. */

end /*c*/

end /*b*/

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

<pre>

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

 

</pre>

 

=={{header|Ring}}==

for x = 1 to 20

for y = x to 20

next

next

 

=={{header|Ruby}}==

 

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

 

=== Ruby 1.9.2 ===

{{works with|Ruby|1.9.2}}

 

# select Pythagorean triplets

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

 

 

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

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

 

 

 

 

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

for y = x to 20

for z = y to 20

next z

next y

<pre>[3,4,5]

[5,12,13]

[9,12,15]

[12,16,20]</pre>

 

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

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.

 

}

 

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

]];

 

 

{{omit from|Axe}}

{{omit from|Maxima}}