J'ai essayé la synthèse de fonctions et le curry avec python

python a partiel

Cependant, il n'y a pas de curry. Je suis triste. J'ai donc écrit une fonction curry qui compte les arguments positionnels par moi-même.

Synthèse fonctionnelle

J'ai d'abord écrit une composition de fonction. C'est simple et minable.

def compose(*funcs: Callable) -> Callable:
    '''
    >>> compose(multest, multest)(4)
    16
    '''
    def composed(*args: Any) -> Any:
        return reduce(lambda x, y: y(x), (funcs[0](*args),)+funcs[1:])
    return composed

Fonctions de curry

Le mécanisme est aussi simple que de vérifier le nombre d'arguments positionnels et de partiellement le partialiser. Alors parfois ça ne marche pas.

def _curry_one(func: Callable) -> Callable:
    def wrap(*args: Any, **kwargs: Any) -> Any:
        return partial(func, *args, **kwargs)
    return wrap


def curry(num_of_args: Optional[int] = None) -> Callable:
    '''
    >>> fnc = curry(2)(multest2)
    >>> fnc(2)(3)
    6
    >>> fnc = curry()(multest3)
    >>> fnc(2)(3)(4)
    24
    '''
    def curry_wrap(func: Callable) -> Callable:
        length_of = compose(filter, list, len)
        if num_of_args:
            num = num_of_args
        else:
            def is_empty(x): return x.default is inspect._empty
            num = length_of(is_empty,
                            inspect.signature(func).parameters.values())
        for n in range(num - 1):
            func = _curry_one(func)
        return func
    return curry_wrap

Lors du curry, comptez le nombre d'arguments et curry autant que le nombre d'arguments de position. Vous pouvez également spécifier le nombre de currys. Cependant, en pratique, il est fixé à 2 et ça fait du bien.

Pourquoi est-ce du curry? Est-ce inutile en partie?

Cela peut être partiel, mais ce curry peut être utilisé comme décorateur.

@curry()
def test(x, y, z):
    return x * y + z

En outre, il est parfois pratique de l'utiliser comme fonction d'ordre supérieur. Surtout lorsqu'il est nécessaire de séparer les cas Quand je dois sortir une starmap. Par exemple, je ne peux pas lire la dernière partie ci-dessous. (Écrire)

def plus(x, y):
    return x * y

result = list(map(partial(plus, 3), range(4)))

Même si ce type est partiellement séparé.

def plus(x, y):
    return x * y

plus3 = partial(plus)
result = list(map(plus3, range(4)))

L'espace de nom est un peu ... Je me sens mal à l'aise avec plus de hoge. Je peux écrire à ce mec comme ça

@curry()
def plus(x, y):
    return x * y

result = compose(map, list)(plus(3), range(4))

Est-ce que ça va?

C'est décidé que c'est inutile, c'est bien que python soit le même, peu importe qui l'écrit. Par conséquent, ce qui précède ne doit pas être utilisé.

Dissolution

Si cela ne fonctionne pas, pourquoi avez-vous fait cela?

Utilisez numpy dans votre projet personnel. Je suis indépendant, mais j'ai été déçu car je ne pouvais pas lire le code parce que j'ai écrit un code comme celui-ci.

np.save(fname, baseline(np.square(fft(data.mean(axis=1)))))

Il s'agit d'un package de calcul scientifique, donc si vous mentionnez la marge de manœuvre dans la situation (existe-t-il?) Il y avait tellement de variables mathématiques que l'espace de noms était fou ... S'il y avait du curry et de la composition de fonction ici, ce serait le cas, non?

mean = curry(np.mean)
save = curry(np.save)
compose(mean(axis=1), fft, np.square, np.std, save(fname))(data)

... n'est-ce pas? Théorie de l'innocence du projet personnel.