Curry n'importe quelle fonction avec Python ...

Curry une fonction arbitraire en Python est assez gênant (Référence: Essayez d'écrire du curry en Python).

Cependant, vous pouvez utiliser des objets appelables pour donner l'impression qu'il est bouclé. Easy Nakoto.

Oh, ne dis pas ça facilement

En ce qui concerne le curry, vous voudrez travailler dur pour pétrir l'expression lambda, mais avec cette méthode, vous pouvez faire la même chose simplement en concevant l'implémentation de la méthode Dunder.

import re

class Curried:
    def __init__(self, f, regex=None, *args, **kwargs):
        self.__f = f
        self.__regex = regex if regex is not None else \
            re.compile('{}\\(\\) missing \\d+ required'.format(f.__name__))
        self.__args = args if args is not None else ()
        self.__kwargs = kwargs if kwargs is not None else {}

    def __call__(self, *arg, **kwarg):
        cls = type(self)
        new_args = self.__args + arg
        new_kwargs = dict(**self.__kwargs, **kwarg)
        try:
            return self.__f(*new_args, **new_kwargs)
        except TypeError as e:
            if self.__regex.match(e.args[0]):
                return cls(self.__f, self.__regex, *new_args, **new_kwargs)
            else:
                raise e

    @property
    def __name__(self):
        return self.__f.__name__

Cette instance Curried prend les arguments un par un et continue de créer des instances Curried jusqu'à ce qu'elle remplisse les arguments de la fonction d'origine. Ce n'est pas seulement une fonction, mais c'est un objet appelable comme une fonction.

Si vous levez la main droite, vous serez responsable de cette main

Utilisez-le de cette façon.

def add(x, y):
    return x + y

def add3(x, y, z):
    return x + y + z

print(Curried(add)(2)(3))
print(Curried(add3)(2)(3)(4))

5
9

À première vue, on dirait que vous appelez une fonction bouclée, non?

Il peut également être utilisé pour les méthodes objet.

class Foo(object):
    def __init__(self, seed=1):
        self.seed = seed

    def add(self, x, y):
        return self.seed * (x + y)

    def multiply(self, x, y):
        return self.seed * x * y

f = Foo(3)
print(Curried(f.add)(2)(3))
print(Curried(f.multiply)(2)(3))

15
18

Vous pouvez également réutiliser des fonctions curry (qui semblent persistantes, mais celle-ci n'est pas vraiment une fonction) que vous ne pouviez pas faire dans l'article de référence.

add2 = Curried(add)(2)
print(add2(3))
print(add2(4))

5
6