Lijstcomprehensie

In programmeertalen is lijstcomprehensie een syntactische constructie om een lijst te noteren. Het is gebaseerd op de wiskundige notatie voor verzamelingen. Een lijstcomprehensie is syntactische suiker aangezien hetzelfde ook op een andere manier kan worden geprogrammeerd, zoals met de hogere-ordefuncties map en filter. Enkele programmeertalen waarin men lijstcomprehensie kan gebruiken zijn Python en Haskell.

Overzicht

Het is in de wiskunde mogelijk een verzameling als volgt te noteren:

${\displaystyle S=\{\,2\cdot x\mid x\in \mathbb {N} ,\ x^{2}>10\,\}}$

Dit kan worden gelezen als: '${\displaystyle S}$ is de verzameling van alle producten '2 maal ${\displaystyle x}$', waarvoor geldt dat ${\displaystyle x}$ een element is van de verzameling natuurlijke getallen en dat ${\displaystyle x}$ in het kwadraat groter is dan 10'.

Deze notatie bevat de volgende onderdelen:

• ${\displaystyle 2\cdot x}$: een functie die op alle elementen wordt toegepast.
• ${\displaystyle x}$: een variabele die wordt gebruikt om de elementen van de verzameling ${\displaystyle \mathbb {N} }$ te benoemen.
• ${\displaystyle \mathbb {N} }$: de verzameling die als invoer dient.
• ${\displaystyle x^{2}>10}$: een predicaat dat moet gelden voor de elementen die in de verzameling komen.

Voorbeeld

In de functionele programmeertaal Haskell kan het bovenstaande geschreven worden als:

[ 2 * x | x <- [0..], x * x > 10 ]

Hierin staat [0..] voor de lijst natuurlijke getallen. Het gedeelte x <- [0..] wordt een generator genoemd.

De bovenstaande lijstcomprehensie kan ook als volgt worden genoteerd:

map (\x -> 2 * x) (filter (\x -> x * x > 10) [0..])

Het is ook mogelijk meer generatoren en meer predicaten te gebruiken, zoals:

[ (x, y) | x <- [1..10], x `rem` 3 == 0, y <- [1..10], x + y == 7 ]

Syntactische suiker

Lijstcomprehensie is een vorm van syntactische suiker aangezien de code ervoor ook in bestaande taalconstructies kan worden uitgedrukt. Voor de programmeertaal Haskell beschrijft het Haskell 98 Report[1] een systematische manier om lijstcomprehensies om te schrijven naar bestaande taalconstructies, zoals let ... in ... en if ... then ... else ....

Zo wordt [ x | x <- [0..], x `rem` 2 == 0 ] bijvoorbeeld omgeschreven naar:

let ok x = if x `rem` 2 == 0 then [x] else []
    ok _ = []
in concatMap ok [0..]

Hierin is rem een functie die de rest van een deling oplevert. De functie concatMap ok [0..] is hetzelfde als concat (map ok [0..]), waarbij map de functie map is en concat de concatenatie van een lijst.

Voetnoten

1. The Haskell 98 Report. 3 List Comprehensions, december 2002.