Synthèse de fonctions et application en Python

Recommandation de synthèse de fonctions - Introduction au langage fonctionnel dédié aux programmeurs orientés objet Partie 1

Recommandation d'application de la fonction - Introduction au langage fonctionnel dédié aux programmeurs orientés objet Partie 2

J'ai trouvé un article comme celui ci-dessus, alors j'ai pensé que j'aimerais aussi le faire en Python ^ ~ ~, alors j'ai essayé un peu.

Tout d'abord, à partir de la mise en œuvre de la fonction de synthèse de fonction (g ∘ f) (x) = g (f (x))

def compose(f_t_u, f_u_r):
    '''
    :type f_t_u: t -> u
    :type f_u_r: u -> r
    :rtype: t -> r

    >>> comp(lambda a: a + 'oppai', lambda b: b + 'hoge')('')
    'oppaihoge'
    >>> comp(comp(lambda a: a+'oppai', lambda b: b+ 'hoge'), lambda x: '[' + x + ']')('')
    '[oppaihoge]'
    '''
    return lambda t: f_u_r(f_t_u(t))

J'ai essayé de mettre quelque chose comme un commentaire de type, mais on ne sait pas s'il est plus facile à lire.

Au fait, la composition de la fonction est faite ci-dessus, mais les parenthèses sont pleines. Scala Je ne suis pas sûr, mais l'article original semble utiliser des opérateurs et des conversions de type implicites pour se débarrasser des parenthèses. Scala a peur

Cependant, Python ne peut pas définir l'opérateur oleore en premier lieu. Donc, ici nous allons travailler sur la neutralisation de la fonction. Tout le monde aime __ror__, la surcharge __or__ et réécrire la composition.

class infix(object):
    def __init__(self, function):
        self.function = function

    def __ror__(self, other):
        self.left = other
        return self

    def __or__(self, other):
        return self.function(self.left, other)

    def __call__(self, value1, value2):
        return self.function(value1, value2)

@infix
def c(f_t_u, f_u_r): return lambda t: f_u_r(f_t_u(t))

Eh bien, avec ça

(str.upper |c| sorted |c| set)('abcdeabc')
# > set(['A', 'C', 'B', 'E', 'D'])

Vous pouvez maintenant écrire comme ça.

Enfin, implémentons un conteneur appelé Ap qui apparaît dans la partie 2 de l'article d'origine. Utilisez l'opérateur de décalage de bits droit pour prendre la fonction et l'utiliser comme il convient.

class Ap(object):
    def __init__(self, val):
        self.val=val
    def __rshift__(self, func):
        return func(self.val)

En utilisant ce gars

Ap('abcdeabc') >> (str.upper |c| sorted |c| set)
# > set(['A', 'C', 'B', 'E', 'D'])

Je peux maintenant écrire. Je l'ai fait.

Il reste encore des crochets, mais vous pouvez terminer. J'aime ça parce que c'est intéressant, mais je ne pense pas que ce soit pratique parce que je ne pense pas que ça ressemble à Python.

# Addendum

Implémentation de la classe Ap

class _Ap(object):
    def __rlshift__(self, other):
        self.value = other
        return self

    def __rshift__(self, other):
        return other(self.value)
Ap = _Ap()
a = Ap

Si tu fais

'abcdacb' <<a>> (str.upper |c| sorted)
#> ['A', 'A', 'B', 'B', 'C', 'C', 'D']

C'est comme ça. Il s'agit d'un visuel plus proche de l'article original, et cela donne un sentiment plus appliqué (?)

Post-scriptum:

Bien qu'il soit moins polyvalent, j'ai également écrit quelque chose qui a une atmosphère de Haskell qui permet la composition de fonctions avec .

[Opérateur de composition de Haskell. En Python ~ Implémentation du traitement de collection par composition de fonction](https://hachibeechan.hateblo.jp/entry/implements-the-haskells-compose-function-in-python-and-list- En traitement)