nome per una funzione che trasforma istruzioni di assegnazione alle espressioni

Question

Aggiorna

Da uno effetto di queste funzioni è di fornire un modo per utilizzare metodo concatenamento su metodi che normalmente non supportano * , sto pensando di chiamarli chain e copychain, rispettivamente. Questo sembra tutt'altro che ideale, però, dal momento che l'aspirante copychain è senza dubbio un concetto più fondamentale, almeno in termini di programmazione funzionale.

---

originale

sto chiamando un boxer per ora. Il codice è in Python, anche se la questione è generale:

def boxer(f):
    """Return a function g(o, *args, **keyargs) -> o

    `g` calls `f` on `o` with the remaining arguments
        and returns `o`.

    >>> l = [2]
    >>> def increment_list_element(l, i):
    ...     l[0] += i
    >>> adder = boxer(increment_list_element)
    >>> adder(l, 2)
    [4]
    >>> def multiply_list_element(l, i):
    ...     l[0] *= i
    >>> multiplier = boxer(multiply_list_element)
    >>> sum(multiplier(l, 6))
    24
    """
    def box(o, *args, **keyargs):
        f(o, *args, **keyargs)
        return o
    return box

Un concetto simile copia il aspiranti assegnatari, e cessionari per e restituisce la copia. Questo è un "shadow_boxer":

from copy import deepcopy

def shadow_boxer(f):
    """Return a function g(o, *args, **keyargs) -> p

    `g` deepcopies `o` as `p`,
        executes `f` on `p` with the remaining arguments,
        and returns `p`.

    >>> l = [2]
    >>> def increment_list_element(l, i):
    ...     l[0] += i
    >>> adder = shadow_boxer(increment_list_element)
    >>> adder(l, 2)
    [4]
    >>> def multiply_list_element(l, i):
    ...     l[0] *= i
    >>> multiplier = shadow_boxer(multiply_list_element)
    >>> sum(multiplier(l, 6))
    12
    """
    def shadow_box(o, *args, **keyargs):
        p = deepcopy(o)
        f(p, *args, **keyargs)
        return p
    return shadow_box

Inoltre, mi piacerebbe scoprire le risorse per saperne di più su questo genere di cose - anche se sono allo stesso modo incerto di un nome per "questo genere di cose". Sembra relative a programmazione funzionale, anche se a quanto ho capito, queste tecniche non sarebbe necessario in un vero e proprio linguaggio funzionale.

Answer 1

Questo è più o meno la stessa cosa di Ruby Object#tap . Non so come ti senti per il nome, ma questo è ciò che lo chiamano.

Answer 2

Quello che la funzione ritorna boxer è probabilmente definiti chiusura in alcuni linguaggi di programmazione. Se non c'è già una funzione con questo nome, mi chiamerebbe la funzione di closure.