Question

I have this code:

class LFSeq: # lazy infinite sequence with new elements from func
    def __init__(self, func):
        self.evaluated = []
        self.func = func
    class __iter__:
        def __init__(self, seq):
            self.index = 0
            self.seq = seq
        def next(self):
            if self.index >= len(self.seq.evaluated):
                self.seq.evaluated += [self.seq.func()]
            self.index += 1
            return self.seq.evaluated[self.index - 1]

And I explicitely want that LFSeq.__iter__ becomes bounded to an instance of LFSeq like any other user-defined function would have been.

It doesn’t work this way though because only user-defined functions are bounded and not classes.

When I introduce a function decorator like

def bound(f):
    def dummy(*args, **kwargs):
        return f(*args, **kwargs)
    return dummy

then I can decorate __iter__ by it and it works:

...
@bound
class __iter__:
    ...

This feels somehow hacky and inconsistent however. Is there any other way? Should it be that way?

I guess yes because otherwise LFSeq.__iter__ and LFSeq(None).__iter__ wouldn’t be the same object anymore (i.e. the class object). Maybe the whole thing about bounded functions should have been syntactic sugar instead of having it in the runtime. But then, on the other side, syntactic sugar shouldn’t really dependent on content. I guess there has to be some tradeoff at some place.

Answer 1

The easiest solution for what you are trying to do is to define your __iter__() method as a generator function:

class LFSeq(object):
    def __init__(self, func):
        self.evaluated = []
        self.func = func
    def __iter__(self):
        index = 0
        while True:
            if index == len(self.evaluated):
                self.evaluated.append(self.func())
            yield self.evaluated[index]
            index += 1

Your approach would have to deal with lots of subtleties of the Python object model, and there’s no reason to go that route.