type_traits_impl.hpp

Go to the documentation of this file.

#pragma once
 
#include <yaclib/fwd.hpp>
 
#include <type_traits>
 
namespace yaclib::detail {
 
template <typename...>
struct Head;
 
template <typename T, typename... Args>
struct Head<T, Args...> final {
  using Type = T;
};
 
template <typename Func, typename... Args>
struct IsInvocable final {
  static constexpr bool Value = std::is_invocable_v<Func, Args...>;
};
 
template <typename Func>
struct IsInvocable<Func, void> final {
  static constexpr bool Value = std::is_invocable_v<Func>;
};
 
template <typename Func, typename... Args>
struct Invoke final {
  using Type = std::invoke_result_t<Func, Args...>;
};
 
template <typename Func>
struct Invoke<Func, void> final {
  using Type = std::invoke_result_t<Func>;
};
 
template <template <typename...> typename Instance, typename...>
struct IsInstantiationOf final {
  static constexpr bool Value = false;
};
 
template <template <typename...> typename Instance, typename... Args>
struct IsInstantiationOf<Instance, Instance<Args...>> final {
  static constexpr bool Value = true;
};
 
template <template <typename...> typename Instance, typename T>
struct InstantiationType final {
  using Value = T;
};
 
template <template <typename...> typename Instance, typename V>
struct InstantiationType<Instance, Instance<V>> final {
  using Value = V;
};
 
template <template <typename...> typename Instance, typename T>
struct InstantiationTypes final {
  using Value = T;
  using Trait = T;
};
 
template <template <typename...> typename Instance, typename V, typename T>
struct InstantiationTypes<Instance, Instance<V, T>> final {
  using Value = V;
  using Trait = T;
};
 
template <typename T>
struct AsyncTypes final {
  using Value = T;
  using Trait = T;
};
 
template <typename V, typename T>
struct AsyncTypes<FutureBase<V, T>> final {
  using Value = V;
  using Trait = T;
};
 
template <typename V, typename T>
struct AsyncTypes<Future<V, T>> final {
  using Value = V;
  using Trait = T;
};
 
template <typename V, typename T>
struct AsyncTypes<FutureOn<V, T>> final {
  using Value = V;
  using Trait = T;
};
 
template <typename V, typename T>
struct AsyncTypes<SharedFutureBase<V, T>> final {
  using Value = V;
  using Trait = T;
};
 
template <typename V, typename T>
struct AsyncTypes<SharedFuture<V, T>> final {
  using Value = V;
  using Trait = T;
};
 
template <typename V, typename T>
struct AsyncTypes<SharedFutureOn<V, T>> final {
  using Value = V;
  using Trait = T;
};
 
}  // namespace yaclib::detail