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

Start Free Trial

No credit card required