How to compile a decorator - C ++, Python and its own implementation. Part 1

This series of articles will be devoted to the possibility of creating a decorator in C ++, the features of their work in Python, and we will also consider one of the options for implementing this functionality in our own compiled language, using the general approach for creating closures - closure conversion and modernization of the syntax tree.

Decorator in C ++

It all started with the fact that my friend VoidDruid decided to write a small compiler as a diploma, the key feature of which is decorators. Even during the pre-defense, when he outlined all the advantages of his approach, which included changing the AST, I was wondering: is it really impossible to implement these same decorators in the great and powerful C ++ and do without any complicated terms and approaches? Googling this topic, I did not find any simple and general approaches to solving this problem (by the way, I came across only articles about the implementation of the design pattern) and then sat down to write my own decorator.

However, before moving on to a direct description of my implementation, I would like to talk a little about how lambdas and closures in C ++ are arranged and what is the difference between them. Immediately make a reservation that if there is no mention of a specific standard, then by default I mean C ++ 20. In short, lambdas are anonymous functions, and closures are functions that use objects from their environment. So for example, starting with C ++ 11, a lambda can be declared and called like this:

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}
    {}
};

As you can see, we have added a new, non-default constructor that takes our parameter by reference and saves it as a member of the class. Actually, this is why you need to be extremely careful when setting [&] or [=], because the whole context will be stored within the closure, and this can be quite suboptimal from memory. In addition, we lost the operator of casting to a function pointer, because now for its normal call context is needed. And now the above code will not compile:

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. This code can only be compiled with version C ++ 14 and higher, since it is not possible to know the type returned in advance. Unfortunately, I have to live with this and I did not find other options.
2. make requires std :: function to be passed to it, and passing a function by name leads to compilation errors. And this is not at all as convenient as we would like! We cannot write code like this:
   
   

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

   
   
3. Also, it is not possible to decorate a class method.
   

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