nom d'une fonction qui transforme les instructions d'affectation aux expressions

Question

Mise à jour

Comme un effet de ces fonctions est de fournir un moyen d'utiliser enchaînant sur les méthodes qui ne supporterait pas normalement * , j'envisage de les appeler chain et copychain, respectivement. Cela semble moins qu'idéal cependant, puisque le copychain est sans doute serait-être un concept plus fondamental, au moins en termes de programmation fonctionnelle.

---

originale

J'appelle un boxer pour l'instant. Le code est en Python, bien que la question est générale:

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

Une copie de concept similaire le cessionnaire serait-être, et cède à la copie et le rendement. Celui-ci est 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

En outre, je voudrais savoir sur les ressources pour en apprendre davantage sur ce genre de choses - bien que je ne suis pas sûr de la même d'un nom pour « ce genre de choses ». Il ne semble lié à la programmation fonctionnelle, bien que je sache, ces techniques serait inutile dans un véritable langage fonctionnel.

Answer 1

est à peu près la même chose que Ruby Object#tap . Je ne sais pas comment vous vous sentez le nom, mais c'est ce qu'ils appellent.

Answer 2

Qu'est-ce que le rendement de la fonction boxer est probablement la fermeture définis dans certains langages de programmation. S'il n'y a pas déjà une fonction de ce nom, j'appelle la fonction closure.