Cómo compilar un decorador: C ++, Python y su propia implementación. Parte 1

Esta serie de artículos estará dedicada a la posibilidad de crear un decorador en C ++, las características de su trabajo en Python, y también consideraremos una de las opciones para implementar esta funcionalidad en nuestro propio lenguaje compilado, utilizando el enfoque general para crear cierres: conversión de cierre y modernización del árbol de sintaxis.

Decorador en C ++

Todo comenzó con el hecho de que mi amigo VoidDruid decidió escribir un pequeño compilador como diploma, cuya característica clave son los decoradores. Incluso durante la defensa previa, cuando describió todas las ventajas de su enfoque, que incluía cambiar el AST, me preguntaba: ¿es realmente imposible implementar estos mismos decoradores en el gran y poderoso C ++ y prescindir de términos y enfoques complicados? Buscando en Google este tema, no encontré ningún enfoque simple y general para resolver este problema (por cierto, solo encontré artículos sobre la implementación del patrón de diseño) y luego me senté a escribir mi propio decorador.

Sin embargo, antes de pasar a una descripción directa de mi implementación, me gustaría hablar un poco sobre cómo se organizan las lambdas y los cierres en C ++ y cuál es la diferencia entre ellos. Inmediatamente haga una reserva de que si no se menciona un estándar específico, por defecto me refiero a C ++ 20. En resumen, las lambdas son funciones anónimas y los cierres son funciones que utilizan objetos de su entorno. Entonces, por ejemplo, comenzando con C ++ 11, una lambda se puede declarar y llamar así:

int main() 
{
    [] (int a) 
    {
        std::cout << a << std::endl;
    }(10);
}

int main() 
{
    auto lambda = [] (int a) 
    {
        std::cout << a << std::endl;
    };
    lambda(10);
}

class __lambda_60_19
{
public: 
    inline void operator()(int a) const
    {
        std::cout.operator<<(a).operator<<(std::endl);
    }
    
    using retType_60_19 = void (*)(int);
    inline operator retType_60_19 () const noexcept
    {
        return __invoke;
    };
    
private: 
    static inline void __invoke(int a)
    {
        std::cout.operator<<(a).operator<<(std::endl);
    }    
};

void (*p_lambda) (int) = lambda;
p_lambda(10);

int main()
{
    int a = 10;
    auto closure = [&a] () { a += 1; };
    closure();
}

class __lambda_61_20
{
public:
    inline void operator()()
    {
        a += 1;
    }
private:
    int & a;
public:
    __lambda_61_20(int & _a)
    : a{_a}
    {}
};

Como puede ver, hemos agregado un nuevo constructor no predeterminado que toma nuestro parámetro como referencia y lo guarda como miembro de la clase. En realidad, es por eso que debe ser extremadamente cuidadoso al configurar [&] o [=], porque todo el contexto se almacenará dentro del cierre, y esto puede ser bastante subóptimo de la memoria. Además, perdimos el operador de conversión a un puntero de función, porque ahora se necesita su contexto de llamada normal. Y ahora el código anterior no se compilará:

int main()
{
    int a = 10;
    auto closure = [&a] () { a += 1; };
    closure();
    void (*ptr)(int) = closure;
}

std::function<void()> function = closure;
function();

namespace Decorator
{
    template<typename R, typename ...Args>
    static auto make(const std::function<R(Args...)>& f)
    {
        std::cout << "Do something" << std::endl;
        return [=](Args... args) 
        {
            return f(std::forward<Args>(args)...);
        };
    }
};

void myFunc(int a)
{
    std::cout << "here" << std::endl;
}

int main()
{
    std::function<void(int)> f = myFunc;
    auto decorated = Decorator::make(f);
    decorated(10);
}

1. Este código solo se puede compilar con la versión C ++ 14 y superior, ya que no es posible conocer el tipo devuelto de antemano. Desafortunadamente, tengo que vivir con esto y no encontré otras opciones.
2. make requiere que se le pase std :: function, y pasar una función por su nombre conduce a errores de compilación. ¡Y esto no es tan conveniente como nos gustaría! No podemos escribir código como este:
   
   

   Decorator::make([](){});
   Decorator::make(myFunc);
   void(*ptr)(int) = myFunc;
   Decorator::make(ptr);

   
   
3. Además, no es posible decorar un método de clase.
   

namespace Decorator
{
    template<typename Function>
    static auto make(Function&& func)
    {
        return [func = std::forward<Function>(func)] (auto && ...args) 
        {
            std::cout << "Do something" << std::endl;
            return std::invoke(
                func,
                std::forward<decltype(args)>(args)...
            );
        };
    }
};

int main()
{
    auto decorated_1 = Decorator::make(myFunc);
    decorated_1(1,2);

    auto my_lambda = [] (int a, int b) 
    { 
        std::cout << a << " " << b <<std::endl; 
    };
    auto decorated_2 = Decorator::make(my_lambda);
    decorated_2(3,4);

    int (*ptr)(int, int) = myFunc;
    auto decorated_3 = Decorator::make(ptr);
    decorated_3(5,6);

    std::function<void(int, int)> fun = myFunc;
    auto decorated_4 = Decorator::make(fun);
    decorated_4(7,8);

    auto decorated_5 = Decorator::make(decorated_4);
    decorated_5(9, 10);

    auto decorated_6 = Decorator::make(&MyClass::func);
    decorated_6(MyClass(10));
}

namespace Decorator
{
    template<typename Function>
    static auto make(Function&& func)
    {
        return [func = std::forward<Function>(func)] 
        <typename ...Args> (Args && ...args) 
        {
            return std::invoke(
                func,
                std::forward<Args>(args)...
            );
        };
    }
};