Compiler Explorer

Source code

#include <variant>

// v collapse this namespace if you know what's good for you
namespace horrifying_guts {

// Strip const, volatile, or reference qualifiers from a type.
  // const int& -> int
  // volatile int&& -> int
  template <typename T>
  struct decay {
    using type = T;
  };
  template <typename T>
  struct decay<T&> {
    using type = typename decay<T>::type;
  };
  template <typename T>
  struct decay<T&&> {
    using type = typename decay<T>::type;
  };
  template <typename T>
  struct decay<const T> {
    using type = typename decay<T>::type;
  };
  template <typename T>
  struct decay<volatile T> {
    using type = typename decay<T>::type;
  };
  template <typename T>
  using decay_t = typename decay<T>::type;

// Provides a value of type T for use in unevaluated contexts.
  // There's no actual definition so this can never be called at
  // runtime, but it can be used in decltype(...) or other
  // unevaluated contexts wherever we need an expression of type T.
  template <typename T> T declval();

// Represent a list of types for compile-time shenanigans.
  template <typename... Ts> struct type_list {};

// Prepend a value to a type list.
  template <typename T, typename List> struct prepend;
  template <typename T, typename... Values>
  struct prepend<T, type_list<Values...>> {
    using type = type_list<T, Values...>;
  };
  template <typename T, typename List>
  using prepend_t = typename prepend<T, List>::type;

// Prepend a value to each nested list in a type list.
  template <typename T, typename List> struct prepend_all;
  template <typename T, typename... Lists>
  struct prepend_all<T, type_list<Lists...>> {
    using type = type_list<prepend_t<T, Lists>...>;
  };
  template <typename T, typename List>
  using prepend_all_t = typename prepend_all<T, List>::type;

// Concatenate two type_lists.
  template <typename A, typename B> struct concat;
  template <typename... As, typename... Bs>
  struct concat<type_list<As...>, type_list<Bs...>> {
    using type = type_list<As..., Bs...>;
  };
  template <typename A, typename B>
  using concat_t = typename concat<A, B>::type;

// Flatten one layer of nested type_lists
  // type_list<type_list<int>, type_list<char>> -> type_list<int, char>
  template <typename... Lists> struct flatten;
  template <>
  struct flatten<> {
    using type = type_list<>;
  };
  template <typename List, typename... Lists>
  struct flatten<List, Lists...> {
    using type = concat_t<List, typename flatten<Lists...>::type>;
  };
  template <typename... Lists>
  using flatten_t = typename flatten<Lists...>::type;

// The meaty bit: given n variants, produce a type_list of
  // type_lists representing all valid combinations of parameters
  // for a visitor.
  //
  // parameter_combinations_t<
  //     std::variant<int, char>&,
  //     const std::variant<float, double>&>
  // ->
  // type_list<
  //   type_list<int&, const float&>,
  //   type_list<int&, const double&>,
  //   type_list<char&, const float&>,
  //   type_list<char&, const double&>
  // >
  template <typename... Variants> struct parameter_combinations;

template <>
  struct parameter_combinations<> {
    using type = type_list<type_list<>>;
  };

template <typename... Ts, typename... Variants>
  struct parameter_combinations<std::variant<Ts...>&, Variants...> {
    using inner_combinations = typename parameter_combinations<Variants...>::type;
    using type = flatten_t<prepend_all_t<Ts&, inner_combinations>...>;
  };
  template <typename... Ts, typename... Variants>
  struct parameter_combinations<const std::variant<Ts...>&, Variants...> {
    using inner_combinations = typename parameter_combinations<Variants...>::type;
    using type = flatten_t<prepend_all_t<const Ts&, inner_combinations>...>;
  };
  template <typename... Variants>
  using parameter_combinations_t =
      typename parameter_combinations<Variants...>::type;

// Check if two types are the same as each other.
  template <typename A, typename B> struct same {
    static constexpr bool value = false;
  };
  template <typename T>
  struct same<T, T> {
    static constexpr bool value = true;
  };
  template <typename A, typename B>
  constexpr bool same_v = same<A, B>::value;

// Check if n types are all the same.
  template <typename... Ts> struct all_same;
  template <>
  struct all_same<> {
    static constexpr bool value = true;
  };
  template <typename T>
  struct all_same<T> {
    static constexpr bool value = true;
  };
  template <typename T1, typename... Ts>
  struct all_same<T1, Ts...> {
    static constexpr bool value = (same_v<T1, Ts> && ...);
  };
  template <typename... Ts>
  constexpr bool all_same_v = all_same<Ts...>::value;

// A concept which is satisfied if we can invoke a functor of type
  // F with arguments of types Args...
  template <typename F, typename... Args>
  concept invocable = requires (F f, Args... args) {
    { f(args...) };
  };

// Like invocable, but takes a type_list of args instead.
  template <typename F, typename List> struct invocable_with;
  template <typename F, typename... Args>
  struct invocable_with<F, type_list<Args...>> {
    static constexpr bool value = invocable<F, Args...>;
  };
  template <typename F, typename List>
  constexpr bool invocable_with_v = invocable_with<F, List>::value;

// Checks that a functor of type F can be invoked with *all*
  // combinations of arguments expressed by the type lists.
  template <typename F, typename... TypeLists>
  concept multi_invocable_with = (invocable_with_v<F, TypeLists> && ...);

// Get the return type for an invocation of F with the given arguments.
  template <typename F, typename List> struct invoke_with_result;
  template <typename F, typename... Args>
  struct invoke_with_result<F, type_list<Args...>> {
    using type = decltype(declval<F>()(declval<Args>()...));
  };
  template <typename F, typename List>
  using invoke_with_result_t = typename invoke_with_result<F, List>::type;

// Implementation for the visitor concept. This concept checks that a
  // functor can accept all of the argument combinations provided *and*
  // that every invocation produces the same type.
  template <typename F, typename... TypeLists>
  concept visitor_impl =
      multi_invocable_with<F, TypeLists...> &&
      all_same_v<invoke_with_result_t<F, TypeLists>...>;

// Like visitor_impl but takes a type_list.
  template <typename F, typename TypeListList> struct visitor_impl_unwrap;
  template <typename F, typename... TypeLists>
  struct visitor_impl_unwrap<F, type_list<TypeLists...>> {
    static constexpr bool value = visitor_impl<F, TypeLists...>;
  };

// Returns true if the argument is std::variant<...>
  template <typename Variant>
  struct is_variant {
    static constexpr bool value = false;
  };
  template <typename... Ts>
  struct is_variant<std::variant<Ts...>> {
    static constexpr bool value = true;
  };
  template <typename Variant>
  concept variant_type = is_variant<decay_t<Variant>>::value;

// Concept for visitors of a given collection of variants.
  template <typename F, typename... Variants>
  concept visitor =
      (variant_type<Variants> && ...) &&
      visitor_impl_unwrap<F, parameter_combinations_t<Variants...>>::value;

}  // namespace horrifying_guts
// ^ collapse this namespace if you know what's good for you

using horrifying_guts::variant_type;
using horrifying_guts::visitor;

// A visitor takes an arbitrary number of variants and, as its first
// argument, a visitor that can accept all combinations of values from
// those variants. std::visit doesn't check these nicely, but this
// concept checks it!
template <variant_type... Variants>
auto my_visit(visitor<Variants...> auto v, Variants&&... variants) {
  return std::visit(v, std::forward<Variants>(variants)...);
}

void demo() {
  std::variant<int, char> v;
  my_visit([](auto& x) { return x; }, v);
}