Ho scritto una funzione e mi piacerebbe scoprire se si tratta di un'implementazione di alcuni pattern o costrutti di programmazione funzionale. Mi piacerebbe scoprire il nome di questo modello o costrutto (se esiste)?
Ho una funzione che prende un elenco di funzioni e fa questo a loro:
wrap(fn1, fn2, fn3, fn4)
# returns
partial(fn4, partial(fn3, partial(fn2, fn1)))
Ci sono forti similitudini con la composizione, la riduzione e altri costrutti di metaprogrammazione fp, dal momento che le funzioni sono organizzate insieme e restituite come un'unica funzione.
Ha anche forti somiglianze con decoratori e gestori di contesto Python poiché fornisce un modo per incapsulare comportamenti pre e post esecuzione in un'unica funzione. Quale fu l'impulso per scrivere questa funzione. Volevo l'abilità fornita dai gestori di contesto, ma volevo essere in grado di definirla in una funzione e di essere in grado di sovrapporre la funzione dopo la funzione.
UPDATE:
Per chiarezza ho aggiunto l'implementazione:
_wrap = partial(reduce, lambda inner, outer: partial(outer, inner))
def wrap(fns):
fns = tuple(fns)
if len(fns)==1:
return fns[0]
return lambda *a, **kw: _wrap(iter(fns))(*a, **kw)
e un esempio:
def fn_one(fn, *a, **kw):
print "entered one"
response = fn(*a, **kw)
print "exited one"
return response
def fn_two(fn, *a, **kw):
print "entered two"
response = fn(*a, **kw)
print "exited two"
return response
def zero():
print "zero"
wrapped_zero = wrap((zero, fn_one, fn_two))
wrapped_zero() # returns entered two, entered one, zero, exited one, exited two