Great question! It’s definitely surprising that such a foundational functional programming tool isn’t included in Python’s functools or itertools modules by default. Let’s walk through how to recreate Haskell’s iterate function using pure functional style—no explicit loops allowed, just leveraging the standard library tools you mentioned.

First, let’s recap what we’re aiming for. In Haskell, iterate generates an infinite list starting with an initial value, then repeatedly applying a function to the previous element:

Haskell's iterate definition:

iterate :: (a -> a) -> a -> [a]
iterate f x = x : iterate f (f x)

The standard Python generator implementation uses a while loop, which works fine, but we want to avoid loops entirely. Here are a couple of clean, functional-style approaches:

1. Using itertools.accumulate + itertools.repeat #

This is probably the most straightforward functional implementation. We can use accumulate to build our infinite sequence, paired with repeat to feed a dummy infinite iterator that we’ll ignore:

from itertools import accumulate, repeat

def iterate(f, init):
    # repeat(init) gives an infinite stream of the initial value
    # accumulate applies f to the previous result each time, ignoring the dummy value
    return accumulate(repeat(init), lambda acc, _: f(acc))

How it works:

• repeat(init) creates an infinite iterator that keeps yielding init (we don’t actually use these values—they’re just there to trigger accumulate to run infinitely).
• accumulate starts with init, then for each subsequent step, applies our lambda: takes the accumulated value (acc), applies f to it, and returns that as the next element in the sequence.

2. Using itertools.count + functools.reduce #

If we want to lean into function composition a bit more, we can use count to generate an infinite sequence of integers, and use reduce to apply f repeatedly n times for each integer n:

from itertools import count
from functools import reduce

def iterate(f, init):
    def apply_n_times(n):
        # Apply f n times to init: f(f(...f(init)...))
        return reduce(lambda acc, _: f(acc), range(n), init)
    # Yield apply_n_times(0), apply_n_times(1), apply_n_times(2), ...
    return (apply_n_times(n) for n in count())

This one works by generating every possible number of applications of f to init—starting with 0 applications (just init), then 1 application (f(init)), then 2, etc.

Both of these implementations are pure functional: no while or for loops, just composing standard library functions to build the infinite sequence, matching Haskell’s iterate behavior exactly.

内容的提问来源于stack exchange，提问作者user1747134