Compiler Explorer

Source code

template <class> struct a {};
namespace b {
template <class ah> void ai(ah...);
template <class aj, class... ah> decltype(aj()(ah()...)) ai(aj, ah...);
template <class, class aj, class... ah> struct ak {
  template <class aa, class... ab> static decltype(ai(aa(), ab()...)) ac();
  using ad = decltype(ac<aj, ah...>);
};
template <class aj, class... ah>
struct ae : a<typename ak<void, aj, ah...>::ad> {};
template <class af, class... ah> using ag = ae<af, ah...>;
template <class af, class... ah> ag<af, ah...> an(af, ah...);
template <class af, class... ah>
concept at = requires(af al, ah... am) { an(al, am...); };
} // namespace b
namespace ao {
template <class c> c &&i();
template <class ap> using aq = ap;
struct ar {
  template <class c> using as = c;
};
template <class> ar bc;
template <class c> using au = decltype(bc<c>);
template <class...>
concept av = requires { 0; };
template <class...> struct aw;
template <class...>
concept ax = requires { typename aw<>; };
template <class ay, class d>
concept az = __is_same(ay, d);
template <class ap, class... ba>
concept bb = (az<ap, ba> || ...);
struct bl {};
struct bd {
  bd(auto);
};
struct be;
template <class c> using bf = c::bf;
template <auto bg> using bh = decltype(bg);
template <class, class e> using bi = e;
using bj = int;
template <class bk>
concept bq = az<bk, bj>;
template <class... ah>
concept bm = (bq<ah> && ...);
template <bool> struct f;
template <template <class...> class af, class... ah>
using g = f<bm<ah...>>::template bn<af, ah...>;
template <class af, class... ah> using bo = f<bm<af>>::template bt<af, ah...>;
template <bool> struct f {
  template <template <class...> class af, class... ah> using bn = af<ah...>;
  template <class af, class... ah> using bt = g<af::template as, ah...>;
};
template <template <class...> class af> struct bp {
  template <class... ah> using as = g<af, ah...>;
};
template <template <class> class c, class... ah>
concept br = requires { typename g<c, ah...>; };
template <class af, class... ah>
concept bs = br<af::template as, ah...>;
struct bu {
  template <int> struct bl {
    template <class bv, class...> using as = bv;
  };
};
template <> struct bu::bl<false> {
  template <class, class bw> using as = bw;
};
template <bool bx, class bv = void, class... bw>
using by = bo<bu::bl<bx>, bv, bw...>;
template <class c> struct bz {
  template <class...> using as = c;
};
struct h {
  template <class...> using as = int;
};
template <class ca, class cb> struct cc {
  template <class... ah> using as = bo<by<bs<ca, ah...>, ca, cb>, ah...>;
};
template <class af, class cd> using ce = cc<af, bz<cd>>;
template <class...> struct cf;
template <class cg, template <class...> class ay, template <class...> class d>
struct cf<cg, ay<>, d<>> {
  using bf = bo<cg>;
};
template <class cg> struct ch {
  template <class... ah> using as = bf<cf<cg, ah...>>;
};
template <class, class cg> struct j {
  template <class... ah> using as = bo<ch<cg>, by<az<ah, int>, aw<>, aw<>>...>;
};
template <class k, class... ba> using l = decltype(i<k>()(i<ba>()...));
template <auto k, class... ba> using m = l<decltype(k), ba...>;
namespace n {
struct p;
struct o;
} // namespace n
using n::o;
using n::p;
template <class r>
concept ci = bb<r, p, o>;
namespace q {
struct cj;
struct ck {};
} // namespace q
using q::cj;
using q::ck;
extern cj u;
template <class s> using v = l<cj, s>;
namespace w {
template <ci> struct x {};
} // namespace w
using w::x;
namespace y {
struct z;
}
using y::z;
namespace cl {
struct cq;
}
using cl::cq;
namespace cm {
struct cn {
  template <class co, class cu>
  auto operator()(co cp, cu cw) -> decltype(cp.apply(cp, cw)) {}
};
} // namespace cm
using cm::cn;
cn cr;
} // namespace ao
namespace ao::cs {
template <class ay, class d>
concept t = az<d, ay>;
}
namespace ao {
using namespace cs;
template <class... ba>
concept ct = __is_constructible(ba...);
template <class>
concept cv = ct<>;
template <class ap>
concept db = ct<ap>;
namespace cx {
template <class r, class... ah> using cy = decltype(cz(i<r>(), i<ah>()...));
}
using cx::cy;
namespace w {
struct da {
  template <class df, class dc, class cd> auto operator()(df, dc, cd &&) -> cd;
};
struct dd {
  template <class ap> auto operator()(ap) -> cy<dd, ap>;
};
} // namespace w
using w::da;
using w::dd;
dd de;
template <class r, class dc, class cd> using dj = l<da, r, dc, cd>;
namespace q {
struct cj {
  template <class s> auto operator()(s) -> cy<cj, s>;
  template <class s> ck operator()(s) const;
};
template <class bg, class r> struct dk {
  dk(bg, r);
  template <bb<r> dg> friend auto cz(dg, dk) -> bg {}
};
struct {
  template <class dh> dh operator()(dh, ck);
} di;
} // namespace q
namespace cm {
template <class co> using __impl_of = decltype(i<co>().__impl_);
template <class r> struct dl {
  using dm = r;
};
struct dn {
  template <class r, class _Data, class _Child>
  auto operator()(r, _Data, _Child) -> bo<bp<dl>, r>;
};
template <class co, class> using __sexpr_uncurry = l<__impl_of<co>, au<co>, dn>;
template <class co> using __desc_of = __sexpr_uncurry<co, bp<dl>>;
} // namespace cm
template <class co> using tag_of_t = cm::__desc_of<co>::dm;
template <class> struct __sexpr_impl;
namespace cm {
auto __get_attrs = [](bd, auto... __child) { return u(__child...); };
auto __drop_front = []<class af>(af) {
  return []<class... _Rest>(auto, _Rest...) -> l<af, _Rest...> {};
};
} // namespace cm
template <class r>
using __get_attrs_fn = m<cm::__drop_front, bh<__sexpr_impl<r>::get_attrs>>;
template <class...> struct __sexpr;
template <class _ImplFn> struct __sexpr<_ImplFn> {
  using __tag_t = l<_ImplFn, ar, cm::dn>::dm;
  _ImplFn __impl_;
  template <t<cj> r, t<__sexpr> _Self>
  friend auto cz(r, _Self)
      -> bi<by<t<_Self, __sexpr>>, m<cr, _Self, __get_attrs_fn<__tag_t>>> {}
  template <class co, class cu>
  auto apply(co, cu) -> l<cm::__impl_of<co>, au<co>, cu>;
};
template <class _ImplFn> __sexpr(_ImplFn) -> __sexpr<_ImplFn>;
namespace cm {
template <class> struct __make_sexpr_t {
  template <class _Data, class... _Child>
  constexpr auto operator()(_Data, _Child...) const;
};
auto __make_tuple = []<class r, class... _Captures>(r, _Captures...) {
  return []<class _Cvref, class k>(_Cvref,
                                   k) -> l<k, r, bo<_Cvref, _Captures>...> {};
};
template <class r>
template <class _Data, class... _Child>
constexpr auto __make_sexpr_t<r>::operator()(_Data __data,
                                             _Child... __child) const {
  return __sexpr{__make_tuple(r(), __data, __child...)};
}
template <class r> __make_sexpr_t<r> __make_sexpr;
} // namespace cm
using cm::__make_sexpr;
template <class co>
concept sender_expr = br<tag_of_t, co>;
template <class co, class r>
concept sender_expr_for = t<tag_of_t<co>, r>;
struct default_domain {
  template <class co> auto transform_sender(co cp) { return cp; }
  template <class co, class dh> auto transform_sender(co cp, dh q) {
    return tag_of_t<co>().transform_sender(cp, q);
  }
};
namespace cm {
template <class> using __completion_domain_or_none = int;
template <class co>
concept __consistent_completion_domains = br<__completion_domain_or_none, co>;
} // namespace cm
struct __get_early_domain_t {
  template <class co, class cd> auto operator()(co, cd) {
    return l<dd, v<co>>();
  }
};
template <class co, class cd = default_domain>
using __early_domain_of_t = l<__get_early_domain_t, co, cd>;
struct __get_late_domain_t {
  template <class co, class dh> auto operator()(co, dh) {
    return default_domain();
  }
};
template <class co, class dh>
using __late_domain_of_t = l<__get_late_domain_t, co, dh>;
namespace __compl_sigs {
template <class>
concept __completion_signature = ax<>;
}
template <__compl_sigs::__completion_signature...> struct completion_signatures;
namespace __compl_sigs {
template <class _TaggedTuple, ci r>
auto __as_tagged_tuple_(r(), _TaggedTuple *) -> bz<bo<_TaggedTuple, r>>;
template <class _Sig, class _TaggedTuple>
using __as_tagged_tuple =
    decltype(__as_tagged_tuple_((_Sig *)nullptr, (_TaggedTuple *)nullptr));
template <class _TaggedTuple, class _Variant, class... _Sigs>
auto __for_all_sigs_(completion_signatures<_Sigs...> *, _TaggedTuple *,
                     _Variant *)
    -> bz<bo<_Variant, bo<__as_tagged_tuple<_Sigs, _TaggedTuple>>...>>;
template <class _Completions, class _TaggedTuple, class _Variant>
using __for_all_sigs = bo<decltype(__for_all_sigs_(
    (_Completions *)nullptr, (_TaggedTuple *)nullptr, (_Variant *)nullptr))>;
template <class _Completions, class _TaggedTuple, class _Variant>
using __maybe_for_all_sigs =
    g<__for_all_sigs, _Completions, _TaggedTuple, _Variant>;
} // namespace __compl_sigs
template <class co, class dh> using __completion_signatures_of_t = l<z, co, dh>;
template <class _Receiver>
concept receiver = cv<_Receiver>;
struct dependent_domain {
  template <sender_expr co, class dh>
    requires t<__early_domain_of_t<co>, dependent_domain>
  decltype(auto) transform_sender(co &&, const dh &) const;
};
namespace __domain {
struct __transform_sender_1 {
  template <class _Domain, class co, class... dh>
  auto operator()(_Domain, co cp, dh... q) {
    return default_domain().transform_sender(cp, q...);
  }
};
struct __transform_sender {
  template <class _Domain, class co, class... dh>
  auto operator()(_Domain __dom, co cp, dh... q) {
    return __transform_sender_1()(__dom, cp, q...);
  }
};
struct __transform_dependent_sender {
  template <class _Domain, sender_expr co, class dh>
  auto operator()(_Domain, co cp, dh q) {
    return dependent_domain().transform_sender(cp, q);
  }
};
} // namespace __domain
struct transform_sender_t : __domain::__transform_sender,
                            __domain::__transform_dependent_sender {
  using __transform_sender::operator();
  using __transform_dependent_sender::operator();
};
template <class _Domain, class co, class... dh>
using transform_sender_result_t = l<transform_sender_t, _Domain, co, dh...>;
int transform_env;
template <sender_expr co, class dh>
  requires t<__early_domain_of_t<co>, dependent_domain>
decltype(auto) dependent_domain::transform_sender(co &&cp, const dh &) const {
  auto __env2 = transform_env;
  return cr(cp, [&]<class r, class _Data, class... _Childs>(
                    r, _Data __data, _Childs... __childs) {
    auto __sndr2 = __make_sexpr<r>(
        __data, __domain::__transform_sender()(this, __childs, __env2)...);
    return __sndr2;
  });
}
namespace y {
template <class co, class dh>
using __tfx_sender = transform_sender_result_t<__late_domain_of_t<co, dh>, co>;
template <class co, class dh>
using __member_alias_t = aq<__tfx_sender<co, dh>>::completion_signatures;
template <class co, class> auto __impl() {
  return (__member_alias_t<co, int>(*)()) nullptr;
}
struct z {
  template <class co, class dh>
  auto operator()(co, dh) -> decltype(__impl<co, dh>()());
};
} // namespace y
template <class co>
concept sender = cm::__consistent_completion_domains<co>;
template <class r> struct __select_completions_for {
  template <t<r>> using as = int;
};
template <class r, class>
using __select_completions_for_or = ce<__select_completions_for<r>, bl>;
template <class r, class _Completions>
using __only_gather_signal =
    __compl_sigs::__maybe_for_all_sigs<_Completions,
                                       __select_completions_for_or<r, r>,
                                       j<bl, bp<completion_signatures>>>;
template <class r, class _Completions, class _Tuple, class _Variant>
using __gather_signal =
    __compl_sigs::__maybe_for_all_sigs<__only_gather_signal<r, _Completions>,
                                       _Tuple, _Variant>;
template <class r, class co, class dh, class _Tuple, class _Variant>
using __gather_completions_for =
    g<__gather_signal, r, __completion_signatures_of_t<co, dh>, _Tuple,
      _Variant>;
namespace cl {
template <class co, class _Receiver>
using __tfx_sender =
    transform_sender_result_t<__late_domain_of_t<co, _Receiver>, co, _Receiver>;
template <class co, class _Receiver>
concept __connectable_with_co_await = av<__tfx_sender<co, _Receiver>>;
template <class co, class> constexpr void __select_impl() {
  __connectable_with_co_await<co, int>;
}
template <class co, class _Receiver>
using __select_impl_t = decltype(__select_impl<co, _Receiver>);
struct cq {
  template <sender co, receiver _Receiver>
  auto operator()(co, _Receiver) -> l<__select_impl_t<co, _Receiver>>;
};
} // namespace cl
template <class, class>
concept __sender_adaptor_closure_for = av<>;
template <sender co, __sender_adaptor_closure_for<co> _Closure>
l<_Closure, co> operator|(co, _Closure);
template <class k, class... ba> struct Trans_NS___closure___binder_back {
  template <sender co> l<k, co, ba...> operator()(co);
};
template <class, class = dependent_domain> struct __let_t;
template <class, class, class, class> using __result_sender_fn = int;
template <class co, class _Set> using __completion_sched = dj<x<_Set>, co, be>;
template <class> using __try_common_domain_fn = h;
template <class _Set, class _Child, class k, class dh, class _Sched>
using __result_domain_t =
    __gather_completions_for<_Set, _Child, dh,
                             __result_sender_fn<k, _Set, dh, _Sched>,
                             __try_common_domain_fn<_Set>>;
template <class _LetTag, class dh> auto __mk_transform_sender_fn(dh) {
  using _Set = bf<_LetTag>;
  return []<class k, class _Child>(bd, k, _Child) {
    using _Sched = __completion_sched<_Child, _Set>;
    using _Domain = __result_domain_t<_Set, _Child, k, dh, _Sched>;
    return __make_sexpr<_Domain>;
  };
}
template <class, class> struct __let_t {
  using bf = o;
  template <sender co, db k> auto operator()(co cp, k cw) {
    return __make_sexpr<__let_t>(cw, cp);
  }
  template <class k> Trans_NS___closure___binder_back<__let_t, k> operator()(k);
  template <sender_expr_for<__let_t> co, class dh>
  auto transform_sender(co cp, dh q) {
    auto __trans_tmp_1 = __mk_transform_sender_fn<__let_t>(q);
    return cr(cp, __trans_tmp_1);
  }
};
template <class _Domain> struct __let_impl {
  static constexpr auto get_attrs = []<class _Child>(bd, _Child __child) {
    return q::di(q::dk(_Domain(), de), u(__child));
  };
};
__let_t<int> let_error;
template <class _Set, class _Domain>
struct __sexpr_impl<__let_t<_Set, _Domain>> : __let_impl<_Domain> {};
namespace __stopped_as_xxx {
struct stopped_as_optional_t {
  template <sender co> auto operator()(co cp) {
    return __make_sexpr<stopped_as_optional_t>(bl(), cp);
  }
};
} // namespace __stopped_as_xxx
using __stopped_as_xxx::stopped_as_optional_t;
stopped_as_optional_t stopped_as_optional;
template <> struct __sexpr_impl<stopped_as_optional_t> {
  static constexpr auto get_attrs = cm::__get_attrs;
};
} // namespace ao
namespace ex = ao;
using ex::ck;
struct fallible_just {
  using completion_signatures = ex::completion_signatures<ex::p(), ex::o()>;
};
template <class = ck> struct expect_error_receiver {};
void C_A_T_C_H_T_E_S_T_10() {
  auto in_snd = fallible_just{} | ex::let_error(int{});
  auto snd = in_snd | ex::stopped_as_optional;
  b::at<ex::cq, decltype(snd), expect_error_receiver<>>;
}