Cara mengkompilasi dekorator - C ++, Python dan implementasinya sendiri. Bagian 1

Rangkaian artikel ini akan dikhususkan untuk kemungkinan membuat dekorator dalam C ++, fitur-fitur pekerjaan mereka dalam Python, dan salah satu opsi untuk mengimplementasikan fungsi ini dalam bahasa yang dikompilasi sendiri akan dipertimbangkan, menggunakan pendekatan umum untuk membuat penutupan - konversi penutupan dan modernisasi pohon sintaksis.

Dekorator dalam C ++

Semuanya berawal dari kenyataan bahwa teman saya VoidDruid memutuskan untuk menulis kompiler kecil sebagai diploma, fitur utama di antaranya adalah dekorator. Bahkan selama pra-pertahanan, ketika dia menguraikan semua keuntungan dari pendekatannya, yang termasuk mengubah AST, saya bertanya-tanya: apakah benar-benar mustahil untuk mengimplementasikan dekorator yang sama ini dalam C ++ yang hebat dan kuat dan melakukannya tanpa syarat dan pendekatan yang rumit? Googling topik ini, saya tidak menemukan pendekatan sederhana dan umum untuk menyelesaikan masalah ini (omong-omong, saya hanya menemukan artikel tentang penerapan pola desain) dan kemudian duduk untuk menulis dekorator saya sendiri.

Namun, sebelum melanjutkan ke deskripsi langsung implementasi saya, saya ingin berbicara sedikit tentang bagaimana lambda dan penutupan di C ++ diatur dan apa perbedaan di antara mereka. Segera buat reservasi bahwa jika tidak disebutkan standar tertentu, maka secara default yang saya maksud adalah C ++ 20. Singkatnya, lambdas adalah fungsi anonim, dan penutupan adalah fungsi yang menggunakan objek dari lingkungannya. Jadi misalnya, dimulai dengan C ++ 11, lambda dapat dideklarasikan dan dipanggil seperti ini:

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

Seperti yang Anda lihat, kami telah menambahkan konstruktor non-standar baru yang mengambil parameter kami dengan referensi dan menyimpannya sebagai anggota kelas. Sebenarnya, inilah mengapa Anda harus sangat berhati-hati ketika mengatur [&] atau [=], karena seluruh konteks akan disimpan dalam penutupan, dan ini bisa sangat suboptimal dari memori. Selain itu, kami kehilangan operator casting ke pointer fungsi, karena sekarang untuk konteks panggilan normal diperlukan. Dan sekarang kode di atas tidak akan dikompilasi:

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. Kode ini hanya dapat dikompilasi dengan versi C ++ 14 dan lebih tinggi, karena tidak mungkin untuk mengetahui jenis yang dikembalikan sebelumnya. Sayangnya, saya harus hidup dengan ini dan saya tidak menemukan opsi lain.
2. make membutuhkan std :: function untuk diteruskan ke sana, dan meneruskan fungsi dengan nama mengarah ke kesalahan kompilasi. Dan ini sama sekali tidak senyaman yang kita inginkan! Kami tidak dapat menulis kode seperti ini:
   
   

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

   
   
3. Juga, tidak mungkin untuk menghias metode kelas.
   

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