#pragma once
#include <memory>



template <typename Fun>
class Function;

template <typename Ret, typename... Args>
class Function<Ret(Args...)>
{
private:
    class callable_base
    {
    public:
        virtual Ret call(Args...) const = 0;
        virtual ~callable_base() = default;
    };

    template <typename Fun>
    class callable : public callable_base
    {
    private:
        Fun _fun;
    public:
        callable(Fun fun):_fun(fun) {}

        virtual Ret call(Args... args) const override
        { return _fun(std::forward<Args>(args)...); }

        virtual ~callable() override {}
    };

    std::unique_ptr<callable_base> _fun;
    bool _is_null = false;

public:
    Function() {}

    template <typename Fun>
    Function& operator=(Fun fun)
    {
        _fun = std::make_unique<callable<Fun>>(fun);
        _is_null = false;
        return *this;
    }

    Function& operator=(std::nullptr_t)
    { _is_null = true; return *this; }

    Ret operator()(Args... args) const
    {
        if (_is_null)
            throw std::bad_function_call();
        return _fun->call(std::forward<Args>(args)...);
    }

    operator bool() const
    { return static_cast<bool>(_fun); }
};