type_traits.h

#pragma once

#include <charconv>
#include <cstddef>
#include <iterator>
#include <type_traits>
#include <utility>

namespace mpl {
template <std::size_t N>
struct choice_t
    // Unfortunately, doxygen cannot parse such a construct.
    :  choice_t<N - 1> 
{};

template <> struct choice_t<0> {};

template <std::size_t N> inline constexpr choice_t<N> choice{};

template <typename Type> struct type_identity {
  using type = Type;
};

template <typename Type>
using type_identity_t = typename type_identity<Type>::type;


template <class T>
struct const_reference
{
   using type = const std::remove_reference_t<T>&;
};

template <class T>
using const_reference_t =  typename const_reference<T>::type;

template <class T>
struct add_const_to_value
{
   using type =  std::conditional_t<std::is_lvalue_reference_v<T>, const_reference_t<T>, const T>;
};

template <class T>
using add_const_to_value_t =  typename add_const_to_value<T>::type;


template <typename Type, typename = void>
struct size_of : std::integral_constant<std::size_t, 0u> {};

template <typename Type>
struct size_of<Type, std::void_t<decltype(sizeof(Type))>>
    : std::integral_constant<std::size_t, sizeof(Type)> {};

template <typename Type>
inline constexpr std::size_t size_of_v = size_of<Type>::value;

template <typename Type, typename> using unpack_as_type = Type;

template <auto Value, typename> inline constexpr auto unpack_as_value = Value;

template <auto Value>
using integral_constant = std::integral_constant<decltype(Value), Value>;

// template<id_type Value>
// using tag = integral_constant<Value>;

template <typename... Type> struct type_list {
  using type = type_list;
  static constexpr auto size = sizeof...(Type);
};

template <std::size_t, typename> struct type_list_element;

template <std::size_t Index, typename First, typename... Other>
struct type_list_element<Index, type_list<First, Other...>>
    : type_list_element<Index - 1u, type_list<Other...>> {};

template <typename First, typename... Other>
struct type_list_element<0u, type_list<First, Other...>> {
  using type = First;
};

template <std::size_t Index, typename List>
using type_list_element_t = typename type_list_element<Index, List>::type;

template <typename, typename> struct type_list_index;

template <typename Type, typename First, typename... Other>
struct type_list_index<Type, type_list<First, Other...>> {
  using value_type = std::size_t;
  static constexpr value_type value =
      1u + type_list_index<Type, type_list<Other...>>::value;
};

template <typename Type, typename... Other>
struct type_list_index<Type, type_list<Type, Other...>> {
  static_assert(type_list_index<Type, type_list<Other...>>::value ==
                    sizeof...(Other),
                "Non-unique type");
  using value_type = std::size_t;
  static constexpr value_type value = 0u;
};

template <typename Type> struct type_list_index<Type, type_list<>> {
  using value_type = std::size_t;
  static constexpr value_type value = 0u;
};

template <typename Type, typename List>
inline constexpr std::size_t type_list_index_v =
    type_list_index<Type, List>::value;

template <typename... Type, typename... Other>
constexpr type_list<Type..., Other...> operator+(type_list<Type...>,
                                                 type_list<Other...>) {
  return {};
}

template <typename...> struct type_list_cat;

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

template <typename... Type, typename... Other, typename... List>
struct type_list_cat<type_list<Type...>, type_list<Other...>, List...> {
  using type =
      typename type_list_cat<type_list<Type..., Other...>, List...>::type;
};

template <typename... Type> struct type_list_cat<type_list<Type...>> {
  using type = type_list<Type...>;
};

template <typename... List>
using type_list_cat_t = typename type_list_cat<List...>::type;

template <typename> struct type_list_unique;

template <typename Type, typename... Other>
struct type_list_unique<type_list<Type, Other...>> {
  using type = std::conditional_t<
      (std::is_same_v<Type, Other> || ...),
      typename type_list_unique<type_list<Other...>>::type,
      type_list_cat_t<type_list<Type>,
                      typename type_list_unique<type_list<Other...>>::type>>;
};

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

template <typename Type>
using type_list_unique_t = typename type_list_unique<Type>::type;

template <typename List, typename Type> struct type_list_contains;

template <typename... Type, typename Other>
struct type_list_contains<type_list<Type...>, Other>
    : std::disjunction<std::is_same<Type, Other>...> {};

template <typename List, typename Type>
inline constexpr bool type_list_contains_v =
    type_list_contains<List, Type>::value;

template <typename...> struct type_list_diff;

template <typename... Type, typename... Other>
struct type_list_diff<type_list<Type...>, type_list<Other...>> {
  using type = type_list_cat_t<
      std::conditional_t<type_list_contains_v<type_list<Other...>, Type>,
                         type_list<>, type_list<Type>>...>;
};

template <typename... List>
using type_list_diff_t = typename type_list_diff<List...>::type;

template <typename, template <typename...> class> struct type_list_transform;

template <typename... Type, template <typename...> class Op>
struct type_list_transform<type_list<Type...>, Op> {
  using type = type_list<typename Op<Type>::type...>;
};

template <typename List, template <typename...> class Op>
using type_list_transform_t = typename type_list_transform<List, Op>::type;

template <typename, template <typename...> typename> struct type_list_rename;
template <typename... T, template <typename...> typename F>
struct type_list_rename<type_list<T...>, F> {
  using result = F<T...>;
};

template <typename, typename> struct type_list_push_front;
template <typename... E, typename T>
struct type_list_push_front<type_list<E...>, T> {
  using result = type_list<T, E...>;
};

template <class List> struct type_list_first {};
template <class First, class... Tail>
struct type_list_first<type_list<First, Tail...>> {
  using type = First;
};

template <auto... Value> struct value_list {
  using type = value_list;
  static constexpr auto size = sizeof...(Value);
};

template <std::size_t, typename> struct value_list_element;

template <std::size_t Index, auto Value, auto... Other>
struct value_list_element<Index, value_list<Value, Other...>>
    : value_list_element<Index - 1u, value_list<Other...>> {};

template <auto Value, auto... Other>
struct value_list_element<0u, value_list<Value, Other...>> {
  static constexpr auto value = Value;
};

template <std::size_t Index, typename List>
inline constexpr auto value_list_element_v =
    value_list_element<Index, List>::value;

template <auto... Value, auto... Other>
constexpr value_list<Value..., Other...> operator+(value_list<Value...>,
                                                   value_list<Other...>) {
  return {};
}

template <typename...> struct value_list_cat;

template <> struct value_list_cat<> {
  using type = value_list<>;
};

template <auto... Value, auto... Other, typename... List>
struct value_list_cat<value_list<Value...>, value_list<Other...>, List...> {
  using type =
      typename value_list_cat<value_list<Value..., Other...>, List...>::type;
};

template <auto... Value> struct value_list_cat<value_list<Value...>> {
  using type = value_list<Value...>;
};

template <typename... List>
using value_list_cat_t = typename value_list_cat<List...>::type;


template <typename List, size_t ... indexes>
struct value_list_expand
{
    using type = std::tuple<typename value_list_element<indexes, List>::type...>;
};

template <typename List, size_t ... indexes>
using value_list_expand_t = typename value_list_expand<List, indexes...>::type;






template <typename, typename> struct is_applicable : std::false_type {};

template <typename Func, template <typename...> class Tuple, typename... Args>
struct is_applicable<Func, Tuple<Args...>> : std::is_invocable<Func, Args...> {
};

template <typename Func, template <typename...> class Tuple, typename... Args>
struct is_applicable<Func, const Tuple<Args...>>
    : std::is_invocable<Func, Args...> {};

template <typename Func, typename Args>
inline constexpr bool is_applicable_v = is_applicable<Func, Args>::value;

template <typename, typename, typename>
struct is_applicable_r : std::false_type {};

template <typename Ret, typename Func, typename... Args>
struct is_applicable_r<Ret, Func, std::tuple<Args...>>
    : std::is_invocable_r<Ret, Func, Args...> {};

template <typename Ret, typename Func, typename Args>
inline constexpr bool is_applicable_r_v =
    is_applicable_r<Ret, Func, Args>::value;

template <typename Type, typename = void>
struct is_complete : std::false_type {};

template <typename Type>
struct is_complete<Type, std::void_t<decltype(sizeof(Type))>> : std::true_type {
};

template <typename Type>
inline constexpr bool is_complete_v = is_complete<Type>::value;

template <typename Type, typename = void>
struct is_iterator : std::false_type {};

namespace details {

template <typename, typename = void>
struct has_iterator_category : std::false_type {};

template <typename Type>
struct has_iterator_category<
    Type, std::void_t<typename std::iterator_traits<Type>::iterator_category>>
    : std::true_type {};

} // namespace details

template <typename Type>
struct is_iterator<Type,
                   std::enable_if_t<!std::is_same_v<
                       std::remove_const_t<std::remove_pointer_t<Type>>, void>>>
    : details::has_iterator_category<Type> {};

template <typename Type>
inline constexpr bool is_iterator_v = is_iterator<Type>::value;

template <typename Type>
struct is_ebco_eligible : std::conjunction<std::is_empty<Type>,
                                           std::negation<std::is_final<Type>>> {
};

template <typename Type>
inline constexpr bool is_ebco_eligible_v = is_ebco_eligible<Type>::value;

template <typename Type, typename = void>
struct is_transparent : std::false_type {};

template <typename Type>
struct is_transparent<Type, std::void_t<typename Type::is_transparent>>
    : std::true_type {};

template <typename Type>
inline constexpr bool is_transparent_v = is_transparent<Type>::value;

template <typename Type, typename = void>
struct is_equality_comparable : std::false_type {};

namespace details {

template <typename, typename = void>
struct has_tuple_size_value : std::false_type {};

template <typename Type>
struct has_tuple_size_value<
    Type, std::void_t<decltype(std::tuple_size<const Type>::value)>>
    : std::true_type {};

template <typename Type, std::size_t... Index>
[[nodiscard]] constexpr bool
unpack_maybe_equality_comparable(std::index_sequence<Index...>) {
  return (is_equality_comparable<std::tuple_element_t<Index, Type>>::value &&
          ...);
}

template <typename>
[[nodiscard]] constexpr bool maybe_equality_comparable(choice_t<0>) {
  return true;
}

template <typename Type>
[[nodiscard]] constexpr auto maybe_equality_comparable(choice_t<1>)
    -> decltype(std::declval<typename Type::value_type>(), bool{}) {
  if constexpr (is_iterator_v<Type>) {
    return true;
  } else if constexpr (std::is_same_v<typename Type::value_type, Type>) {
    return maybe_equality_comparable<Type>(choice<0>);
  } else {
    return is_equality_comparable<typename Type::value_type>::value;
  }
}

template <typename Type>
[[nodiscard]] constexpr std::enable_if_t<
    is_complete_v<std::tuple_size<std::remove_const_t<Type>>>, bool>
maybe_equality_comparable(choice_t<2>) {
  if constexpr (has_tuple_size_value<Type>::value) {
    return unpack_maybe_equality_comparable<Type>(
        std::make_index_sequence<std::tuple_size<Type>::value>{});
  } else {
    return maybe_equality_comparable<Type>(choice<1>);
  }
}

} // namespace details

template <typename Type>
struct is_equality_comparable<
    Type, std::void_t<decltype(std::declval<Type>() == std::declval<Type>())>>
    : std::bool_constant<details::maybe_equality_comparable<Type>(choice<2>)> {
};

template <typename Type>
inline constexpr bool is_equality_comparable_v =
    is_equality_comparable<Type>::value;

template <typename To, typename From> struct constness_as {
  using type = std::remove_const_t<To>;
};

template <typename To, typename From> struct constness_as<To, const From> {
  using type = const To;
};

template <typename To, typename From>
using constness_as_t = typename constness_as<To, From>::type;

template <typename Member> class member_class {
  static_assert(std::is_member_pointer_v<Member>,
                "Invalid pointer type to non-static member object or function");

  template <typename Class, typename Ret, typename... Args>
  static Class *clazz(Ret (Class::*)(Args...));

  template <typename Class, typename Ret, typename... Args>
  static Class *clazz(Ret (Class::*)(Args...) const);

  template <typename Class, typename Type> static Class *clazz(Type Class::*);

public:
  using type = std::remove_pointer_t<decltype(clazz(std::declval<Member>()))>;
};

template <typename Member>
using member_class_t = typename member_class<Member>::type;

template <std::size_t Index, auto Candidate> class nth_argument {
  template <typename Ret, typename... Args>
  static constexpr type_list<Args...> pick_up(Ret (*)(Args...));

  template <typename Ret, typename Class, typename... Args>
  static constexpr type_list<Args...> pick_up(Ret (Class ::*)(Args...));

  template <typename Ret, typename Class, typename... Args>
  static constexpr type_list<Args...> pick_up(Ret (Class ::*)(Args...) const);

  template <typename Type, typename Class>
  static constexpr type_list<Type> pick_up(Type Class ::*);

public:
  using type = type_list_element_t<Index, decltype(pick_up(Candidate))>;
};

template <std::size_t Index, auto Candidate>
using nth_argument_t = typename nth_argument<Index, Candidate>::type;



template<std::size_t N, typename Seq> struct offset_sequence;

template<std::size_t N, std::size_t... Ints>
struct offset_sequence<N, std::index_sequence<Ints...>>
{
 using type = std::index_sequence<Ints + N...>;
};
template<std::size_t N, typename Seq>
using offset_sequence_t = typename offset_sequence<N, Seq>::type;

template <typename T, T... S, typename F>
constexpr void for_sequence(std::integer_sequence<T, S...>, F &&f) {
  using unpack_t = int[];
  (void)unpack_t{(static_cast<void>(f(std::integral_constant<T, S>{})), 0)...,
                 0};
}


template <typename T, typename = void>
struct is_from_chars_convertible : std::false_type {};

template <typename T>
struct is_from_chars_convertible<
    T, std::void_t<decltype(std::from_chars(std::declval<const char *>(),
                                            std::declval<const char *>(),
                                            std::declval<T &>()))>>
    : std::true_type {};

} // namespace mpl