toy_variant_match.cpp

#include <variant>
#include <type_traits>
#include <iostream>
#include <string>

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

template<typename T> 
struct wrapper {
    using value_t = T;
    T value;
};

template<typename T, typename F>
struct as_impl {
    using value_t = typename T::value_t;
    as_impl(F && f) : f(std::move(f)) {}
    auto operator()(T arg) { return f(arg.value); }
    F f;
};

template<typename T>
struct as {
    as() = default;
    template<typename F>
    auto operator=(F && f) requires(std::is_invocable_v<F, typename T::value_t>)  {
        return as_impl<T, F>(std::forward<F>(f));
    }
};

//

struct foo : wrapper<std::string> {};
struct bar : wrapper<int> {};
struct baz : wrapper<int> {};

[[gnu::noinline]]
void test(const std::variant<bar, baz, foo> &v) {
    std::visit(overloaded {
        as<bar>() = [](int x) {
            std::cout << "bar " << x << std::endl;
        },
        as<baz>() = [](int x) {
            std::cout << "baz " << x << std::endl;
        },
        as<foo>() = [](auto s) {
            std::cout << "sss " << s << std::endl;
        }
    }, v);
}

int main() {
    test(bar{10});
}