Using itertools for recursive function application

Question

I need a Python function iterate(f, x) that creates an iterator returning the values x, f(x), f(f(x)), f(f(f(x))), etc (like, e.g., Clojure's iterate). First of all, I was wondering: Does this already exist somewhere in the standard library and I'm only missing it? Of course it's easy enough to implement with a generator:

def iterate(f, x):
    while True:
        yield x
        x = f(x)

Just out of curiosity: Is there a more functional way to do this in Python, e.g. with some itertools or functools magic?

In Python 3.3 this would work

def iterate(f, x):
    return accumulate(repeat(x), lambda acc, _ : f(acc))

but looks like an abuse to me. Can I do this more nicely?

Answer 1

There doesn't seem to be something in itertools that does what you want, but itertools is a deep treasure chest, so I could have missed something.

Your generator code looks great. I don't know why you'd write it with accumulate unless you were playing an absurd game of code golf, or you were trying to impress Haskell snobs. Write your function so that it is readable, understandable, and maintainable. No need to be overly clever.

Answer 2

You can use an anamorphism (or unfold) to simplify the definition of iterate, and to use only one starting value. Here's an implementation I once used, based on a quite well-known paper:

def ana(build, predicate):
    def h(x):
        if predicate(x):
            return
        else:
            a, b = build(x)
            yield a
            for i in h(b):
                yield i
            # with newer syntax: 
            # yield from h(b)
    return h

Implementing iterate with ana then looks like this:

def iterate(f, x):
    return ana(lambda x: (x, f(x)), lambda _: False)(x)

No itertools, though... And I agree that this isn't the most readable variant. In fact, it is rather cryptic.

---

UPDATE: There's an easier version, which even looks quite nice. It's taken from here:

def unfold(f, x):
    while True:
        w, x = f(x)
        yield w

And that gives you:

def iterate(f, x):
    return unfold(lambda y: (y, f(y)), x)