#include <iostream>
#include <stdexcept>
#include <string>
#include <utility>
#include <variant>


namespace ztl{
    template<class ...Ts>
    struct overloaded:Ts...{using Ts::operator()...;};

    template<class ...Ts>
    overloaded(Ts...)->overloaded<Ts...>;

    template<class ...Ts, class ...Fs>
    auto match(std::variant<Ts...>& v, Fs&&... func) {
        return std::visit(ztl::overloaded{std::forward<Fs>(func)...}, v);
    }
    template<class ...Ts, class ...Fs>
    auto match(const std::variant<Ts...>& v, Fs&&... func) {
        return std::visit(ztl::overloaded{std::forward<Fs>(func)...}, v);
    }
    template<class ...Ts, class ...Fs>
    auto match(std::variant<Ts...>&& v, Fs&&... func) {
        return std::visit(ztl::overloaded{std::forward<Fs>(func)...}, std::move(v));
    }
    struct Err:std::string{};

    // template<class T>
    // struct Ok{
    //     T data;
    // };

    template<class T>
    struct Result:std::variant<T,Err>{
        T unwrap(){
            return match<T>(*this,[](const T&t){
                return t;
            },[](const Err &e){
                throw std::runtime_error(e);
                T t;
                return t;
            });
        }
    };

    template<class ...Ts>
    void logger(Ts&&...v){
        #ifndef NDEBUG
        std::cout<<"log[";
        (std::cout<<...<<v);
        std::cout<<"]\n";
        #endif
    }
}