Idioms in python: closure vs functor vs object
So the correct answer to this is the callable object, which essentially replaces the idiom of the closure in python.
so working off option 3 above change:
class Calculator(Object) :
def __init__(self):
self.previous_state=None
def do_something(self, current_state) :
#do_something
self.previous_state = current_state
return something
to
class Calculator(Object) :
def __init__(self):
self.previous_state=None
def __call__(self, current_state) :
#do_something
self.previous_state = current_state
return something
and now you can call it like a function. So
func = Calculator():
for x in list:
func(x)
You can define a generator, which is a restricted form of a coprocess.
def make_gen():
previous_state = None
for row in rows:
# do something
previous_state = current_state
yield something
thing = make_gen()
for item in thing:
# Each iteration, item is a different value
# "returned" by the yield statement in the generator
Instead of calling thing
(which replaces your inner function) repeatedly, you iterate over it (which is basically the same as calling next(thing)
repeatedly).
The state is entirely contained within the body of the generator.
If you don't want to actually iterate over it, you can still selectively "re-enter" the coprocess by calling next
explicitly.
thing = make_gen()
first_item = next(thing)
# do some stuff
second_item = next(thing)
# do more stuff
third_item = next(thing)
fourth_item = next(thing)
# etc