#include <functional>
#include <iostream>
#include <tuple>

template<typename F, typename... Args> class fiber
{
public:
    using R = typename std::invoke_result_t<F, Args...>;

    explicit fiber(F &&f, Args &&...args)
        : f(std::forward<F>(f)), args(std::forward<Args>(args)...)
    {
    }

    template<typename F2, typename... Args2>
    explicit fiber(const F2 &f, Args2 &&...args2)
        : f(f), args(std::forward<Args2>(args2)...)
    {
    }

    R run() { return std::apply(f, args); }

private:
    F f;
    std::tuple<Args...> args;
};

template<typename F, typename... Args> fiber(F, Args...) -> fiber<F, Args...>;

void funcion() { std::cout << "1\n"; }

struct objeto
{
    int a = 0;
    void operator()() { std::cout << "2\n"; }
    int metodo(int b)
    {
        std::cout << a + b << '\n';
        return a + b;
    }
};

auto lambda = [] { std::cout << "3\n"; };

int main()
{
    fiber f1(funcion);
    fiber f2(objeto{});
    fiber f3(lambda);
    fiber f4([] { std::cout << "4\n"; });
    fiber f5(&objeto::metodo, objeto{2}, 3);

    f1.run();
    f2.run();
    f3.run();
    f4.run();
    return f5.run();
}