Menu
Home
People
Places
Arts
History
Plants & Animals
Science
Life & Culture
Technology
Reference.org
List comprehension
open-in-new
<h2 id="overview">Overview</h2> <p>Consider the following example in mathematical <a href="/facts/Set-builder_notation/0nVHQF6E">set-builder notation</a>. </p> S = { 2 ⋅ x ∣ x ∈ N , x 2 > 3 } {\displaystyle S=\{2\cdot x\mid x\in \mathbb {N} ,\ x^{2}>3\}} <p>or often </p> S = { 2 ⋅ x : x ∈ N , x 2 > 3 } {\displaystyle S=\{2\cdot x:x\in \mathbb {N} ,\ x^{2}>3\}} <p>This can be read, " S {\displaystyle S} is the set of all numbers "2 times x {\displaystyle x} " SUCH THAT x {\displaystyle x} is an ELEMENT or MEMBER of the set of <a href="/facts/Natural_number/u65og8JE">natural numbers</a> ( N {\displaystyle \mathbb {N} } ), AND x {\displaystyle x} squared is greater than 3 {\displaystyle 3} ." </p><p>The smallest natural number, x = 1, fails to satisfy the condition x2>3 (the condition 12>3 is false) so 2 ·1 is not included in S. The next natural number, 2, does satisfy the condition (22>3) as does every other natural number. Thus x consists of 2, 3, 4, 5... Since the set S consists of all numbers "2 times x" it is given by S = {4, 6, 8, 10,...}. S is, in other words, the set of all even numbers greater than 2. </p><p>In this annotated version of the example: </p> S = { 2 ⋅ x ⏟ output expression ∣ x ⏟ variable ∈ N ⏟ input set , x 2 > 3 ⏟ predicate } {\displaystyle S=\{\underbrace {2\cdot x} _{\color {Violet}{\text{output expression}}}\mid \underbrace {x} _{\color {Violet}{\text{variable}}}\in \underbrace {\mathbb {N} } _{\color {Violet}{\text{input set}}},\ \underbrace {x^{2}>3} _{\color {Violet}{\text{predicate}}}\}} <ul><li> x {\displaystyle x} is the variable representing members of an input set.</li> <li> N {\displaystyle \mathbb {N} } represents the input set, which in this example is the set of natural numbers</li> <li> x 2 > 3 {\displaystyle x^{2}>3} is a <a href="/facts/Predicate_(logic)/5WazAvKF">predicate</a> expression acting as a filter on members of the input set.</li> <li> 2 ⋅ x {\displaystyle 2\cdot x} is an output expression producing members of the new set from members of the input set that satisfy the predicate expression.</li> <li> { } {\displaystyle \{\}} braces indicate that the result is a set</li> <li> ∣ {\displaystyle \mid } , {\displaystyle ,} the vertical bar is read as "SUCH THAT". The bar and the colon ":" are used interchangeably.</li> <li>commas separate the predicates and can be read as "AND".</li></ul> <p>A list comprehension has the same syntactic components to represent generation of a list in order from an input <a href="/facts/List_(computing)/9tzhAH6M">list</a> or <a href="/facts/Iterator/f0HhTBWz">iterator</a>: </p> <ul><li>A variable representing members of an input list.</li> <li>An input list (or iterator).</li> <li>An optional predicate expression.</li> <li>And an output expression producing members of the output list from members of the input iterable that satisfy the predicate.</li></ul> <p>The order of generation of members of the output list is based on the order of items in the input. </p><p>In <a href="/facts/Haskell_(programming_language)/4Htv9WLu">Haskell's</a> list comprehension syntax, this set-builder construct would be written similarly, as: </p> s = [ 2*x | x <- [0..], x^2 > 3 ] <p>Here, the list [0..] represents N {\displaystyle \mathbb {N} } , x^2>3 represents the predicate, and 2*x represents the output expression. </p><p>List comprehensions give results in a defined order (unlike the members of sets); and list comprehensions may <a href="/facts/Generator_(computer_science)/nHRrs0GF">generate</a> the members of a list in order, rather than produce the entirety of the list thus allowing, for example, the previous Haskell definition of the members of an infinite list. </p> <h2 id="history">History</h2> <p>The existence of related constructs predates the use of the term "List Comprehension". The <a href="/facts/SETL/VF8l7bME">SETL</a> programming language (1969) has a set formation construct which is similar to list comprehensions. E.g., this code prints all prime numbers from 2 to N: </p> print([n in [2..N] | forall m in {2..n - 1} | n mod m > 0]); <p>The <a href="/facts/Computer_algebra_system/jkLAC1U3">computer algebra system</a> <a href="/facts/Axiom_(computer_algebra_system)/l23pr0bP">AXIOM</a> (1973) has a similar construct that processes <a href="/facts/Stream_(computing)/2jtBAp0U">streams</a>. </p><p>The first use of the term "comprehension" for such constructs was in <a href="/facts/Rod_Burstall/BhNTxat5">Rod Burstall</a> and <a href="/facts/John_Darlington/EfKAWHDz">John Darlington</a>'s description of their functional programming language <a href="/facts/NPL_programming_language/Pdw0t7LF">NPL</a> from 1977. In his retrospective "Some History of Functional Programming Languages",<a class="footnote-ref" id="fnref:1" href="#fn:1"><sup>1</sup></a> <a href="/facts/David_Turner_(computer_scientist)/3mQuLpdo">David Turner</a> recalls: </p> <blockquote><p>NPL was implemented in POP2 by Burstall and used for Darlington’s work on program transformation (Burstall & Darlington 1977). The language was first order, strongly (but not polymorphically) typed, purely functional, call-by-value. It also had “set expressions” e.g. </p>setofeven (X) <= <:x : x in X & even(x):>}}</blockquote> <p>In a footnote attached to the term "list comprehension", Turner also notes </p> <blockquote><p>I initially called these <i>ZF expressions</i>, a reference to <a href="/facts/Zermelo%25E2%2580%2593Fraenkel_set_theory/UYIsPbXw">Zermelo–Fraenkel set theory</a> — it was <a href="/facts/Philip_Wadler/ShX91nId">Phil Wadler</a> who coined the better term <i>list comprehension</i>.</p></blockquote> <p>Burstall and Darlington's work with NPL influenced many functional programming languages during the 1980s, but not all included list comprehensions. An exception was Turner's influential, pure, lazy, functional programming language <a href="/facts/Miranda_programming_language/t9A6GFYv">Miranda</a>, released in 1985. The subsequently developed standard pure lazy functional language <a href="/facts/Haskell_programming_language/4Htv9WLu">Haskell</a> includes many of Miranda's features, including list comprehensions. </p><p>Comprehensions were proposed as a query notation for databases<a class="footnote-ref" id="fnref:2" href="#fn:2"><sup>2</sup></a> and were implemented in the <i><a href="/facts/Heinrich_Kleisli/mJK1LNNt">Kleisli</a></i> database query language.<a class="footnote-ref" id="fnref:3" href="#fn:3"><sup>3</sup></a> </p> <h2 id="examples-in-different-programming-languages">Examples in different programming languages</h2> <p class="note">Main article: <a href="/facts/Comparison_of_programming_languages_(list_comprehension)/8QS3yMJ2">Comparison of programming languages (list comprehension)</a></p> <h2 id="similar-constructs">Similar constructs</h2> <h3>Monad comprehension</h3> <p>In Haskell, a <a href="/facts/Monads_in_functional_programming/kYazRoF1">monad comprehension</a> is a generalization of the list comprehension to other <a href="/facts/Monads_in_functional_programming/kYazRoF1">monads in functional programming</a>. </p> <h3>Set comprehension</h3> <p>The <a href="/facts/Python_(programming_language)/YbuGqofa">Python</a> language introduces syntax for <a href="/facts/Set_(computer_science)/ovoXUmF9">set</a> comprehensions starting in version 2.7. Similar in form to list comprehensions, set comprehensions generate Python sets instead of lists. </p> >>> s = {v for v in 'ABCDABCD' if v not in 'CB'} >>> print(s) {'A', 'D'} >>> type(s) <class 'set'> >>> <p><a href="/facts/Racket_(programming_language)/5n7LW08b">Racket</a> set comprehensions generate Racket sets instead of lists. </p> (for/set ([v "ABCDABCD"] #:unless (member v (string->list "CB"))) v)) <h3>Dictionary comprehension</h3> <p>The <a href="/facts/Python_(programming_language)/YbuGqofa">Python</a> language introduced a new syntax for <a href="/facts/Associative_array/IFGd2xcP">dictionary</a> comprehensions in version 2.7, similar in form to list comprehensions but which generate Python <a href="https://docs.python.org/library/stdtypes.html#dict">dicts</a> instead of lists. </p> >>> s = {key: val for key, val in enumerate('ABCD') if val not in 'CB'} >>> s {0: 'A', 3: 'D'} >>> <p>Racket hash table comprehensions generate Racket hash tables (one implementation of the Racket dictionary type). </p> (for/hash ([(val key) (in-indexed "ABCD")] #:unless (member val (string->list "CB"))) (values key val)) <h3>Parallel list comprehension</h3> <p>The <a href="/facts/Glasgow_Haskell_Compiler/4msB3KFN">Glasgow Haskell Compiler</a> has an extension called parallel list comprehension (also known as zip-comprehension) that permits multiple independent branches of qualifiers within the list comprehension syntax. Whereas qualifiers separated by commas are dependent ("nested"), qualifier branches separated by pipes are evaluated in parallel (this does not refer to any form of multithreadedness: it merely means that the branches are <a href="/facts/Map_(higher-order_function)/GdzN4UJl">zipped</a>). </p> -- regular list comprehension a = [(x,y) | x <- [1..5], y <- [3..5]] -- [(1,3),(1,4),(1,5),(2,3),(2,4) ... -- zipped list comprehension b = [(x,y) | (x,y) <- zip [1..5] [3..5]] -- [(1,3),(2,4),(3,5)] -- parallel list comprehension c = [(x,y) | x <- [1..5] | y <- [3..5]] -- [(1,3),(2,4),(3,5)] <p>Racket's comprehensions standard library contains parallel and nested versions of its comprehensions, distinguished by "for" vs "for*" in the name. For example, the vector comprehensions "for/vector" and "for*/vector" create vectors by parallel versus nested iteration over sequences. The following is Racket code for the Haskell list comprehension examples. </p> > (for*/list ([x (in-range 1 6)] [y (in-range 3 6)]) (list x y)) '((1 3) (1 4) (1 5) (2 3) (2 4) (2 5) (3 3) (3 4) (3 5) (4 3) (4 4) (4 5) (5 3) (5 4) (5 5)) > (for/list ([x (in-range 1 6)] [y (in-range 3 6)]) (list x y)) '((1 3) (2 4) (3 5)) <p>In Python, we could do as follows: </p> >>> # regular list comprehension >>> a = [(x, y) for x in range(1, 6) for y in range(3, 6)] [(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), ... >>> >>> # parallel/zipped list comprehension >>> b = [x for x in zip(range(1, 6), range(3, 6))] [(1, 3), (2, 4), (3, 5)] <p>In Julia, practically the same results can be achieved as follows: </p> # regular array comprehension >>> a = [(x, y) for x in 1:5 for y in 3:5] # parallel/zipped array comprehension >>> b = [x for x in zip(1:3, 3:5)] <p>with the only difference that instead of lists, in Julia, we have arrays. </p> <h3>XQuery and XPath</h3> <p>Like the original NPL use, these are fundamentally database access languages. </p><p>This makes the comprehension concept more important, because it is computationally infeasible to retrieve the entire list and operate on it (the initial 'entire list' may be an entire XML database). </p><p>In XPath, the expression: </p> /library/book//paragraph[@style='first-in-chapter'] <p>is conceptually evaluated as a series of "steps" where each step produces a list and the next step applies a filter function to each element in the previous step's output.<a class="footnote-ref" id="fnref:4" href="#fn:4"><sup>4</sup></a> </p><p>In XQuery, full XPath is available, but <a href="/facts/FLWOR/RWapbW8R">FLWOR</a> statements are also used, which is a more powerful comprehension construct.<a class="footnote-ref" id="fnref:5" href="#fn:5"><sup>5</sup></a> </p> for $b in //book where $b[@pages < 400] order by $b//title return <shortBook> <title>{$b//title}</title> <firstPara>{($book//paragraph)[1]}</firstPara> </shortBook> <p>Here the XPath //book is evaluated to create a sequence (aka list); the where clause is a functional "filter", the order by sorts the result, and the <shortBook>...</shortBook> XML snippet is actually an <a href="/facts/Anonymous_function/2vdyE4zL">anonymous function</a> that builds/transforms XML for each element in the sequence using the 'map' approach found in other functional languages. </p><p>So, in another functional language the above FLWOR statement may be implemented like this: </p> map( newXML(shortBook, newXML(title, $1.title), newXML(firstPara, $1...)) filter( lt($1.pages, 400), xpath(//book) ) ) <h3>LINQ in C#</h3> <p><a href="/facts/C_Sharp_(programming_language)/UC2gxeyb">C#</a> 3.0 has a group of related features called <a href="/facts/Language_Integrated_Query/qz61xeUf">LINQ</a>, which defines a set of query operators for manipulating object enumerations. </p> var s = Enumerable.Range(0, 100).Where(x => x * x > 3).Select(x => x * 2); <p>It also offers an alternative comprehension syntax, reminiscent of SQL: </p> var s = from x in Enumerable.Range(0, 100) where x * x > 3 select x * 2; <p>LINQ provides a capability over typical list comprehension implementations. When the root object of the comprehension implements the IQueryable interface, rather than just executing the chained methods of the comprehension, the entire sequence of commands are converted into an <a href="/facts/Abstract_syntax_tree/73AUK1jI">abstract syntax tree</a> (AST) object, which is passed to the IQueryable object to interpret and execute. </p><p>This allows, amongst other things, for the IQueryable to </p> <ul><li>rewrite an incompatible or inefficient comprehension</li> <li>translate the AST into another query language (e.g. SQL) for execution</li></ul> <h3>C++</h3> <p>C++ does not have any language features directly supporting list comprehensions but <a href="/facts/Operator_overloading/hRyHs4Qf">operator overloading</a> (e.g., overloading |, >>, >>=) has been used successfully to provide expressive syntax for "embedded" query <a href="/facts/Domain-specific_language/n18H1foD">domain-specific languages</a> (DSL). Alternatively, list comprehensions can be constructed using the <a href="/facts/Erase-remove_idiom/AeHg5flv">erase-remove idiom</a> to select elements in a container and the STL algorithm for_each to transform them. </p> #include <algorithm> #include <list> #include <numeric> using namespace std; template<class C, class P, class T> C comprehend(C&& source, const P& predicate, const T& transformation) { // initialize destination C d = forward<C>(source); // filter elements d.erase(remove_if(begin(d), end(d), predicate), end(d)); // apply transformation for_each(begin(d), end(d), transformation); return d; } int main() { list<int> range(10); // range is a list of 10 elements, all zero iota(begin(range), end(range), 1); // range now contains 1, 2, ..., 10 list<int> result = comprehend( range, [](int x) { return x * x <= 3; }, [](int &x) { x *= 2; }); // result now contains 4, 6, ..., 20 } <p>There is some effort in providing C++ with list-comprehension constructs/syntax similar to the set builder notation. </p> <ul><li>In <a href="/facts/Boost_C%252B%252B_Libraries/vGLGG51A">Boost</a>. Range <a href="http://www.boost.org/libs/range">[1]</a> library there is a notion of adaptors <a href="http://www.boost.org/libs/range/doc/html/range/reference/adaptors.html">[2]</a> that can be applied to any range and do filtering, transformation etc. With this library, the original Haskell example would look like (using Boost.Lambda <a href="http://www.boost.org/libs/lambda">[3]</a> for anonymous filtering and transforming functions) (<a href="http://codepad.org/y4bpgLJu">Full example</a>):counting_range(1,10) | filtered( _1*_1 > 3 ) | transformed(ret<int>( _1*2 )) </li> <li>This<a class="footnote-ref" id="fnref:6" href="#fn:6"><sup>6</sup></a> implementation uses a macro and overloads the << operator. It evaluates any expression valid inside an 'if', and any variable name may be chosen. It's not <a href="/facts/Thread_safety/fx3ULqUw">threadsafe</a>, however. Usage example:</li></ul> list<int> N; list<double> S; for (int i = 0; i < 10; i++) N.push_back(i); S << list_comprehension(3.1415 * x, x, N, x * x > 3) <ul><li>This<a class="footnote-ref" id="fnref:7" href="#fn:7"><sup>7</sup></a> implementation provides head/tail slicing using classes and operator overloading, and the | operator for filtering lists (using functions). Usage example:</li></ul> bool even(int x) { return x % 2 == 0; } bool x2(int &x) { x *= 2; return true; } list<int> l, t; int x, y; for (int i = 0; i < 10; i++) l.push_back(i); (x, t) = l | x2; (t, y) = t; t = l < 9; t = t < 7 | even | x2; <ul><li>Language for Embedded Query and Traversal (LEESA<a class="footnote-ref" id="fnref:8" href="#fn:8"><sup>8</sup></a>) is an embedded DSL in C++ that implements X-Path-like queries using operator overloading. The queries are executed on richly typed xml trees obtained using xml-to-c++ binding from an XSD. There is absolutely no string encoding. Even the names of the xml tags are classes and therefore, there is no way for typos. If a LEESA expression forms an incorrect path that does not exist in the data model, the C++ compiler will reject the code.Consider a catalog xml.</li></ul> <catalog> <book> <title>Hamlet</title> <price>9.99</price> <author> <name>William Shakespeare</name> <country>England</country> </author> </book> <book>...</book> ... </catalog> <p>LEESA provides >> for XPath's / separator. XPath's // separator that "skips" intermediate nodes in the tree is implemented in LEESA using what's known as Strategic Programming. In the example below, catalog_, book_, author_, and name_ are instances of catalog, book, author, and name classes, respectively. </p> // Equivalent X-Path: "catalog/book/author/name" std::vector<name> author_names = evaluate(root, catalog_ >> book_ >> author_ >> name_); // Equivalent X-Path: "catalog//name" std::vector<name> author_names = evaluate(root, catalog_ >> DescendantsOf(catalog_, name_)); // Equivalent X-Path: "catalog//author[country=="England"]" std::vector<name> author_names = evaluate(root, catalog_ >> DescendantsOf(catalog_, author_) >> Select(author_, [](const author & a) { return a.country() == "England"; }) >> name_); <h2 id="see-also">See also</h2> <ul><li><a href="/facts/Set-builder_notation/0nVHQF6E">Set-builder notation</a></li> <li>The <a href="/facts/Select_(SQL)/cYnKkmFo">SELECT</a> statement together with its FROM and WHERE clauses in <a href="/facts/SQL/UjQLJcYm">SQL</a></li></ul> <h2 id="notes-and-references">Notes and references</h2> <ul><li><a href="https://web.archive.org/web/20050125080818/http://ftp.sunet.se/foldoc/foldoc.cgi?list+comprehension">List Comprehension</a> in The Free On-line Dictionary of Computing, Editor Denis Howe.</li> <li>Wadler, Philip (1990). <a href="http://citeseer.ist.psu.edu/wadler92comprehending.html">"Comprehending Monads"</a>. <i>Proceedings of the 1990 ACM Conference on LISP and Functional Programming, Nice</i>.</li></ul> <h2 id="external-links">External links</h2> <ul><li>SQL-like set operations with list comprehension one-liners in the <a href="http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/159974">Python Cookbook</a></li> <li><a href="http://lambda-the-ultimate.org/classic/message11326.html">Discussion on list comprehensions in Scheme and related constructs</a></li> <li><a href="http://langexplr.blogspot.com/2007/02/list-comprehensions-across-languages_18.html">List Comprehensions across languages</a></li></ul> <h3>Axiom</h3> <ul><li><a href="https://web.archive.org/web/20051018040438/http://page.axiom-developer.org/zope/mathaction/Streams">Axiom stream examples</a></li></ul> <h3>Clojure</h3> <ul><li><a href="https://clojuredocs.org/clojure.core/for">Clojure API documentation - <i>for</i> macro</a></li></ul> <h3>Common Lisp</h3> <ul><li><a href="http://rali.iro.umontreal.ca/rali/?q=en/node/886">Implementation of a Lisp comprehension macro</a> by Guy Lapalme</li></ul> <h3>Haskell</h3> <ul><li>The Haskell 98 Report, chapter <a href="http://haskell.org/onlinereport/exps.html#list-comprehensions">3.11 List Comprehensions</a>.</li> <li>The Glorious Glasgow Haskell Compilation System User's Guide, chapter <a href="https://web.archive.org/web/20051129140339/http://www.haskell.org/ghc/docs/latest/html/users_guide/syntax-extns.html#parallel-list-comprehensions">7.3.4 Parallel List Comprehensions</a>.</li> <li>The Hugs 98 User's Guide, chapter <a href="https://web.archive.org/web/20140515114545/http://cvs.haskell.org/Hugs/pages/users_guide/hugs-ghc.html#ZIP-COMPREHENSION">5.1.2 Parallel list comprehensions (a.k.a. zip-comprehensions)</a>.</li></ul> <h3>OCaml</h3> <ul><li><a href="http://batteries.forge.ocamlcore.org/">OCaml Batteries Included</a></li> <li><a href="http://batteries.forge.ocamlcore.org/doc.preview:batteries-alpha3/html/extensions.html">Language extensions introduced in OCaml Batteries Included</a></li></ul> <h3>Python</h3> <ul><li>The Python Tutorial, <a href="https://docs.python.org/tutorial/datastructures.html#list-comprehensions">List Comprehensions</a>.</li> <li>Python Language Reference, <a href="https://docs.python.org/reference/expressions.html#list-displays">List displays</a>.</li> <li>Python Enhancement Proposal <a href="https://www.python.org/peps/pep-0202.html">PEP 202: List Comprehensions</a>.</li> <li>Python Language Reference, <a href="https://docs.python.org/reference/expressions.html#generator-expressions">Generator expressions</a>.</li> <li>Python Enhancement Proposal <a href="https://python.org/peps/pep-0289.html">PEP 289: Generator Expressions</a>.</li></ul> <h2 id="references">References</h2> <ol> <li id="fn:1"><p>Turner, David (2012). "Some history of functional programming languages" (PDF). International Symposium on Trends in Functional Programming, Springer, Berlin, Heidelberg. pp. 1–20. <a href="https://www.cs.kent.ac.uk/people/staff/dat/tfp12/tfp12.pdf" target="_blank">https://www.cs.kent.ac.uk/people/staff/dat/tfp12/tfp12.pdf</a> <a href="#fnref:1" class="footnote-back-ref">↩</a></p></li> <li id="fn:2"><p>Comprehensions, a query notation for DBPLs <a href="http://portal.acm.org/citation.cfm?coll=GUIDE&dl=GUIDE&id=135271" target="_blank">http://portal.acm.org/citation.cfm?coll=GUIDE&dl=GUIDE&id=135271</a> <a href="#fnref:2" class="footnote-back-ref">↩</a></p></li> <li id="fn:3"><p>The functional guts of the Kleisli query system <a href="http://portal.acm.org/citation.cfm?id=351241&dl=ACM&coll=portal" target="_blank">http://portal.acm.org/citation.cfm?id=351241&dl=ACM&coll=portal</a> <a href="#fnref:3" class="footnote-back-ref">↩</a></p></li> <li id="fn:4"><p>"2.1 Location Steps". XML Path Language (XPath). W3C. 16 November 1999. Archived from the original on 9 December 2012. Retrieved 24 December 2008. <a href="https://web.archive.org/web/20121209085946/http://www.w3.org/TR/xpath/#section-Location-Steps" target="_blank">https://web.archive.org/web/20121209085946/http://www.w3.org/TR/xpath/#section-Location-Steps</a> <a href="#fnref:4" class="footnote-back-ref">↩</a></p></li> <li id="fn:5"><p>"XQuery FLWOR Expressions". W3Schools. Archived from the original on 2011-10-08. <a href="https://web.archive.org/web/20111008001258/http://w3schools.com/xquery/xquery_flwor.asp" target="_blank">https://web.archive.org/web/20111008001258/http://w3schools.com/xquery/xquery_flwor.asp</a> <a href="#fnref:5" class="footnote-back-ref">↩</a></p></li> <li id="fn:6"><p>"Single-variable List Comprehension in C++ using Preprocessor Macros". Archived from the original on 2011-08-21. Retrieved 2011-01-09. <a href="https://web.archive.org/web/20110821211656/http://mfoliveira.org/blog/2011/01/04/simple-list-comprehension-in-cp-using-preprocessor-macros/" target="_blank">https://web.archive.org/web/20110821211656/http://mfoliveira.org/blog/2011/01/04/simple-list-comprehension-in-cp-using-preprocessor-macros/</a> <a href="#fnref:6" class="footnote-back-ref">↩</a></p></li> <li id="fn:7"><p>"C++ list comprehensions". Archived from the original on 2017-07-07. Retrieved 2011-01-09. <a href="https://web.archive.org/web/20170707125836/http://www.tedunangst.com/listcc.html" target="_blank">https://web.archive.org/web/20170707125836/http://www.tedunangst.com/listcc.html</a> <a href="#fnref:7" class="footnote-back-ref">↩</a></p></li> <li id="fn:8"><p>"Language for Embedded Query and Traversal (LEESA)". <a href="http://www.dre.vanderbilt.edu/LEESA/" target="_blank">http://www.dre.vanderbilt.edu/LEESA/</a> <a href="#fnref:8" class="footnote-back-ref">↩</a></p></li> </ol>