Como compilar um decorador - C ++, Python e sua própria implementação. Parte 1

Esta série de artigos será dedicada à possibilidade de criar um decorador em C ++, os recursos de seu trabalho em Python, e também consideraremos uma das opções para implementar essa funcionalidade em nossa própria linguagem compilada, usando a abordagem geral para criar closures - conversão de fechamento e modernização da árvore de sintaxe.

Decorador em C ++

Tudo começou com o fato de meu amigo VoidDruid ter decidido escrever um pequeno compilador como diploma, cuja principal característica são os decoradores. Mesmo durante a pré-defesa, quando ele destacou todas as vantagens de sua abordagem, que incluíam a alteração do AST, eu me perguntava: é realmente impossível implementar esses mesmos decoradores no grande e poderoso C ++ e fazer sem termos e abordagens complicados? Pesquisando neste tópico, não encontrei nenhuma abordagem simples e geral para resolver esse problema (a propósito, encontrei apenas artigos sobre a implementação do padrão de design) e depois me sentei para escrever meu próprio decorador.

No entanto, antes de passar para uma descrição direta da minha implementação, gostaria de falar um pouco sobre como as lambdas e os fechamentos em C ++ são organizados e qual é a diferença entre eles. Faça imediatamente uma reserva de que, se não houver menção a um padrão específico, por padrão, quero dizer C ++ 20. Em resumo, lambdas são funções anônimas e encerramentos são funções que usam objetos de seu ambiente. Por exemplo, começando com C ++ 11, um lambda pode ser declarado e chamado assim:

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 você pode ver, adicionamos um novo construtor não padrão que pega nosso parâmetro por referência e o salva como membro da classe. Na verdade, é por isso que você precisa ser extremamente cuidadoso ao definir [&] ou [=], porque todo o contexto será armazenado dentro do fechamento e isso pode ser bastante subótimo da memória. Além disso, perdemos o operador de conversão para um ponteiro de função, porque agora é necessário o seu contexto de chamada normal. E agora o código acima não será compilado:

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. Esse código só pode ser compilado com a versão C ++ 14 e superior, pois não é possível conhecer o tipo retornado antecipadamente. Infelizmente, tenho que conviver com isso e não encontrei outras opções.
2. make exige que std :: function seja passado para ele, e a passagem de uma função pelo nome leva a erros de compilação. E isso não é tão conveniente quanto gostaríamos! Não podemos escrever código como este:
   
   

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

   
   
3. Além disso, não é possível decorar um método de classe.
   

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)...
            );
        };
    }
};