Un opérateur de composition de fonction en Python

Vous ne pouvez pas avoir ce que vous voulez. La notation . n'est pas un opérateur binaire , c'est un primary , avec uniquement l'opérande de valeur (le côté gauche du . ), et un identifiant . Les identificateurs sont des chaînes de caractères et non des expressions à part entière produire des références à une valeur.

À partir des Références d'attributs section :

Une référence d'attribut est une primaire suivie d'un point et d'un nom:

>>> getattr(object(), 42)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: getattr(): attribute name must be string

Le primaire doit évaluer un objet d'un type qui prend en charge les références d'attribut, ce que font la plupart des objets. Cet objet est alors invité à produire l'attribut dont le nom est l'identifiant.

Ainsi, lors de la compilation, Python analyse identificateur comme une valeur de chaîne, pas comme une expression (ce que vous obtenez pour les opérandes aux opérateurs). Le hook __getattribute__ (et tout autre hooks d'accès aux attributs ) ne doit traiter que des chaînes. Il n'y a aucun moyen de contourner cela; la fonction d'accès dynamique aux attributs getattr () a > impose strictement que name soit une chaîne:

attributeref ::=  primary "." identifier

Si vous souhaitez utiliser la syntaxe pour composer deux objets, vous êtes limité aux opérateurs binaires, donc les expressions qui prennent deux opérandes, et seulement celles qui ont des hooks (les opérateurs booléens et et ou n'ont pas de hook car ils s'évaluent paresseusement, est et n'est pas n'ont pas de hook car ils agissent sur l'identité d'objet, pas sur les valeurs d'objet).

Je ne suis pas disposé à fournir cette réponse. Mais vous devez savoir que dans certaines circonstances, vous pouvez utiliser une notation point ". " même s'il s'agit d'une notation primaire. Cette solution ne fonctionne que pour les fonctions accessibles depuis globals():

@Composable
def add1(x):
    return x + 1

@Composable
def add2(x):
    return x + 2

print((add1.add2)(5))
# 8

Pour tester:

import functools

class Composable:

    def __init__(self, func):
        self.func = func
        functools.update_wrapper(self, func)

    def __getattr__(self, othername):
        other = globals()[othername]
        return lambda *args, **kw: self.func(other.func(*args, **kw))

    def __call__(self, *args, **kw):
        return self.func(*args, **kw)

p>

Vous pouvez contourner la limitation de la définition des fonctions composables exclusivement dans la portée globale en utilisant le module inspect . Notez que c'est à peu près aussi éloigné de Pythonic que possible, et que l'utilisation de inspect rendra votre code beaucoup plus difficile à tracer et à déboguer. L'idée est d'utiliser inspect.stack () pour obtenir l'espace de noms du contexte appelant, et y rechercher le nom de la variable.

@Composable
def inc(x):
    return x + 1

def repeat(func, count):
    result = func
    for i in range(count-1):
        result = result.func
    return result
    
print(repeat(inc, 6)(5))
# 11

Notez que j'ai changé func à _func pour éviter à moitié les collisions si vous composez avec une fonction réellement nommée func . De plus, j'enveloppe votre lambda dans un Composable (...) , afin qu'il puisse lui-même être composé.

Démonstration qu'il fonctionne en dehors de la portée globale: p >

def main():
    @Composable
    def add1(x):
        return x + 1

    @Composable
    def add2(x):
        return x + 2

    print((add1.add2)(5))

main()
# 8

Cela vous donne l'avantage implicite de pouvoir passer des fonctions comme arguments, sans vous soucier de résoudre le nom de la variable en nom réel de la fonction dans la portée globale. Exemple:

import functools
import inspect

class Composable:

    def __init__(self, func):
        self._func = func
        functools.update_wrapper(self, func)

    def __getattr__(self, othername):
        stack = inspect.stack()[1][0]
        other = stack.f_locals[othername]
        return Composable(lambda *args, **kw: self._func(other._func(*args, **kw)))

    def __call__(self, *args, **kw):
        return self._func(*args, **kw)