120 template <
typename T>
126#if META_CXX_VARIABLE_TEMPLATES
127 template <
typename T>
128 META_INLINE_VAR
constexpr T *nullptr_v =
nullptr;
140 template <META_TYPE_CONSTRAINT(trait) T>
141 using _t =
typename T::type;
143#if META_CXX_VARIABLE_TEMPLATES || defined(META_DOXYGEN_INVOKED)
147 template <META_TYPE_CONSTRAINT(
integral) T>
148 constexpr typename T::type::value_type _v = T::type::value;
156 template <
typename T>
162 template <std::
size_t N>
163 using size_t = std::integral_constant<std::size_t, N>;
168 using bool_ = std::integral_constant<bool, B>;
173 using int_ = std::integral_constant<int, I>;
178 using char_ = std::integral_constant<char, Ch>;
184 template <META_TYPE_CONSTRAINT(
integral) T>
185 using inc = std::integral_constant<
decltype(T::type::value + 1), T::type::value + 1>;
189 template <META_TYPE_CONSTRAINT(
integral) T>
190 using dec = std::integral_constant<
decltype(T::type::value - 1), T::type::value - 1>;
195 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
196 using plus = std::integral_constant<
decltype(T::type::value + U::type::value),
197 T::type::value + U::type::value>;
202 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
203 using minus = std::integral_constant<
decltype(T::type::value - U::type::value),
204 T::type::value - U::type::value>;
209 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
210 using multiplies = std::integral_constant<
decltype(T::type::value * U::type::value),
211 T::type::value * U::type::value>;
216 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
217 using divides = std::integral_constant<
decltype(T::type::value / U::type::value),
218 T::type::value / U::type::value>;
223 template <META_TYPE_CONSTRAINT(
integral) T>
224 using negate = std::integral_constant<
decltype(-T::type::value), -T::type::value>;
229 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
230 using modulus = std::integral_constant<
decltype(T::type::value % U::type::value),
231 T::type::value % U::type::value>;
236 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
242 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
248 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
254 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
260 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
266 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
272 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
273 using bit_and = std::integral_constant<
decltype(T::type::value & U::type::value),
274 T::type::value & U::type::value>;
279 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
280 using bit_or = std::integral_constant<
decltype(T::type::value | U::type::value),
281 T::type::value | U::type::value>;
286 template <META_TYPE_CONSTRAINT(
integral) T, META_TYPE_CONSTRAINT(
integral) U>
287 using bit_xor = std::integral_constant<
decltype(T::type::value ^ U::type::value),
288 T::type::value ^ U::type::value>;
293 template <META_TYPE_CONSTRAINT(
integral) T>
294 using bit_not = std::integral_constant<
decltype(~T::type::value), ~T::type::value>;
300 template <
typename T>
305 template <
typename T>
310 template <
typename T,
typename U>
315 template <
typename T,
typename U>
320 template <
typename T,
typename U>
325 template <
typename T,
typename U>
330 template <
typename T>
335 template <
typename T,
typename U>
340 template <
typename T,
typename U>
345 template <
typename T,
typename U>
350 template <
typename T,
typename U>
355 template <
typename T,
typename U>
360 template <
typename T,
typename U>
365 template <
typename T,
typename U>
370 template <
typename T,
typename U>
375 template <
typename T,
typename U>
380 template <
typename T,
typename U>
385 template <
typename T>
392 enum class indices_strategy_
399 constexpr indices_strategy_ strategy_(std::size_t cur, std::size_t end)
401 return cur >= end ? indices_strategy_::done
402 : cur * 2 <= end ? indices_strategy_::repeat
403 : indices_strategy_::recurse;
406 template <
typename T>
407 constexpr std::size_t range_distance_(T begin, T end)
409 return begin <= end ? static_cast<std::size_t>(end - begin)
410 : throw
"The start of the integer_sequence must not be "
411 "greater than the end";
414 template <std::
size_t End,
typename State, indices_strategy_ Status_>
420 template <
typename T, T,
typename>
421 struct coerce_indices_
429#if !META_CXX_INTEGER_SEQUENCE
432 template <
typename T, T... Is>
435 using value_type = T;
437 static constexpr std::size_t
size() noexcept {
return sizeof...(Is); }
446 template <std::size_t... Is>
449#if META_HAS_MAKE_INTEGER_SEQ && !defined(META_DOXYGEN_INVOKED)
456 template <
typename T, T N>
457 __make_integer_seq<integer_sequence, T, N> make_integer_sequence_();
461 template <
typename T, T N>
464 template <std::
size_t N>
471 template <std::
size_t N>
479 template <
typename T, T N>
490 template <
typename T, T From, T To>
492 _t<detail::coerce_indices_<T, From,
498 template <
typename,
typename>
499 struct concat_indices_
503 template <std::size_t... Is, std::size_t... Js>
510 struct make_indices_<0u,
index_sequence<0>, indices_strategy_::done>
515 template <std::size_t End, std::size_t... Values>
516 struct make_indices_<End,
index_sequence<Values...>, indices_strategy_::repeat>
517 : make_indices_<End, index_sequence<Values..., (Values + sizeof...(Values))...>,
518 detail::strategy_(sizeof...(Values) * 2, End)>
522 template <std::size_t End, std::size_t... Values>
523 struct make_indices_<End,
index_sequence<Values...>, indices_strategy_::recurse>
524 : concat_indices_<index_sequence<Values...>,
525 make_index_sequence<End - sizeof...(Values)>>
529 template <
typename T, T Offset, std::size_t... Values>
540 template <META_TYPE_CONSTRAINT(invocable) Fn,
typename... Args>
548 template <
typename Fn,
typename... Args>
556 template <
typename T>
559#if defined(META_WORKAROUND_CWG_1558) && !defined(META_DOXYGEN_INVOKED)
562 static id impl(
void *);
564 template <
typename... Ts>
565 using invoke =
_t<
decltype(id::impl(
static_cast<list<Ts...
> *>(
nullptr)))>;
567 template <
typename...>
576 template <
typename T>
584 template <
typename T>
590#if defined(META_WORKAROUND_CWG_1558) && !defined(META_DOXYGEN_INVOKED)
593 template <
typename... Ts>
596 template <
typename...>
600#if META_CXX_VARIABLE_TEMPLATES
604 template <
typename T>
605 META_INLINE_VAR
constexpr bool is_trait_v = trait<T>;
609 template <
typename T>
610 META_INLINE_VAR
constexpr bool is_callable_v = invocable<T>;
615 template <
typename,
typename =
void>
616 META_INLINE_VAR
constexpr bool is_trait_ =
false;
618 template <
typename T>
619 META_INLINE_VAR
constexpr bool is_trait_<T, void_<typename T::type>> =
true;
621 template <
typename,
typename =
void>
622 META_INLINE_VAR
constexpr bool is_callable_ =
false;
624 template <
typename T>
625 META_INLINE_VAR
constexpr bool is_callable_<T, void_<quote<T::template invoke>>> =
true;
631 template <
typename T>
632 META_INLINE_VAR
constexpr bool is_trait_v = detail::is_trait_<T>;
636 template <
typename T>
637 META_INLINE_VAR
constexpr bool is_callable_v = detail::is_callable_<T>;
643 template <
typename T>
644 using is_trait = bool_<is_trait_v<T>>;
649 template <
typename T>
655 template <
typename,
typename =
void>
658 using type = std::false_type;
661 template <
typename T>
662 struct is_trait_<T,
void_<typename T::type>>
664 using type = std::true_type;
667 template <
typename,
typename =
void>
670 using type = std::false_type;
673 template <
typename T>
674 struct is_callable_<T,
void_<quote<T::template
invoke>>>
676 using type = std::true_type;
681 template <
typename T>
682 using is_trait = _t<detail::is_trait_<T>>;
688 template <
typename T>
696 template <
template <
typename...>
class,
typename...>
701 template <
template <
typename...>
class C,
typename... Ts>
702 requires valid<C, Ts...>
struct defer_<C, Ts...>
704 using type = C<Ts...>;
707 template <
typename T,
template <T...>
class, T...>
712 template <
typename T,
template <T...>
class C, T... Is>
713 requires valid_i<T, C, Is...>
struct defer_i_<T, C, Is...>
715 using type = C<Is...>;
717#elif defined(META_WORKAROUND_MSVC_703656)
718 template <
typename,
template <
typename...>
class,
typename...>
723 template <
template <
typename...>
class C,
typename... Ts>
724 struct _defer_<
void_<C<Ts...>>, C, Ts...>
726 using type = C<Ts...>;
729 template <
template <
typename...>
class C,
typename... Ts>
730 using defer_ = _defer_<void, C, Ts...>;
732 template <
typename,
typename T,
template <T...>
class, T...>
737 template <
typename T,
template <T...>
class C, T... Is>
738 struct _defer_i_<
void_<C<Is...>>, T, C, Is...>
740 using type = C<Is...>;
743 template <
typename T,
template <T...>
class C, T... Is>
744 using defer_i_ = _defer_i_<void, T, C, Is...>;
746 template <
template <
typename...>
class C,
typename... Ts,
747 template <
typename...>
class D = C>
748 id<D<Ts...>> try_defer_(
int);
749 template <
template <
typename...>
class C,
typename... Ts>
750 nil_ try_defer_(
long);
752 template <
template <
typename...>
class C,
typename... Ts>
753 using defer_ =
decltype(detail::try_defer_<C, Ts...>(0));
755 template <
typename T,
template <T...>
class C, T... Is,
template <T...>
class D = C>
756 id<D<Is...>> try_defer_i_(
int);
757 template <
typename T,
template <T...>
class C, T... Is>
758 nil_ try_defer_i_(
long);
760 template <
typename T,
template <T...>
class C, T... Is>
761 using defer_i_ =
decltype(detail::try_defer_i_<T, C, Is...>(0));
764 template <
typename T>
785 template <
template <
typename...>
class C,
typename... Ts>
786 struct defer : detail::defer_<C, Ts...>
796 template <
typename T,
template <T...>
class C, T... Is>
797 struct defer_i : detail::defer_i_<T, C, Is...>
807 template <
template <
typename...>
class C,
typename... Ts>
816 template <
typename T,
template <T...>
class C, T... Is>
823 template <
typename T>
830 template <
typename T>
837 template <
typename T>
842 template <
typename T>
846#if META_CXX_VARIABLE_TEMPLATES
851 template <
typename T,
template <
typename...>
class C>
858 template <
typename,
template <
typename...>
class>
859 struct is_ : std::false_type
863 template <
typename... Ts,
template <
typename...>
class C>
864 struct is_<C<Ts...>, C> : std::true_type
873 template <
typename T,
template <
typename...>
class C>
879 template <META_TYPE_CONSTRAINT(invocable)... Fns>
884 template <META_TYPE_CONSTRAINT(invocable) Fn0>
887 template <
typename... Ts>
888 using invoke = invoke<Fn0, Ts...>;
891 template <META_TYPE_CONSTRAINT(invocable) Fn0, META_TYPE_CONSTRAINT(invocable)... Fns>
894 template <
typename... Ts>
895 using invoke = invoke<Fn0, invoke<
compose_<Fns...>, Ts...>>;
898 template <
typename... Fns>
905 template <
typename... Fns>
911 template <
template <
typename...>
class C>
916 template <
typename... Ts>
917 using invoke =
_t<
defer<C, Ts...>>;
923 template <
typename T,
template <T...>
class C>
928 template <META_TYPE_CONSTRAINT(integral)... Ts>
929 using invoke =
_t<
defer_i<T, C, Ts::type::value...>>;
932#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 4 && __GNUC_MINOR__ <= 8 && \
933!defined(META_DOXYGEN_INVOKED)
934 template <
template <
typename...>
class C>
937 template <
typename... Ts>
941 template <
typename T,
template <T...>
class C>
944 template <
typename... Ts>
945 using invoke = _t<invoke<quote_i<T, C>, Ts...>>;
954 template <
template <
typename...>
class C>
959 template <
typename T,
template <T...>
class C>
967 template <META_TYPE_CONSTRAINT(invocable) Fn,
typename... Ts>
970 template <
typename... Us>
971 using invoke = invoke<Fn, Ts..., Us...>;
977 template <META_TYPE_CONSTRAINT(invocable) Fn,
typename... Us>
980 template <
typename... Ts>
981 using invoke = invoke<Fn, Ts..., Us...>;
988 template <
typename Fn,
typename... Ts>
993 template <
typename Fn,
typename... Ts>
1003 template <META_TYPE_CONSTRAINT(invocable) Fn,
typename L>
1008 template <META_TYPE_CONSTRAINT(invocable) Fn,
typename Ret,
typename... Args>
1013 template <META_TYPE_CONSTRAINT(invocable) Fn,
template <
typename...>
class T,
1019 template <META_TYPE_CONSTRAINT(invocable) Fn,
typename T, T... Is>
1029 template <META_TYPE_CONSTRAINT(invocable) Fn,
typename L>
1034 template <
typename Fn,
typename L>
1041 template <META_TYPE_CONSTRAINT(invocable) Fn,
1042 META_TYPE_CONSTRAINT(invocable) Q = quote<list>>
1048 template <META_TYPE_CONSTRAINT(invocable) Fn>
1055 template <
typename Fn,
typename Q = quote<list>>
1060 template <
typename Fn>
1066 template <META_TYPE_CONSTRAINT(invocable) Fn>
1070 template <
typename... Ts>
1074 template <
typename A,
typename B,
typename... Ts>
1075 struct impl<A, B, Ts...> :
lazy::invoke<Fn, B, A, Ts...>
1080 template <
typename... Ts>
1081 using invoke =
_t<impl<Ts...>>;
1088 template <
typename Fn>
1095 template <
typename...>
1099 template <
typename Fn,
typename... Gs>
1100 struct on_<Fn, Gs...>
1102 template <
typename... Ts>
1103 using invoke = invoke<Fn, invoke<compose<Gs...>, Ts>...>;
1111 template <META_TYPE_CONSTRAINT(invocable)... Fns>
1112 using on_ = detail::on_<Fns...>;
1114 template <
typename... Fns>
1115 using on =
on_<Fns...>;
1121 template <
typename Fn,
typename G>
1133 template <
typename Then,
typename Else>
1139 template <
typename Then,
typename Else>
1140 using invoke = Else;
1147 template <
bool If,
typename Then,
typename Else =
void>
1156 template <
typename...>
1161 template <
typename If>
1162 requires integral<If>
1163 struct _if_<If> : std::enable_if<_v<If>>
1167 template <
typename If,
typename Then>
1168 requires integral<If>
1169 struct _if_<If, Then> : std::enable_if<_v<If>, Then>
1173 template <
typename If,
typename Then,
typename Else>
1174 requires integral<If>
1175 struct _if_<If, Then, Else> : std::conditional<_v<If>, Then, Else>
1178#elif defined(__clang__)
1180 template <
typename,
typename =
bool>
1185 template <
typename If>
1186 struct _if_<
list<If>, decltype(bool(If::type::value))> : std::enable_if<If::type::value>
1190 template <
typename If,
typename Then>
1191 struct _if_<
list<If, Then>, decltype(bool(If::type::value))>
1192 : std::enable_if<If::type::value, Then>
1196 template <
typename If,
typename Then,
typename Else>
1197 struct _if_<
list<If, Then, Else>, decltype(bool(If::type::value))>
1198 : std::conditional<If::type::value, Then, Else>
1203 template <
typename,
typename = std::true_type>
1208 template <
typename If>
1209 struct _if_<
list<If>,
bool_<If::type::value>>
1214 template <
typename If,
typename Then>
1215 struct _if_<
list<If, Then>,
bool_<If::type::value>>
1220 template <
typename If,
typename Then,
typename Else>
1221 struct _if_<
list<If, Then, Else>,
bool_<If::type::value>>
1226 template <
typename If,
typename Then,
typename Else>
1227 struct _if_<
list<If, Then, Else>,
bool_<!If::type::value>>
1238 template <
typename... Args>
1239 using if_ =
_t<detail::_if_<Args...>>;
1243 template <
bool If,
typename... Args>
1244 using if_c = _t<detail::_if_<bool_<If>, Args...>>;
1246 template <
typename... Args>
1249 template <
bool If,
typename... Args>
1257 template <
typename... Args>
1262 template <
bool If,
typename... Args>
1270 template <
typename...>
1276 struct _and_<> : std::true_type
1280 template <
typename B,
typename... Bs>
1281 requires integral<B> && (bool(B::type::value))
1282 struct _and_<B, Bs...> : _and_<Bs...>
1286 template <
typename B,
typename... Bs>
1287 requires integral<B> && (!bool(B::type::value))
1288 struct _and_<B, Bs...> : std::false_type
1292 template <
typename...>
1298 struct _or_<> : std::false_type
1302 template <
typename B,
typename... Bs>
1303 requires integral<B> && (bool(B::type::value))
1304 struct _or_<B, Bs...> : std::true_type
1308 template <
typename B,
typename... Bs>
1309 requires integral<B> && (!bool(B::type::value))
1310 struct _or_<B, Bs...> : _or_<Bs...>
1317 template <
typename...>
1318 using invoke = std::true_type;
1324 template <
typename B,
typename... Bs>
1326 if_c<!B::type::value, id<std::false_type>, _and_<0 ==
sizeof...(Bs)>>,
1333 template <
typename =
void>
1334 using invoke = std::false_type;
1340 template <
typename B,
typename... Bs>
1342 if_c<B::type::value, id<std::true_type>, _or_<0 ==
sizeof...(Bs)>>,
1356 template <META_TYPE_CONSTRAINT(
integral) B>
1359#if META_CXX_FOLD_EXPRESSIONS && !defined(META_WORKAROUND_GCC_UNKNOWN1)
1360 template <
bool... Bs>
1361 META_INLINE_VAR
constexpr bool and_v = (
true && ... && Bs);
1365 template <
bool... Bs>
1366#if defined(META_WORKAROUND_MSVC_756112) || defined(META_WORKAROUND_GCC_86356)
1372#if defined(META_WORKAROUND_GCC_66405)
1373 template <
bool... Bs>
1378 template <
bool... Bs>
1381 META_IS_SAME(integer_sequence<bool, Bs...>,
1382 integer_sequence<bool, (Bs || true)...>)>
1385#if META_CXX_VARIABLE_TEMPLATES
1386 template <
bool... Bs>
1387 META_INLINE_VAR
constexpr bool and_v =
1396 template <META_TYPE_CONSTRAINT(integral)... Bs>
1399 template <
typename... Bs>
1405 template <
typename... Bs>
1407 using and_ =
_t<detail::_and_<Bs...>>;
1416#if META_CXX_FOLD_EXPRESSIONS && !defined(META_WORKAROUND_GCC_UNKNOWN1)
1417 template <
bool... Bs>
1418 META_INLINE_VAR
constexpr bool or_v = (
false || ... || Bs);
1420 template <
bool... Bs>
1421#if defined(META_WORKAROUND_MSVC_756112) || defined(META_WORKAROUND_GCC_86356)
1424 using or_c =
bool_<(
false || ... || Bs)>;
1427 template <
bool... Bs>
1430 !META_IS_SAME(integer_sequence<bool, Bs...>,
1431 integer_sequence<bool, (Bs && false)...>)>
1433#if META_CXX_VARIABLE_TEMPLATES
1434 template <
bool... Bs>
1435 META_INLINE_VAR
constexpr bool or_v =
1444 template <META_TYPE_CONSTRAINT(integral)... Bs>
1447 template <
typename... Bs>
1453 template <
typename... Bs>
1455 using or_ =
_t<detail::_or_<Bs...>>;
1466 template <
typename... Bs>
1471 template <
typename... Bs>
1476 template <
typename B>
1481 template <
typename... Bs>
1486 template <
typename... Bs>
1495 template <
typename,
typename,
typename>
1500 template <
typename Fn,
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
1501 typename T5,
typename T6,
typename T7,
typename T8,
typename T9>
1504 template <
typename X,
typename Y>
1505 using F = invoke<Fn, X, Y>;
1507 template <
typename S>
1509 F<F<F<F<F<F<F<F<F<F<_t<S>, T0>, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>;
1513 template <
typename Fn>
1516 template <
typename X,
typename Y>
1517 using F = invoke<Fn, X, Y>;
1519 template <
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
1520 typename T5,
typename T6,
typename T7,
typename T8,
typename T9,
1523 F<F<F<F<F<F<F<F<F<F<State, T0>, T1>, T2>, T3>, T4>, T5>, T6>, T7>, T8>, T9>;
1526 template <
typename State,
typename Fn>
1527 struct fold_<list<>, State, Fn>
1532 template <
typename Head,
typename... Tail,
typename State,
typename Fn>
1533 requires valid<invoke, Fn, State, Head>
1534 struct fold_<list<Head, Tail...>, State, Fn>
1535 : fold_<list<Tail...>, invoke<Fn, State, Head>, Fn>
1539 template <
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
1540 typename T6,
typename T7,
typename T8,
typename T9,
typename... Tail,
1541 typename State,
typename Fn>
1542 requires valid<invoke, compose_<Fn>, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, State>
1543 struct fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn>
1544 : fold_<list<Tail...>,
1545 invoke<compose_<Fn>, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, State>, Fn>
1549 template <
typename Fn,
typename T0>
1552 template <
typename X>
1553 using invoke = invoke<Fn, _t<X>, T0>;
1556 template <
typename State,
typename Fn>
1557 struct fold_<list<>, State, Fn> : State
1561 template <
typename Head,
typename... Tail,
typename State,
typename Fn>
1562 struct fold_<list<Head, Tail...>, State, Fn>
1563 : fold_<list<Tail...>, lazy::invoke<compose1_<Fn, Head>, State>, Fn>
1567 template <
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
1568 typename T6,
typename T7,
typename T8,
typename T9,
typename... Tail,
1569 typename State,
typename Fn>
1570 struct fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn>
1571 : fold_<list<Tail...>,
1572 lazy::invoke<compose10_<Fn, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>, State>, Fn>
1585 template <META_TYPE_CONSTRAINT(list_like) L,
typename State, META_TYPE_CONSTRAINT(invocable) Fn>
1587 using fold = _t<detail::fold_<L, State, Fn>>;
1596 template <META_TYPE_CONSTRAINT(list_like) L,
typename State, META_TYPE_CONSTRAINT(invocable) Fn>
1603 template <
typename L,
typename State,
typename Fn>
1608 template <
typename L,
typename State,
typename Fn>
1617 template <
typename,
typename,
typename>
1618 struct reverse_fold_
1622 template <
typename State,
typename Fn>
1623 struct reverse_fold_<list<>, State, Fn>
1629 template <
typename Head,
typename... L,
typename State,
typename Fn>
1630 requires trait<reverse_fold_<list<L...>, State, Fn>>
struct reverse_fold_<
1631 list<Head, L...>, State, Fn>
1632 :
lazy::invoke<Fn, _t<reverse_fold_<list<L...>, State, Fn>>, Head>
1636 template <
typename Head,
typename... Tail,
typename State,
typename Fn>
1637 struct reverse_fold_<list<Head, Tail...>, State, Fn>
1638 :
lazy::invoke<compose1_<Fn, Head>, reverse_fold_<list<Tail...>, State, Fn>>
1643 template <
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
1644 typename T6,
typename T7,
typename T8,
typename T9,
typename... Tail,
1645 typename State,
typename Fn>
1646 struct reverse_fold_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Tail...>, State, Fn>
1647 :
lazy::invoke<compose10_<Fn, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0>,
1648 reverse_fold_<list<Tail...>, State, Fn>>
1660 template <META_TYPE_CONSTRAINT(list_like) L,
typename State, META_TYPE_CONSTRAINT(invocable) Fn>
1667 template <
typename L,
typename State,
typename Fn>
1682 template <
typename... Ts>
1687 static constexpr std::size_t
size() noexcept {
return sizeof...(Ts); }
1695 template <META_TYPE_CONSTRAINT(list_like) L>
1702 template <
typename L>
1711 template <
typename... Lists>
1719 using type = list<>;
1722 template <
typename... L1>
1725 using type = list<L1...>;
1728 template <
typename... L1,
typename... L2>
1729 struct concat_<list<L1...>, list<L2...>>
1731 using type = list<L1..., L2...>;
1734 template <
typename... L1,
typename... L2,
typename... L3>
1735 struct concat_<list<L1...>, list<L2...>, list<L3...>>
1737 using type = list<L1..., L2..., L3...>;
1740 template <
typename... L1,
typename... L2,
typename... L3,
typename... Rest>
1741 struct concat_<list<L1...>, list<L2...>, list<L3...>, Rest...>
1742 :
concat_<list<L1..., L2..., L3...>, Rest...>
1746 template <
typename... L1,
typename... L2,
typename... L3,
typename... L4,
1747 typename... L5,
typename... L6,
typename... L7,
typename... L8,
1748 typename... L9,
typename... L10,
typename... Rest>
1749 struct concat_<list<L1...>, list<L2...>, list<L3...>, list<L4...>, list<L5...>,
1750 list<L6...>, list<L7...>, list<L8...>, list<L9...>, list<L10...>,
1752 :
concat_<list<L1..., L2..., L3..., L4..., L5..., L6..., L7..., L8..., L9..., L10...>,
1764 template <META_TYPE_CONSTRAINT(list_like)... Ls>
1767 template <
typename... Lists>
1768 using concat =
concat_<Lists...>;
1774 template <
typename... Lists>
1785 template <META_TYPE_CONSTRAINT(list_like) ListOfLists>
1792 template <
typename ListOfLists>
1802 template <
typename... Args>
1807 template <
typename... Ts,
typename Fn>
1808 requires invocable<Fn> && and_v<valid<invoke, Fn, Ts>...>
1809 struct transform_<list<Ts...>, Fn>
1811 using type = list<invoke<Fn, Ts>...>;
1814 template <
typename... Ts,
typename... Us,
typename Fn>
1815 requires invocable<Fn> && and_v<valid<invoke, Fn, Ts, Us>...>
1816 struct transform_<list<Ts...>, list<Us...>, Fn>
1818 using type = list<invoke<Fn, Ts, Us>...>;
1821 template <
typename,
typename =
void>
1826 template <
typename... Ts,
typename Fn>
1827 struct transform_<list<list<Ts...>, Fn>,
void_<
invoke<Fn, Ts>...>>
1829 using type = list<invoke<Fn, Ts>...>;
1832 template <
typename... Ts0,
typename... Ts1,
typename Fn>
1833 struct transform_<list<list<Ts0...>, list<Ts1...>, Fn>,
1836 using type = list<invoke<Fn, Ts0, Ts1>...>;
1851 template <
typename... Args>
1852 using transform =
_t<detail::transform_<Args...>>;
1854 template <
typename... Args>
1862 template <
typename... Args>
1871 template <
typename T, std::
size_t>
1874 template <
typename T,
typename Ints>
1879 template <
typename T, std::size_t... Is>
1882 using type = list<first_<T, Is>...>;
1891 template <std::
size_t N,
typename T =
void>
1898 template <META_TYPE_CONSTRAINT(
integral) N,
typename T =
void>
1905 template <
typename N,
typename T =
void>
1910 template <std::
size_t N,
typename T =
void>
1919#if META_HAS_TYPE_PACK_ELEMENT && !defined(META_DOXYGEN_INVOKED)
1920 template <
typename L, std::
size_t N,
typename =
void>
1925 template <
typename... Ts, std::size_t N>
1926 struct at_<list<Ts...>, N,
void_<__type_pack_element<N, Ts...>>>
1928 using type = __type_pack_element<N, Ts...>;
1931 template <
typename Vo
idPtrs>
1934 template <
typename... VoidPtrs>
1935 struct at_impl_<list<VoidPtrs...>>
1937 static nil_ eval(...);
1939 template <
typename T,
typename... Us>
1940 static T eval(VoidPtrs..., T *, Us *...);
1943 template <
typename L, std::
size_t N>
1948 template <
typename... Ts, std::size_t N>
1949 struct at_<list<Ts...>, N>
1950 : decltype(at_impl_<repeat_n_c<N, void *>>::eval(static_cast<id<Ts> *>(nullptr)...))
1961 template <META_TYPE_CONSTRAINT(list_like) L, std::
size_t N>
1968 template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(
integral) N>
1975 template <
typename L,
typename N>
1986 template <
typename Vo
idPtrs>
1989 static nil_ eval(...);
1992 template <
typename... VoidPtrs>
1993 struct drop_impl_<list<VoidPtrs...>>
1995 static nil_ eval(...);
1997 template <
typename... Ts>
1998 static id<list<Ts...>> eval(VoidPtrs..., id<Ts> *...);
2002 struct drop_impl_<list<>>
2004 template <
typename... Ts>
2005 static id<list<Ts...>> eval(id<Ts> *...);
2008 template <
typename L, std::
size_t N>
2013 template <
typename... Ts, std::size_t N>
2014 struct drop_<list<Ts...>, N>
2015#if META_CXX_VARIABLE_TEMPLATES
2016 : decltype(drop_impl_<repeat_n_c<N, void *>>::eval(detail::nullptr_v<id<Ts>>...))
2018 : decltype(drop_impl_<repeat_n_c<N, void *>>::eval(detail::_nullptr_v<id<Ts>>()...))
2029 template <META_TYPE_CONSTRAINT(list_like) L, std::
size_t N>
2036 template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(
integral) N>
2043 template <
typename L,
typename N>
2052 template <
typename L>
2057 template <
typename Head,
typename... Tail>
2058 struct front_<list<Head, Tail...>>
2069 template <META_TYPE_CONSTRAINT(list_like) L>
2076 template <
typename L>
2085 template <
typename L>
2090 template <
typename Head,
typename... Tail>
2091 struct back_<list<Head, Tail...>>
2093 using type = at_c<list<Head, Tail...>,
sizeof...(Tail)>;
2102 template <META_TYPE_CONSTRAINT(list_like) L>
2109 template <
typename L>
2119 template <META_TYPE_CONSTRAINT(list_like) L,
typename... Ts>
2126 template <
typename... Ts>
2135 template <
typename L>
2140 template <
typename Head,
typename... L>
2141 struct pop_front_<list<Head, L...>>
2143 using type = list<L...>;
2153 template <META_TYPE_CONSTRAINT(list_like) L>
2160 template <
typename L>
2172 template <META_TYPE_CONSTRAINT(list_like) L,
typename... Ts>
2179 template <
typename... Ts>
2186 template <
typename T,
typename U>
2189 template <
typename T,
typename U>
2196 template <META_TYPE_CONSTRAINT(integral)... Ts>
2199 template <
typename... Ts>
2200 using min =
min_<Ts...>;
2204 template <META_TYPE_CONSTRAINT(integral)... Ts>
2207 template <
typename... Ts>
2208 using max =
max_<Ts...>;
2214 template <
typename... Ts>
2219 template <
typename... Ts>
2230 template <META_TYPE_CONSTRAINT(list_like) L>
2237 template <
typename L>
2245 template <
typename F,
typename S>
2250 template <
typename Pair>
2255 template <
typename Pair>
2262 template <
typename Pair>
2267 template <
typename Pair>
2277 constexpr std::size_t find_index_i_(
bool const *
const first,
bool const *
const last,
2280 return first == last ? npos::value
2281 : *
first ? N : find_index_i_(
first + 1, last, N + 1);
2284 template <
typename L,
typename T>
2289 template <
typename V>
2290 struct find_index_<list<>, V>
2295 template <
typename... T,
typename V>
2296 struct find_index_<list<T...>, V>
2298#ifdef META_WORKAROUND_LLVM_28385
2299 static constexpr bool s_v[
sizeof...(T)] = {META_IS_SAME(T, V)...};
2301 static constexpr bool s_v[] = {META_IS_SAME(T, V)...};
2303 using type =
size_t<find_index_i_(s_v, s_v +
sizeof...(T))>;
2314 template <META_TYPE_CONSTRAINT(list_like) L,
typename T>
2321 template <
typename L,
typename T>
2331 constexpr std::size_t reverse_find_index_i_(
bool const *
const first,
2332 bool const *
const last, std::size_t N)
2334 return first == last
2336 : *(last - 1) ? N - 1 : reverse_find_index_i_(
first, last - 1, N - 1);
2339 template <
typename L,
typename T>
2340 struct reverse_find_index_
2344 template <
typename V>
2345 struct reverse_find_index_<list<>, V>
2350 template <
typename... T,
typename V>
2351 struct reverse_find_index_<list<T...>, V>
2353#ifdef META_WORKAROUND_LLVM_28385
2354 static constexpr bool s_v[
sizeof...(T)] = {META_IS_SAME(T, V)...};
2356 static constexpr bool s_v[] = {META_IS_SAME(T, V)...};
2358 using type =
size_t<reverse_find_index_i_(s_v, s_v +
sizeof...(T),
sizeof...(T))>;
2369 template <META_TYPE_CONSTRAINT(list_like) L,
typename T>
2376 template <
typename L,
typename T>
2387 template <META_TYPE_CONSTRAINT(list_like) L,
typename T>
2394 template <
typename L,
typename T>
2403 template <
typename L,
typename T,
typename State = list<>>
2404 struct reverse_find_
2408 template <
typename T,
typename State>
2409 struct reverse_find_<list<>, T, State>
2414 template <
typename Head,
typename... L,
typename T,
typename State>
2415 struct reverse_find_<list<Head, L...>, T, State> : reverse_find_<list<L...>, T, State>
2419 template <
typename... L,
typename T,
typename State>
2420 struct reverse_find_<list<T, L...>, T, State>
2421 : reverse_find_<list<L...>, T, list<T, L...>>
2432 template <META_TYPE_CONSTRAINT(list_like) L,
typename T>
2439 template <
typename L,
typename T>
2449 template <
typename L,
typename Fn>
2454 template <
typename Fn>
2455 struct find_if_<list<>, Fn>
2457 using type = list<>;
2460 template <
typename Head,
typename... L,
typename Fn>
2461 requires integral<invoke<Fn, Head>>
2462 struct find_if_<list<Head, L...>, Fn>
2463 :
if_<invoke<Fn, Head>, id<list<Head, L...>>, find_if_<list<L...>, Fn>>
2467 constexpr bool const *find_if_i_(
bool const *
const begin,
bool const *
const end)
2469 return begin == end || *begin ? begin : find_if_i_(begin + 1, end);
2472 template <
typename L,
typename Fn,
typename =
void>
2477 template <
typename Fn>
2478 struct find_if_<list<>, Fn>
2480 using type = list<>;
2483 template <
typename... L,
typename Fn>
2484 struct find_if_<list<L...>, Fn,
2485 void_<integer_sequence<bool, bool(
invoke<Fn, L>::type::value)...>>>
2487#ifdef META_WORKAROUND_LLVM_28385
2488 static constexpr bool s_v[
sizeof...(L)] = {invoke<Fn, L>::type::value...};
2490 static constexpr bool s_v[] = {invoke<Fn, L>::type::value...};
2493 drop_c<list<L...>, detail::find_if_i_(s_v, s_v +
sizeof...(L)) - s_v>;
2505 template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
2512 template <
typename L,
typename Fn>
2522 template <
typename L,
typename Fn,
typename State = list<>>
2523 struct reverse_find_if_
2527 template <
typename Fn,
typename State>
2528 struct reverse_find_if_<list<>, Fn, State>
2533 template <
typename Head,
typename... L,
typename Fn,
typename State>
2534 requires integral<invoke<Fn, Head>>
2535 struct reverse_find_if_<list<Head, L...>, Fn, State>
2536 : reverse_find_if_<list<L...>, Fn, if_<invoke<Fn, Head>, list<Head, L...>, State>>
2540 constexpr bool const *reverse_find_if_i_(
bool const *
const begin,
bool const *
const pos,
2541 bool const *
const end)
2545 : *(pos - 1) ? pos - 1 : reverse_find_if_i_(begin, pos - 1, end);
2548 template <
typename L,
typename Fn,
typename =
void>
2549 struct reverse_find_if_
2553 template <
typename Fn>
2554 struct reverse_find_if_<list<>, Fn>
2556 using type = list<>;
2559 template <
typename... L,
typename Fn>
2560 struct reverse_find_if_<
2562 void_<integer_sequence<bool, bool(
invoke<Fn, L>::type::value)...>>>
2564#ifdef META_WORKAROUND_LLVM_28385
2565 static constexpr bool s_v[
sizeof...(L)] = {invoke<Fn, L>::type::value...};
2567 static constexpr bool s_v[] = {invoke<Fn, L>::type::value...};
2570 drop_c<list<L...>, detail::reverse_find_if_i_(s_v, s_v +
sizeof...(L),
2571 s_v +
sizeof...(L)) -
2584 template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
2591 template <
typename L,
typename Fn>
2600 template <
typename L,
typename T,
typename U>
2605 template <
typename... L,
typename T,
typename U>
2606 struct replace_<list<L...>, T, U>
2608 using type = list<if_c<META_IS_SAME(T, L), U, L>...>;
2618 template <META_TYPE_CONSTRAINT(list_like) L,
typename T,
typename U>
2625 template <
typename L,
typename T,
typename U>
2635 template <
typename L,
typename C,
typename U>
2640 template <
typename... L,
typename C,
typename U>
2641 requires and_v<integral<invoke<C, L>>...>
2642 struct replace_if_<list<L...>, C, U>
2644 using type = list<if_<invoke<C, L>, U, L>...>;
2647 template <
typename L,
typename C,
typename U,
typename =
void>
2652 template <
typename... L,
typename C,
typename U>
2653 struct replace_if_<list<L...>, C, U,
2654 void_<integer_sequence<bool, bool(
invoke<C, L>::type::value)...>>>
2656 using type = list<if_<invoke<C, L>, U, L>...>;
2668 template <META_TYPE_CONSTRAINT(list_like) L,
typename C,
typename U>
2675 template <
typename L,
typename C,
typename U>
2683 template <
typename,
typename>
2688#if (defined(META_CONCEPT) || META_CXX_VARIABLE_TEMPLATES) && META_CXX_FOLD_EXPRESSIONS
2689 template <
typename... Ts,
typename T>
2692 using type =
meta::size_t<((std::size_t)META_IS_SAME(T, Ts) + ...)>;
2695 constexpr std::size_t count_i_(
bool const *
const begin,
bool const *
const end,
2698 return begin == end ? n : detail::count_i_(begin + 1, end, n + *begin);
2701 template <
typename T>
2707 template <
typename... L,
typename T>
2710#ifdef META_WORKAROUND_LLVM_28385
2711 static constexpr bool s_v[
sizeof...(L)] = {META_IS_SAME(T, L)...};
2713 static constexpr bool s_v[] = {META_IS_SAME(T, L)...};
2715 using type =
meta::size_t<detail::count_i_(s_v, s_v +
sizeof...(L), 0u)>;
2724 template <META_TYPE_CONSTRAINT(list_like) L,
typename T>
2731 template <
typename L,
typename T>
2739#if defined(META_CONCEPT) && META_CXX_FOLD_EXPRESSIONS
2740 template <
typename,
typename>
2745 template <
typename... Ts,
typename Fn>
2746 requires (integral<invoke<Fn, Ts>> && ...)
2747 struct count_if_<list<Ts...>, Fn>
2749 using type =
meta::size_t<((std::size_t)(
bool)_v<invoke<Fn, Ts>> + ...)>;
2752 template <
typename L,
typename Fn,
typename =
void>
2757 template <
typename Fn>
2763 template <
typename... L,
typename Fn>
2767#if META_CXX_FOLD_EXPRESSIONS
2770#ifdef META_WORKAROUND_LLVM_28385
2775 using type =
meta::size_t<detail::count_i_(s_v, s_v +
sizeof...(L), 0u)>;
2786 template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
2793 template <
typename L,
typename Fn>
2802 template <
typename Pred>
2805 template <
typename A>
2817 template <
typename L,
typename Pred>
2824 template <
typename L,
typename Fn>
2833 template <
typename T>
2836 static constexpr T value{};
2840 template <
typename T>
2841 constexpr T static_const<T>::value;
2853 template <
class Fn,
class... Args>
2854 constexpr auto operator()(list<Args...>, Fn f)
const -> Fn
2856 return (
void)std::initializer_list<int>{((void)f(Args{}), 0)...}, f;
2862#if META_CXX_INLINE_VARIABLES
2866 inline constexpr detail::for_each_fn
for_each{};
2876 constexpr auto &&
for_each = detail::static_const<detail::for_each_fn>::value;
2890 template <META_TYPE_CONSTRAINT(list_like) ListOfLists>
2898 template <
typename ListOfLists>
2910 template <META_TYPE_CONSTRAINT(invocable) Fn, META_TYPE_CONSTRAINT(list_like) ListOfLists>
2917 template <
typename Fn,
typename ListOfLists>
2929 template <META_TYPE_CONSTRAINT(list_like) ListOfLists>
2936 template <
typename ListOfLists>
2945 template <
typename T>
2950 template <
typename Sequence>
2951 struct as_list_ :
lazy::invoke<uncurry<quote<list>>, Sequence>
2960 template <
typename Sequence>
2967 template <
typename Sequence>
2976 template <
typename L,
typename State = list<>>
2977 struct reverse_ :
lazy::fold<L, State, quote<push_front>>
2981 template <
typename T0,
typename T1,
typename T2,
typename T3,
typename T4,
typename T5,
2982 typename T6,
typename T7,
typename T8,
typename T9,
typename... Ts,
2984 struct reverse_<list<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, Ts...>, list<Us...>>
2985 : reverse_<list<Ts...>, list<T9, T8, T7, T6, T5, T4, T3, T2, T1, T0, Us...>>
2995 template <META_TYPE_CONSTRAINT(list_like) L>
3002 template <
typename L>
3008 template <META_TYPE_CONSTRAINT(invocable) Fn>
3015 template <
typename Fn>
3026 template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
3033 template <
typename L,
typename Fn>
3044 template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
3051 template <
typename L,
typename Fn>
3062 template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
3069 template <
typename L, META_TYPE_CONSTRAINT(invocable) Fn>
3080 template <META_TYPE_CONSTRAINT(list_like) L,
typename T>
3087 template <
typename L,
typename T>
3096 template <
typename L>
3101 template <
typename... L>
3102 struct inherit_<list<L...>> : L...
3104 using type = inherit_;
3113 template <META_TYPE_CONSTRAINT(list_like) L>
3120 template <
typename L>
3129 template <
typename Set,
typename T>
3134 template <
typename... Set,
typename T>
3135 struct in_<list<Set...>, T> :
bool_<META_IS_BASE_OF(id<T>, inherit<list<id<Set>...>>)>
3139 template <
typename Set,
typename T>
3144 template <
typename... Set,
typename T>
3145 struct insert_back_<list<Set...>, T>
3147 using type =
if_<in_<list<Set...>, T>, list<Set...>, list<Set..., T>>;
3156 template <META_TYPE_CONSTRAINT(list_like) L>
3163 template <
typename L>
3172 template <
typename Fn>
3176 template <
typename,
typename>
3178 template <
typename,
typename,
typename =
void>
3183 template <
typename... Yes,
typename... No,
typename A>
3185 requires integral<invoke<Fn, A>>
3196 template <
typename State,
typename A>
3208 template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
3215 template <
typename L,
typename Fn>
3224 template <META_TYPE_CONSTRAINT(invocable) Fn,
typename A,
typename B,
typename... Ts>
3227 template <
typename L,
typename Fn>
3228 requires list_like<L> && invocable<Fn>
3230 template <
typename,
typename,
typename =
void>
3235 template <
typename Fn>
3236 struct sort_<list<>, Fn>
3238 using type = list<>;
3241 template <
typename A,
typename Fn>
3242 struct sort_<list<A>, Fn>
3244 using type = list<A>;
3247 template <
typename A,
typename B,
typename... Ts,
typename Fn>
3249 requires trait<sort_<
first<part_<Fn, A, B, Ts...>>, Fn>> &&
3250 trait<sort_<
second<part_<Fn, A, B, Ts...>>, Fn>>
3251 struct sort_<list<A, B, Ts...>, Fn>
3254 list<A, B, Ts...>, Fn,
3258 using P = part_<Fn, A, B, Ts...>;
3259 using type = concat<_t<sort_<first<P>, Fn>>, list<A>, _t<sort_<second<P>, Fn>>>;
3276 template <META_TYPE_CONSTRAINT(list_like) L, META_TYPE_CONSTRAINT(invocable) Fn>
3283 template <
typename L,
typename Fn>
3292 template <
typename T,
int = 0>
3295 template <
typename,
int = 0>
3298 template <
typename T,
int = 0>
3302 template <
typename If,
typename... Ts>
3309 template <
typename A,
typename T,
typename Fn,
typename Ts>
3314 template <
typename T,
typename Fn,
typename Ts>
3315 struct subst1_<Fn, T, Fn, Ts>
3317 using type = list<>;
3319 template <
typename A,
typename T,
typename Fn,
typename Ts>
3320 struct subst1_<vararg_<A>, T, Fn, Ts>
3322 using type = list<Ts>;
3325 template <
typename As,
typename Ts>
3328 concat<As, repeat_n_c<size<Ts>{} + 2 - size<As>{}, back<As>>>,
3329 concat<Ts, repeat_n_c<2, back<As>>>,
3330 bind_back<quote_trait<subst1_>, back<As>, drop_c<Ts, size<As>{} - 2>>>>,
3334 template <list_like As, list_like Ts>
3335 requires (_v<size<Ts>> + 2 >= _v<size<As>>)
3336 using substitutions = substitutions_<As, Ts>;
3338 template <
typename As,
typename Ts>
3339 using substitutions =
3340#ifdef META_WORKAROUND_MSVC_702792
3341 invoke<if_c<(size<Ts>::value + 2 >= size<As>::value), quote<substitutions_>>, As,
3344 invoke<if_c<(size<Ts>{} + 2 >= size<As>{}), quote<substitutions_>>, As, Ts>;
3348 template <
typename T>
3349 struct is_vararg_ : std::false_type
3352 template <
typename T>
3353 struct is_vararg_<vararg_<T>> : std::true_type
3357 template <META_TYPE_CONSTRAINT(list_like) Tags>
3358 using is_variadic_ = is_vararg_<at<push_front<Tags, void>, dec<size<Tags>>>>;
3360 template <META_TYPE_CONSTRAINT(list_like) Tags,
bool IsVariadic = is_variadic_<Tags>::value>
3364 template <
typename... As>
3365 struct lambda_<list<As...>, false>
3368 static constexpr std::size_t arity =
sizeof...(As) - 1;
3369 using Tags = list<As...>;
3370 using Fn = back<Tags>;
3371 template <
typename T, META_TYPE_CONSTRAINT(list_like) Args>
3373 template <
typename T, META_TYPE_CONSTRAINT(list_like) Args>
3374 using lazy_impl_ = lazy::_t<defer<impl, T, protect_<Args>>>;
3376 template <
typename, list_like>
3378 template <
typename,
typename,
typename =
void>
3383 template <
template <
typename...>
class C,
typename... Ts,
typename Args>
3385 requires valid<C, _t<impl<Ts, Args>>...>
struct subst_<defer<C, Ts...>, Args>
3387 struct subst_<defer<C, Ts...>, Args,
void_<C<
_t<impl<Ts, Args>>...>>>
3390 using type = C<_t<impl<Ts, Args>>...>;
3392 template <
typename T,
template <T...>
class C, T... Is,
typename Args>
3394 requires valid_i<T, C, Is...>
struct subst_<defer_i<T, C, Is...>, Args>
3396 struct subst_<defer_i<T, C, Is...>, Args,
void_<C<Is...>>>
3399 using type = C<Is...>;
3401 template <
typename T, META_TYPE_CONSTRAINT(list_like) Args>
3402 struct impl : if_c<(reverse_find_index<Tags, T>() != npos()),
3403 lazy::at<Args, reverse_find_index<Tags, T>>, id<T>>
3406 template <
typename T,
typename Args>
3407 struct impl<protect_<T>, Args>
3411 template <
typename T,
typename Args>
3412 struct impl<is_valid_<T>, Args>
3414 using type = is_trait<impl<T, Args>>;
3416 template <
typename If,
typename... Ts,
typename Args>
3417 struct impl<defer<
if_, If, Ts...>, Args>
3418 : impl<lazy_impl_<lazy_if_<If, Ts...>, Args>, Args>
3421 template <
typename B,
typename... Bs,
typename Args>
3422 struct impl<defer<
and_, B, Bs...>, Args>
3423 : impl<lazy_impl_<lazy_if_<B, lazy::and_<Bs...>, protect_<std::false_type>>, Args>,
3427 template <
typename B,
typename... Bs,
typename Args>
3428 struct impl<defer<
or_, B, Bs...>, Args>
3429 : impl<lazy_impl_<lazy_if_<B, protect_<std::true_type>, lazy::or_<Bs...>>, Args>,
3433 template <
template <
typename...>
class C,
typename... Ts,
typename Args>
3434 struct impl<defer<C, Ts...>, Args> : subst_<defer<C, Ts...>, Args>
3437 template <
typename T,
template <T...>
class C, T... Is,
typename Args>
3438 struct impl<defer_i<T, C, Is...>, Args> : subst_<defer_i<T, C, Is...>, Args>
3441 template <
template <
typename...>
class C,
typename... Ts,
typename Args>
3442 struct impl<C<Ts...>, Args> : subst_<defer<C, Ts...>, Args>
3445 template <
typename... Ts,
typename Args>
3446 struct impl<lambda_<list<Ts...>, false>, Args>
3448 using type = compose<
uncurry<lambda_<list<As..., Ts...>,
false>>,
3449 curry<bind_front<quote<concat>, Args>>>;
3451 template <
typename... Bs,
typename Args>
3452 struct impl<lambda_<list<Bs...>, true>, Args>
3454 using type = compose<
typename lambda_<list<As..., Bs...>,
true>::thunk,
3455 bind_front<quote<concat>, transform<Args, quote<list>>>,
3456 curry<bind_front<quote<substitutions>, list<Bs...>>>>;
3460 template <
typename... Ts>
3462 requires (
sizeof...(Ts) == arity)
using invoke =
_t<impl<Fn, list<Ts..., Fn>>>;
3464 using invoke =
_t<if_c<
sizeof...(Ts) == arity, impl<Fn, list<Ts..., Fn>>>>;
3470 template <
typename... As>
3471 struct lambda_<list<As...>, true>
3474 template <META_TYPE_CONSTRAINT(list_like) T,
bool IsVar>
3475 friend struct lambda_;
3476 using Tags = list<As...>;
3477 template <
typename T, META_TYPE_CONSTRAINT(list_like) Args>
3479 template <META_TYPE_CONSTRAINT(list_like) Args>
3480 using eval_impl_ = bind_back<quote_trait<impl>, Args>;
3481 template <
typename T, META_TYPE_CONSTRAINT(list_like) Args>
3482 using lazy_impl_ = lazy::_t<defer<impl, T, protect_<Args>>>;
3483 template <
template <
typename...>
class C, META_TYPE_CONSTRAINT(list_like) Args,
3484 META_TYPE_CONSTRAINT(list_like) Ts>
3485 using try_subst_ = apply<quote<C>, join<transform<Ts, eval_impl_<Args>>>>;
3487 template <
typename, list_like>
3489 template <
typename,
typename,
typename =
void>
3494 template <
template <
typename...>
class C,
typename... Ts,
typename Args>
3496 requires is_true<try_subst_<C, Args, list<Ts...>>>
struct subst_<defer<C, Ts...>, Args>
3498 struct subst_<defer<C, Ts...>, Args,
void_<try_subst_<C, Args, list<Ts...>>>>
3501 using type = list<try_subst_<C, Args, list<Ts...>>>;
3503 template <
typename T,
template <T...>
class C, T... Is,
typename Args>
3505 requires valid_i<T, C, Is...>
struct subst_<defer_i<T, C, Is...>, Args>
3507 struct subst_<defer_i<T, C, Is...>, Args,
void_<C<Is...>>>
3510 using type = list<C<Is...>>;
3512 template <
typename T, META_TYPE_CONSTRAINT(list_like) Args>
3513 struct impl : if_c<(reverse_find_index<Tags, T>() != npos()),
3514 lazy::at<Args, reverse_find_index<Tags, T>>, id<list<T>>>
3517 template <
typename T,
typename Args>
3518 struct impl<protect_<T>, Args>
3520 using type = list<T>;
3522 template <
typename T,
typename Args>
3523 struct impl<is_valid_<T>, Args>
3525 using type = list<is_trait<impl<T, Args>>>;
3527 template <
typename If,
typename... Ts,
typename Args>
3528 struct impl<defer<
if_, If, Ts...>, Args>
3529 : impl<lazy_impl_<lazy_if_<If, Ts...>, Args>, Args>
3532 template <
typename B,
typename... Bs,
typename Args>
3533 struct impl<defer<
and_, B, Bs...>, Args>
3534 : impl<lazy_impl_<lazy_if_<B, lazy::and_<Bs...>, protect_<std::false_type>>, Args>,
3538 template <
typename B,
typename... Bs,
typename Args>
3539 struct impl<defer<
or_, B, Bs...>, Args>
3540 : impl<lazy_impl_<lazy_if_<B, protect_<std::true_type>, lazy::or_<Bs...>>, Args>,
3544 template <
template <
typename...>
class C,
typename... Ts,
typename Args>
3545 struct impl<defer<C, Ts...>, Args> : subst_<defer<C, Ts...>, Args>
3548 template <
typename T,
template <T...>
class C, T... Is,
typename Args>
3549 struct impl<defer_i<T, C, Is...>, Args> : subst_<defer_i<T, C, Is...>, Args>
3552 template <
template <
typename...>
class C,
typename... Ts,
typename Args>
3553 struct impl<C<Ts...>, Args> : subst_<defer<C, Ts...>, Args>
3556 template <
typename... Bs,
bool IsVar,
typename Args>
3557 struct impl<lambda_<list<Bs...>, IsVar>, Args>
3560 list<compose<
typename lambda_<list<As..., Bs...>,
true>::thunk,
3561 bind_front<quote<concat>, Args>,
3562 curry<bind_front<quote<substitutions>, list<Bs...>>>>>;
3566 template <
typename S,
typename R = _t<impl<back<Tags>, S>>>
3568 requires (_v<size<R>> == 1)
using invoke = front<R>;
3570 using invoke = if_c<size<R>{} == 1, front<R>>;
3575 template <
typename... Ts>
3576 using invoke =
invoke<thunk, substitutions<Tags, list<Ts...>>>;
3590 template <
typename... Ts>
3592 requires (
sizeof...(Ts) > 0)
using lambda = detail::lambda_<list<Ts...>>;
3594 using lambda = if_c<(
sizeof...(Ts) > 0), detail::lambda_<
list<Ts...>>>;
3601 template <
typename T>
3607 template <
typename T>
3614 template <
typename T>
3621 template <
typename Tag,
typename Value>
3627 template <
typename...>
3631 template <
typename Fn>
3636 template <
typename Tag,
typename Value,
typename... Rest>
3637 struct let_<var<Tag, Value>, Rest...>
3639 using type = lazy::invoke<lambda<Tag, _t<let_<Rest...>>>, Value>;
3659 template <
typename... As>
3666 template <
typename... As>
3672 inline namespace placeholders
3697 template <
typename M2,
typename M>
3698 struct cartesian_product_fn
3700 template <
typename X>
3703 template <
typename Xs>
3704 using lambda1 = list<push_front<Xs, X>>;
3705 using type = join<transform<M2, quote<lambda1>>>;
3707 using type = join<transform<M, quote_trait<lambda0>>>;
3718 template <META_TYPE_CONSTRAINT(list_like) ListOfLists>
3726 template <
typename ListOfLists>
3738 template <
typename T>
3742 struct add_const_if<false>
3744 template <
typename T>
3749 using add_const_if_c = detail::add_const_if<If>;
3750 template <META_TYPE_CONSTRAINT(
integral) If>
3751 using add_const_if = add_const_if_c<If::type::value>;
3757 template <
bool If,
typename T>
3758 using const_if_c =
typename add_const_if_c<If>::template invoke<T>;
3759 template <
typename If,
typename T>
3760 using const_if =
typename add_const_if<If>::template invoke<T>;
3766 template <
typename State,
typename Ch>
3767 using atoi_ = if_c<(Ch::value >=
'0' && Ch::value <=
'9'),
3768 std::integral_constant<
typename State::value_type,
3769 State::value * 10 + (Ch::value -
'0')>>;
3773 inline namespace literals
3777 template <
char... Chs>
3778 constexpr fold<list<char_<Chs>...>,
meta::size_t<0>, quote<detail::atoi_>>