Source : Free On-Line Dictionary of Computing

list comprehension
     
         An expression in a {functional
        language} denoting the results of some operation on (selected)
        elements of one or more lists.  An example in {Haskell}:
     
        [ (x,y) | x <- [1 .. 6], y <- [1 .. x], x+y < 10]
     
        This returns all pairs of numbers (x,y) where x and y are
        elements of the list 1, 2, ..., 10, y <= x and their sum is
        less than 10.
     
        A list comprehension is simply "{syntactic sugar}" for a
        combination of applications of the functions, concat, map and
        filter.  For instance the above example could be written:
     
        	filter p (concat (map (\ x -> map (\ y -> (x,y))
        			 [1..x]) [1..6]))
        	where
        	p (x,y) = x+y < 10
     
        According to a note by Rishiyur Nikhil ,
        (August 1992), the term itself seems to have been coined by
        Phil Wadler circa 1983-5, although the programming construct
        itself goes back much further (most likely Jack Schwartz and
        the SETL language).
     
        The term "list comprehension" appears in the references below.
     
        The earliest reference to the notation is in Rod Burstall and
        John Darlington's description of their language, NPL.
     
        David Turner subsequently adopted this notation in his
        languages SASL, KRC and Miranda, where he has called them "{ZF
        expression}s", set abstractions and list abstractions (in his
        1985 FPCA paper [Miranda: A Non-Strict Functional Language
        with Polymorphic Types]).
     
        ["The OL Manual" Philip Wadler, Quentin Miller and Martin
        Raskovsky, probably 1983-1985].
     
        ["How to Replace Failure by a List of Successes" FPCA
        September 1985, Nancy, France, pp. 113-146].
     
        (1995-02-22)