# Chapter 3. Lazy Evaluation

A powerful feature of Python is its iterator protocol (which we will get to shortly). This capability is only loosely connected to functional programming per se, since Python does not quite offer lazy data structures in the sense of a language like Haskell. However, use of the iterator protocol—and Python’s many built-in or standard library iteratables—accomplish much the same effect as an actual lazy data structure.

Let us explain the contrast here in slightly more detail. In a language like Haskell, which is inherently lazily evaluated, we might define a list of all the prime numbers in a manner like the following:

````-- Define a list of ALL the prime numbers`
`primes` `=` `sieve` `[``2` `..``]`
`where` `sieve` `(``p``:``xs``)` `=` `p` `:` `sieve` `[``x` `|` `x` `<-` `xs``,` `(``x` ````rem```` `p``)``/=``0``]````

This report is not the place to try to teach Haskell, but you can see a comprehension in there, which is in fact the model that Python used in introducing its own comprehensions. There is also deep recursion involved, which is not going to work in Python.

Apart from syntactic differences, or even the ability to recurse to indefinite depth, the significant difference here is that the Haskell version of `primes` is an actual (infinite) sequence, not just an object capable of sequentially producing elements (as was the `primes` object we demonstrated in the chapter entitled “Callables”). In particular, you can index into an arbitrary element of the infinite list of primes in Haskell, and the intermediate values will be produced ...

Get Functional Programming in Python now with O’Reilly online learning.

O’Reilly members experience live online training, plus books, videos, and digital content from 200+ publishers.