Compiler Explorer

Source code

#ifdef LAUNDER
template <unsigned long _Idx, unsigned long _Cnt>
struct ___m_at {
	static_assert(_Idx < _Cnt);
	static constexpr unsigned long value = _Idx + _Cnt * 0;
};

template <unsigned long _Np, class... _Ts>
using __m_at_c = _Ts...[___m_at<_Np, sizeof...(_Ts)>::value];
#else
template <unsigned long _Np, class... _Ts>
using __m_at_c = _Ts...[_Np];
#endif

template <class _Tp> auto(__declval)() -> _Tp &&;
template <class _Fun, class... _As>
concept __callable = requires(_Fun __fun, _As... __as) {
  __fun(__as...);
};
template <class...> struct __types;
template <class _Ty>
concept constructible_from = __is_constructible(_Ty);
template <class _Ty>
concept copy_constructible = constructible_from<_Ty>;
template <int> struct __mbool;
template <class, class _Up> using __msecond = _Up;
template <class> int __v;
template <long...> struct Trans_NS___pack___t;
template <long... _Is> using __indices = Trans_NS___pack___t<_Is...>;
template <class _Ty, _Ty... _Is> using __idx = __indices<_Is...>;
template <long _Np> using __make_indices = __make_integer_seq<__idx, long, _Np>;
using __msuccess = int;
template <class> __msuccess __ok_v;
template <class _Ty> using __ok_t = decltype(__ok_v<_Ty>);
template <class... _Args>
concept _Ok = (__is_same(__ok_t<_Args>, __msuccess) && ...);
template <bool> struct __i;
template <template <class> class _Fn, class... _Args>
using __meval = __i<_Ok<_Args...>>::template __g<_Fn, _Args...>;
template <class _Fn, class... _Args>
using __minvoke = __i<_Ok<_Args...>>::template __f<_Fn>::template __f<_Args...>;
template <> struct __i<true> {
  template <template <class> class _Fn, class... _Args>
  using __g = _Fn<_Args...>;
  template <class _Fn> using __f = _Fn;
};
template <template <class> class _Fn> struct __q {
  template <class... _Args>
  using __f = __i<_Ok<_Args...>>::template __g<_Fn, _Args...>;
};
template <template <class> class _Fn, class...> struct __mbind_back_q {
  template <class... _Args> using __f = __meval<_Fn, _Args...>;
};
template <template <class> class _Tp, class... _Args>
concept __mvalid = requires {
  typename __meval<_Tp, _Args...>;
};
template <class _Fn, class...>
concept __minvocable = __mvalid<_Fn::template __f>;
struct __if_ {
  template <int> struct __;
};
template <bool _Pred> using __if_c = __minvoke<__if_::__<_Pred>>;
template <class _Try, class> struct __mtry_catch {
  template <class... _Args>
  using __f = __minvoke<__if_c<__minvocable<_Try, _Args...>>>;
};
template <class...> struct __mcompose;
template <class _Second, class _First> struct __mcompose<_Second, _First> {
  template <class... _Args> using __f = __minvoke<__minvoke<_First, _Args...>>;
};
template <class _Ty> using __mfront_ = _Ty;
template <class... _As> using __mfront = __meval<__mfront_, _As...>;
template <class _Fun, class... _As>
using __call_result_t = decltype(__declval<_Fun>()(__declval<_As>()...));
template <int> struct __mfind_if_ {
  template <class _Fn, class, class _Head>
  using __f = __minvoke<__if_c<__v<__minvoke<_Fn, _Head>>>>;
};
template <class _Fn, class _Continuation = __q<__types>> struct __mfind_if {
  template <class... _Args>
  using __f = __minvoke<__mfind_if_<0>, _Fn, _Continuation, _Args...>;
};
template <class _Continuation = __q<__types>> struct __mpop_back {
  template <class> struct __impl;
  template <long... _Idx> struct __impl<__indices<_Idx...>> {
    template <class... _Ts>
    using __f = __minvoke<_Continuation, __m_at_c<_Idx, _Ts...>...>;
  };
  template <class... _Ts>
  using __f = __minvoke<__impl<__make_indices<sizeof...(_Ts)>>, _Ts...>;
};
using __1 = int;
template <class> struct __mdispatch_;
template <class _Ret, class... _Args>
struct __mdispatch_<_Ret (*)(_Args......)> {
  template <class... _Ts>
  auto operator0() -> __msecond<
      __if_c<sizeof...(_Ts)>,
      __call_result_t<__mdispatch_<__minvoke<__mpop_back<>, _Args...>>,
                      _Ts...>>;
};
template <class> struct __mdispatch;
template <class _Ret, class... _Args>
struct __mdispatch<_Ret(_Args......)> : __mdispatch_<_Ret (*)(_Args......)> {};
template <class _Ty>
concept __dispatchable = __callable<__mdispatch<_Ty>>;
template <class _Signature>
using __try_dispatch_ = __mbool<__dispatchable<_Signature>>;
template <class, class = __q<__mfront>> struct __which;
template <template <class> class _Cp, class... _Signatures, class _Continuation>
struct __which<_Cp<_Signatures...>, _Continuation> {
  template <class... _Args>
  using __f = __minvoke<__mfind_if<__mbind_back_q<__try_dispatch_, _Args...>>,
                        _Signatures...>;
};
template <class _Signatures, class _DefaultFn>
using __make_dispatcher =
    __minvoke<__mtry_catch<__mcompose<__q<__mdispatch>, __which<_Signatures>>,
                           _DefaultFn>>;
struct __none_such;
namespace __rcvrs {
struct set_value_t;
}
using __rcvrs::set_value_t;
namespace __tag_invoke {
struct tag_invoke_t;
}
using __tag_invoke::tag_invoke_t;
namespace __detail {
struct __sexpr_apply_t {
  template <class _Sender, class _ApplyFn>
  auto operator()(_Sender __sndr, _ApplyFn __fun)
      -> decltype(__sndr.apply(__sndr, __fun));
};
template <class _Tag, class> struct __desc {
  template <class _Fn> using __f = __minvoke<_Fn, _Tag>;
};
} // namespace __detail
using __detail::__sexpr_apply_t;
template <class _Tag> using __legacy_c11n_for = _Tag::__legacy_customizations_t;
template <class _Tag>
using __legacy_c11n_fn =
    __make_dispatcher<__legacy_c11n_for<_Tag>, __none_such>;
template <class _Tag>
concept __has_legacy_c11n = __callable<__legacy_c11n_fn<_Tag>>;
struct __legacy_customization {
  template <class _Tag, class _Data>
  requires __has_legacy_c11n<_Tag>
  auto operator()(_Tag, _Data);
};
struct default_domain {
  template <class _Sender> void transform_sender(_Sender) {
    __callable<__sexpr_apply_t, _Sender, __legacy_customization>;
  }
};
namespace __detail {
template <class _Sender> using __completion_domain_or_none = _Sender;
template <class _Sender>
concept __consistent_completion_domains =
    __mvalid<__completion_domain_or_none, _Sender>;
} // namespace __detail
template <class _Sender>
concept sender = __detail::__consistent_completion_domains<_Sender>;
namespace __detail {
template <class _Sender>
using __impl_of = decltype(__declval<_Sender>().__impl_);
}
template <class _Descriptor, auto _DescriptorFn = [] { return _Descriptor(); }>
auto __descriptor_fn_v = _DescriptorFn;
namespace __detail {
template <class _Tag> auto __captures(_Tag) {
  return []<class _Cvref, class _Fun>(
             _Cvref, _Fun) -> __call_result_t<_Fun, _Tag, _Tag> {};
}
template <class _Tag> using __captures_t = decltype(__captures(_Tag()));
} // namespace __detail
template <auto _DescriptorFn> struct __sexpr {
  using __desc_t = decltype(_DescriptorFn());
  using __captures_t = __minvoke<__desc_t, __q<__detail::__captures_t>>;
  __captures_t __impl_;
  template <class _Tag, class _Data> __sexpr(_Tag, _Data);
  template <class _Sender, class _ApplyFn>
  auto apply(_Sender, _ApplyFn)
      -> __call_result_t<__detail::__impl_of<_Sender>, _Sender, _ApplyFn>;
};
template <class _Tag, class _Data>
using __sexpr_t = __sexpr<__descriptor_fn_v<__detail::__desc<_Tag, _Data>>>;
namespace __detail {
template <class _Tag> struct __make_sexpr_t {
  template <class _Data> auto operator()(_Data __data) {
    return __sexpr_t<_Tag, _Data>{_Tag(), __data};
  }
};
} // namespace __detail
template <class _Tag> __detail::__make_sexpr_t<_Tag> __make_sexpr;
struct {
  template <class _Domain, class _Sender>
  void operator()(_Domain __dom, _Sender __sndr) {
    __dom.transform_sender(__sndr);
  }
} transform_sender;
template <class _Scheduler>
concept scheduler = copy_constructible<_Scheduler>;
namespace __when_all {
struct transfer_when_all_t {
  using _Sender = __1;
  using __legacy_customizations_t =
      __types<tag_invoke_t(set_value_t, _Sender...)>;
  template <scheduler _Scheduler, sender... _Senders>
  void operator()(_Scheduler, _Senders... __sndrs) {
    auto __domain = default_domain();
    transform_sender(__domain, __make_sexpr<transfer_when_all_t>(__sndrs...));
  }
};
} // namespace __when_all
using __when_all::transfer_when_all_t;
transfer_when_all_t transfer_when_all;
using inline_scheduler = int;
auto tag_invoke() { transfer_when_all(inline_scheduler{}, inline_scheduler{}); }