#include <iostream>
#include <type_traits>
#include <vector>
#include <tuple>

template<class... Types>
class Monad
{
    public:
        Monad(std::tuple<Types...> t) : params(t){}
        template<class F, class... Us>
        auto operator>=(F func)
        {
            auto t = std::tuple_cat(params, std::make_tuple(func));
            return make_monad(t);
        }
       auto run()
       {
           return call_func(std::index_sequence_for<Types...>{});
       }
    private:
        std::tuple<Types...> params;
   
        template<std::size_t... I>
        auto call_func(std::index_sequence<I...>)
        {
           return run_impl(std::get<I>(params)...);
        }
        template<class X>
        X run_impl(X x)
        {
            std::cout << x << std::endl;
           return x;
        }
        template<class X, class F, class... Args>
        auto run_impl(X x, F f, Args... args)
        {  
            std::cout << x << " >= ";
            return run_impl(f(x), args...);
        }
};

template<class... Args>
Monad<Args...> make_monad(std::tuple<Args...> t)
{
    return Monad<Args...>(t);
}

struct F1
{
double operator()(int a)
{
    return a+0.1;
}
};



struct Mult2
{
    std::size_t operator()(double d)
    {
        return d*2;
    }
};


int main()
{
	Monad<int> m(5);
    auto i = m >= F1() >= Mult2() >= [](std::size_t x){return x+20;};

    std::cout << i.run()  << std::endl;
}