17template <
typename...
Args>
20template <
typename Func,
typename...
Arg>
23template <
typename Func,
typename...
Arg>
75template <
bool Condition,
typename T>
78 return std::move(std::forward<T>(
arg));
80 return std::forward<T>(
arg);
84template <
typename T,
typename... List>
85inline constexpr auto kCount = (std::size_t{std::is_same_v<T, List> ? 1 : 0} + ...);
87template <
typename T,
typename...
Ts>
88inline constexpr auto kContains = (std::is_same_v<T, Ts> || ...);
90template <
typename T,
typename Tuple>
93template <
typename T,
typename...
Ts>
98template <
typename Tuple>
101template <
typename T,
typename...
Ts>
106template <
typename Tuple>
109template <
template <
typename>
typename F,
typename Tuple>
112template <
template <
typename>
typename F>
117template <
template <
typename>
typename F,
typename T>
119 using Type = std::conditional_t<F<T>::Value, std::tuple<T>, std::tuple<>>;
122template <
template <
typename>
typename F,
typename T,
typename...
Ts>
125 using PrevType =
typename Filter<F, std::tuple<
Ts...>>::Type;
131template <
typename Tuple>
144template <
typename T,
typename...
Ts>
147 using PrevType =
typename Unique<std::tuple<
Ts...>>::Type;
153template <
typename Tuple>
156template <
typename...
Ts>
161template <
typename Tuple>
169template <
typename...
Ts>
187template <std::
size_t FromIndex, std::
size_t ToIndex,
typename FromTuple,
typename ToTuple>
190template <std::size_t
ToIndex,
typename... From,
typename...
To>
192 static_assert(
sizeof...(From) >=
sizeof...(
To));
193 static constexpr std::size_t
Index() {
198template <std::size_t
FromIndex, std::size_t
ToIndex,
typename... From,
typename...
To>
200 static_assert(
sizeof...(From) >=
sizeof...(
To));
203 static constexpr std::size_t
Index() {
206 tail_t<std::tuple<
To...>>>::Index();
213template <std::
size_t FromIndex,
typename FromTuple,
typename ToTuple>
216template <
typename T,
typename Tuple>
219template <
typename T,
typename...
Ts>
221 static_assert(
sizeof...(Ts) > 0);
223 static constexpr std::size_t
Index() {
224 if constexpr (std::is_same_v<T,
head_t<
Ts...>>) {
232template <
typename T,
typename Tuple>
237 static_assert(!std::is_reference_v<T>,
"T cannot be V&, just use pointer or std::reference_wrapper");
238 static_assert(!std::is_const_v<T>,
"T cannot be const, because it's unnecessary");
239 static_assert(!std::is_volatile_v<T>,
"T cannot be volatile, because it's unnecessary");
240 static_assert(!
is_result_v<T>,
"T cannot be Result, because it's ambiguous");
242 static_assert(!
is_task_v<T>,
"T cannot be Task, because it's ambiguous");
243 static_assert(!std::is_same_v<T, std::exception_ptr>,
"T cannot be std::exception_ptr, because it's ambiguous");
244 static_assert(!std::is_same_v<T, Unit>,
"T cannot be Unit, because Unit for internal instead of void usage");
typename detail::AsyncTypes< T >::Error async_error_t
constexpr bool is_waitable_v
typename detail::InstantiationTypes< Task, T >::Error task_error_t
typename detail::Head< Args... >::Type head_t
constexpr std::size_t index_of_v
constexpr bool is_result_v
typename detail::AsyncTypes< T >::Value async_value_t
constexpr bool is_invocable_v
decltype(auto) move_if(T &&arg) noexcept
typename WrapVoid< T >::Type wrap_void_t
constexpr bool is_combinator_input_v
typename Tail< Tuple >::Type tail_t
constexpr bool is_future_base_v
constexpr std::size_t translate_index_v
constexpr bool Check() noexcept
constexpr bool is_shared_future_base_v
Contract< V, E > MakeContract()
Creates related future and promise.
std::remove_cv_t< std::remove_reference_t< T > > remove_cvref_t
typename detail::Invoke< Func, Arg... >::Type invoke_t
constexpr bool is_waitable_with_timeout_v
typename detail::InstantiationTypes< Task, T >::Value task_value_t
typename detail::InstantiationTypes< Result, T >::Value result_value_t
typename detail::InstantiationTypes< Result, T >::Error result_error_t
std::conditional_t< F< T >::Value, typename Prepend< T, PrevType >::Type, PrevType > Type
std::conditional_t< F< T >::Value, std::tuple< T >, std::tuple<> > Type
static constexpr std::size_t Index()
std::variant< Ts... > Type
std::tuple< T, Ts... > Type
static constexpr std::size_t Index()
static constexpr std::size_t Index()
std::conditional_t< kContains< T, Ts... >, PrevType, typename Prepend< T, PrevType >::Type > Type
std::variant< Ts... > Type