Compiler Explorer

Source code

template <class _From, class _To>
inline constexpr bool is_convertible_v = __is_convertible0;

template <class _Bp, class _Dp>
inline constexpr bool is_base_of_v = __is_base_of0;

namespace std {
template <class _Dp, class _Bp>
concept derived_from = is_base_of_v<_Bp, _Dp> && is_convertible_v<const volatile _Dp*, const volatile _Bp*>;

template <class _Tp>
_Tp&& __declval() noexcept;

template <class _Ty>
using __decay_t = __decay(_Ty);

struct __cp {
  template <class _Tp>
  using __f = _Tp&&;
};

template <class>
extern __cp __cpcvr;

template <class _Tp>
using __copy_cvref_fn = decltype(__cpcvr<_Tp>);

template <class _Fun, class... _As>
concept __callable = requires(_Fun&& __fun, _As&&... __as) {
  __fun( __as...);
};

template <class... _Ts>
concept __typename = requires {};

template <class _Ap, class _Bp>
concept __same_as = __is_same(_Ap, _Bp);

template <class...>
concept __true = true;

template <class _Cp>
concept __class = __true<> && !__same_as<const _Cp, _Cp>;

template <class _Ty, class... _As>
concept __one_of = (__same_as<_Ty, _As> || ...);

struct __ ;

struct __ignore {
  constexpr __ignore(auto&&...) noexcept ;
};

struct __none_such ;

template <class _Tp>
using __t = typename _Tp::__t;

template <auto _Value>
using __mtypeof = decltype(_Value);

template <class _Tp, class _Up>
using __msecond = _Up;

using __msuccess = int;

template <class>
extern __msuccess __ok_v;

template <class _Ty>
using __ok_t = decltype(__ok_v<_Ty>);

template <class _Arg>
concept __ok = __same_as<__ok_t<_Arg>, __msuccess>;

template <class... _Args>
concept _Ok = (__ok<_Args> && ...);

template <bool _AllOK>
struct __i;

template <template <class...> class _Fn, class... _Args>
using __meval = typename __i<_Ok<_Args...>>::template __g<_Fn, _Args...>;

template <class _Fn, class... _Args>
using __minvoke = typename __i<_Ok<_Fn>>::template __h<_Fn, _Args...>;

template <bool _AllOK>
struct __i {
  template <template <class...> class _Fn, class... _Args>
  using __g = _Fn<_Args...>;
  
  template <class _Fn, class... _Args>
  using __h = __meval<_Fn::template __f, _Args...>;
};

template <template <class...> class _Fn>
struct __q {
  template <class... _Args>     using __f = __meval<_Fn, _Args...>;
};

template <template <class...> class _Tp, class... _Args>
concept __mvalid = requires {};

template <class _Fn, class... _Args>
concept __minvocable = __mvalid<_Fn::template __f, _Args...>;

struct __if_ {
  template <int >
  struct __ {
    template <class _True, class...>
    using __f = _True;
  };
};

template <bool _Pred, class _True = void, class... _False> 
  requires(sizeof..._False <= 1)
using __if_c = __minvoke<__if_::__<_Pred>, _True, _False...>;

template
struct __mtry_catch ;

template <class _Fn, class _Default>
using __with_default = __mtry_catch;

template
struct __mcompose ;

template <class _Old, class _Continuation = __q>
struct __remove ;

template <class _Return>
struct __qf ;

template <class _Fun, class... _As>
using __call_result_t = decltype(__declval<_Fun>()(__declval<_As>()...));

template <const auto& _Fun, class... _As>
using __result_of = __call_result_t<decltype(_Fun), _As...>;

template <class _Ty>
using __cref_t = decltype(int{}0);

struct set_value_t;
struct set_error_t;
struct set_stopped_t;

template <class _Tag>
concept __completion_tag = __one_of<_Tag, set_value_t, set_error_t, set_stopped_t>;

struct get_env_t;

template <class _EnvProvider>
using env_of_t = __call_result_t<get_env_t, _EnvProvider>;

template <__completion_tag _CPO>
struct get_completion_scheduler_t;

struct sender_t;

namespace __detail {
  struct __sexpr_apply_t;
}

extern const __sexpr_apply_t __sexpr_apply;

template <class _Ap, class _Bp>
concept same_as = __same_as<_Ap, _Bp> && __same_as<_Bp, _Ap>;

template <class _Ty>
concept destructible = __is_nothrow_destructible(_Ty);

template <class _Ty, class... _As>
concept constructible_from = destructible<_Ty> && __is_constructible(_Ty, _As...);

template <class _Ty>
concept move_constructible = constructible_from<_Ty, _Ty>;

template <class _Ty>
concept __movable_value = move_constructible<__decay_t<_Ty>> && constructible_from<__decay_t<_Ty>, _Ty>;

template <class _Tag, class... _Args>
concept tag_invocable = requires {};

template <class _Tag, class... _Args>
using tag_invoke_result_t = decltype(tag_invoke(__declval<_Tag>(), __declval<_Args>()...));

struct get_domain_t {
  template <class _Ty> 
    requires tag_invocable<get_domain_t, const _Ty&>
  constexpr auto operator()(const _Ty& __ty) const noexcept
    -> tag_invoke_result_t<get_domain_t, const _Ty&> 
};

inline constexpr get_domain_t get_domain;

template <class _Tag, class _Queryable, class _Default>
using __query_result_or_t = __call_result_t<int, _Tag, _Queryable, _Default>;

struct get_env_t {
  template <class _EnvProvider>
    requires tag_invocable<get_env_t, const _EnvProvider&>
  inline constexpr auto operator()(const _EnvProvider& __env_provider) const noexcept
    -> tag_invoke_result_t<get_env_t, const _EnvProvider&> ;
};

template <class _Value, class _Tag, class... _Tags>
struct __with {
  constexpr explicit __with(_Value __value, _Tag, _Tags...) noexcept0 : __value_0 ;
  
  template <__one_of<_Tag, _Tags...> _Key>
  friend auto tag_invoke(_Key, const __with& __self) noexcept -> _Value {}
};

template <class _Second, class _First>
struct __joined : _Second {
  _First __env_;

template <class _Tag>
    requires tag_invocable<_Tag, const _First&>
  friend auto tag_invoke(_Tag, const __joined& __self) noexcept 
    -> tag_invoke_result_t<_Tag, const _First&> {}
};

struct __fwd_fn {};

struct __join_fn {
  template <class First, class... Rest> 
  decltype(auto) operator()(First&& first, int&&... rest) const {
    return __joined{__fwd_fn(),  first};
  }
};

inline constexpr __join_fn __join;

template <class _EnvProvider>
concept environment_provider =     requires {};

namespace __detail {

template <class _Sender>
using __impl_of = decltype(__declval<_Sender>().__impl_);

template <class _Tag, class _Data, class... _Child>
struct __desc {
  using __tag = _Tag;
};

template <class _Fn>
struct __sexpr_uncurry_fn {
  template <class _Tag, class _Data, class... _Child>
    requires __minvocable<_Fn, _Tag, _Data, _Child...>
  constexpr auto operator()(_Tag, _Data&&, _Child&&...) const noexcept 
    -> __minvoke<_Fn, _Tag, _Data, _Child...>;
};

template <class _Sender, class _Fn>
using __sexpr_uncurry = __call_result_t<__impl_of<_Sender>, __copy_cvref_fn<_Sender>, __sexpr_uncurry_fn<_Fn>>;

template <class _Sender>
using __desc_of = __sexpr_uncurry<_Sender, __q<__desc>>;

using __get_desc = __sexpr_uncurry_fn<__q<__desc>>;

} // namespace __detail

template <class _Sender>
using tag_of_t = typename __detail::__desc_of<_Sender>::__tag;

template <class _Tag>
struct __sexpr_impl;

inline constexpr auto __drop_front = []<class _Fn>(_Fn __fn) noexcept {
  return []<class... _Rest>(auto&&, _Rest&&... __rest) noexcept
           -> __call_result_t<const _Fn&, _Rest...> {};
};

template <class _Tag>
using __get_attrs_fn =     __result_of<__detail::__drop_front, __mtypeof<__sexpr_impl<_Tag>::get_attrs>>;

template <class _ImplFn>
struct __sexpr {
  using __desc_t = __call_result_t<_ImplFn, __cp, __detail::__get_desc>;
  using __tag_t = typename __desc_t::__tag;
  
  mutable _ImplFn __impl_;
  
  template <same_as _Tag, same_as _Self>
  inline friend auto tag_invoke(_Tag, const _Self& __self) noexcept
    -> __msecond<__if_c<same_as<_Tag, get_env_t> && same_as<_Self, __sexpr>>, __result_of<__sexpr_apply, const _Self&, __get_attrs_fn<__tag_t>>>;
  
  template <class _Sender, class _ApplyFn>
  inline static auto apply( _Sender&& __sndr, _ApplyFn&& __fun) noexcept
    -> __call_result_t<__detail::__impl_of<_Sender>, __copy_cvref_fn<_Sender>, _ApplyFn> ;
};

namespace __detail

template <class _Tag>
struct __make_sexpr_t {
  template <class _Data = __, class... _Child>
  constexpr auto operator()(_Data __data, _Child... __child) const;

constexpr auto __make_tuple = []<class _Tag, class... _Captures>(_Tag, _Captures&&... __captures) {
    return []<class _Cvref, class _Fun>(_Cvref, _Fun && __fun) mutable noexcept -> __call_result_t<_Fun, _Tag, __minvoke<_Cvref, _Captures>...>                    requires __callable<_Fun, _Tag, __minvoke<_Cvref, _Captures>...>           {};
  };
};

template <class _Tag>
template <class _Data, class... _Child>
constexpr auto __make_sexpr_t<_Tag>::operator()(_Data __data, _Child... __child) const {
  return __sexpr{
    __make_tuple(_Tag(),  __data,  __child...)};
};

template <class _Tag>
inline constexpr __make_sexpr_t<_Tag> __make_sexpr;

namespace __detail {
struct __sexpr_apply_t {
  template <class _Sender, class _ApplyFn> 
  inline auto operator()(_Sender&& __sndr, _ApplyFn&& __fun) const noexcept 
    -> decltype( __sndr.apply( __sndr ,  __fun)) 
};

template <class _Sender>
concept sender_expr = __mvalid<tag_of_t, _Sender>;

template <class _Sender, class _Tag>
concept sender_expr_for = sender_expr<_Sender> && same_as<tag_of_t<_Sender>, _Tag>;

struct default_domain {
  template <class _Sender>
  inline decltype(auto) transform_sender(_Sender&& __sndr) const {
    return static_cast<>( __sndr);
  }

template <class _Sender, class _Env>
  void transform_sender(_Sender&& __sndr, const _Env& __env) const {
    tag_of_t<_Sender>().transform_sender( __sndr, __env);
  }

namespace __detail

template <class _Sender>
using __completion_domain_or_none = __t;

template <class _Sender>
concept __consistent_completion_domains = __mvalid<__completion_domain_or_none, _Sender>;

inline constexpr struct __get_early_domain_t {
  template <class _Sender, class _Default = default_domain>
  auto operator()(const _Sender&, _Default __def = {}) const noexcept {
    return __call_result_t<get_domain_t, env_of_t<_Sender>>();
    return __def;
  }
} __get_early_domain;

template <class _Sender, class _Default = default_domain>
using __early_domain_of_t = __call_result_t<__get_early_domain_t, _Sender, _Default>;

inline constexpr struct __get_late_domain_t {
  template <class _Sender, class _Env>
  auto operator()(const _Sender& __sndr, const _Env& __env) const noexcept {
    return default_domain();
  }
};

template <class _Sender, class _Env>
using __late_domain_of_t = __call_result_t<__get_late_domain_t, _Sender, _Env>;

namespace stdexec {
namespace __compl_sigs {

template <class _Sig>
concept __completion_signature = __typename<>;

} // namespace __compl_sigs

template <__compl_sigs::__completion_signature... _Sigs>
struct completion_signatures {

namespace __compl_sigs

template <class _TaggedTuple, class _Variant, class... _Sigs>
void  __for_all_sigs_() -> __mconst;

template <class _Completions, class _TaggedTuple, class _Variant>
using __for_all_sigs = __minvoke<decltype(__compl_sigs::__for_all_sigs_(nullptr, nullptr, (_Variant*) nullptr))>;

template <class _Sender, class _Env>
using __completion_signatures_of_t =int;

struct dependent_domain {};

namespace __domain

inline constexpr struct transform_sender_t {
  template <class _Domain, class _Sender, class... _Env>
  inline decltype(auto) operator()(_Domain __dom, _Sender&& __sndr, const _Env&... __env) const {
    return __dom.transform_sender( __sndr, __env...);          
  }
} transform_sender;

template <class _Domain, class _Sender, class... _Env>
using transform_sender_result_t = __call_result_t<transform_sender_t, _Domain, _Sender, _Env...>;

template <class _Sender, class _Env>
using __tfx_sender = transform_sender_result_t<__late_domain_of_t<_Sender, _Env>, _Sender, _Env>;

struct get_completion_signatures_t {
  template <class _Sender, class _Env> 
  static auto __impl() {
    using _TfxSender = __tfx_sender<_Sender, int>;
  }

template <class _Sender, class _Env = int>
  constexpr auto operator()(_Sender&&, const _Env&) const noexcept -> decltype(__impl<_Sender, _Env>00); 
};

inline constexpr get_completion_signatures_t get_completion_signatures;

template <class _Sender>
concept __enable_sender = derived_from<typename _Sender::sender_concept, sender_t> || requires {};

template <class _Sender>
inline constexpr bool enable_sender = __detail::__enable_sender<_Sender>;

template <class _Sender, class _Env = int>
concept sender = enable_sender<__decay_t<_Sender>>
                 && environment_provider<__cref_t<_Sender>>
                 && __detail::__consistent_completion_domains<_Sender>
                 && move_constructible<__decay_t<_Sender>>
                 && constructible_from<__decay_t<_Sender>, _Sender>;

template <class _Sender, class _Env = int>
concept sender_in = sender<_Sender> && requires(_Sender&& __sndr, _Env&& __env) {
  get_completion_signatures( __sndr,  __env);
};

struct __select_completions_for;

template <class _Tuple>
struct __invoke_completions ;

template <class _Tag, class _Tuple>
using __select_completions_for_or = __with_default< __select_completions_for, __>;

template <class _Tag, class _Completions>
using __only_gather_signal = __compl_sigs::__maybe_for_all_sigs<_Completions, __select_completions_for_or<_Tag, __qf<_Tag>>, __remove<__, __q<completion_signatures>>>;

template <class _Tag, class _Completions, class _Tuple, class _Variant>
using __gather_signal = __compl_sigs::__maybe_for_all_sigs<__only_gather_signal<_Tag, _Completions>, __invoke_completions<_Tuple>, _Variant>;

template <class _Tag, class _Sender, class _Env, class _Tuple, class _Variant>
using __gather_completions_for = __meval<__gather_signal, _Tag, __completion_signatures_of_t<_Sender, _Env>, _Tuple, _Variant>;

template <class _Sender, class _Env = empty_env, class _Tuple = __q, class _Variant = __q>
using __try_value_types_of_t = __gather_completions_for;

template <class _Sender, class _Env = empty_env, template <class...> class _Tuple = __decayed_tuple, template <class...> class _Variant = __variant>
  requires sender_in<_Sender, _Env>
using value_types_of_t = __value_types_of_t<_Sender, _Env, __q<_Tuple>, __q<_Variant>>;

template <__class _Dp>
struct sender_adaptor_closure;

template <class _Tp>
concept __sender_adaptor_closure = derived_from<__decay_t<_Tp>, sender_adaptor_closure<__decay_t<_Tp>>>
                                   && move_constructible<__decay_t<_Tp>>
                                   && constructible_from<__decay_t<_Tp>, _Tp>;

template <class _Tp, class _Sender>
concept __sender_adaptor_closure_for = __sender_adaptor_closure<_Tp>
                                       && sender<__decay_t<_Sender>> 
                                       && __callable<_Tp, __decay_t<_Sender>>
                                       && sender<__call_result_t<_Tp, __decay_t<_Sender>>>;

template <sender _Sender, __sender_adaptor_closure_for _Closure>
__call_result_t<_Closure, _Sender> operator|(_Sender&& __sndr, _Closure&& __clsur);

template <class _Fun, class... _As>
struct __binder_back : sender_adaptor_closure {
  template <sender _Sender>
  requires __callable<_Fun, _Sender, _As...> 
  inline __call_result_t<_Fun, _Sender, _As...> operator()(_Sender&& __sndr) && noexcept0 
};

template <class _Set, class _Domain = dependent_domain>
struct __let_t;

template <class _Fun, class _Set, class _Env, class _Sched>
using __result_sender_fn = __mcompose;

template <class _Sender, class _Set>
using __completion_sched = __query_result_or_t<get_completion_scheduler_t<_Set>, env_of_t<_Sender>, __none_such>;

template <class _Set>
using __try_common_domain_fn = __mtry_catch_q;

template <class _Set, class _Child, class _Fun, class _Env, class _Sched>
using __result_domain_t = __gather_completions_for<_Set, _Child, _Env, __result_sender_fn<_Fun, _Set, _Env, _Sched>, __try_common_domain_fn<_Set>>;

template <class _LetTag, class _Env>
auto __mk_transform_sender_fn(const _Env&) noexcept {
  using _Set = __t<_LetTag>;
  return []<class _Fun, class _Child>(__ignore, _Fun&& __fun, _Child&& __child) {
    using _Sched = __completion_sched<_Child, _Set>;
    using _Domain = __result_domain_t<_Set, _Child, _Fun, _Env, _Sched>;
    return __make_sexpr<__let_t<_Set, _Domain>>0;
  };
};

template <class _Set, class _Domain>
struct __let_t {
  using __t = std::set_error_t;
  template <sender _Sender, __movable_value _Fun>
  auto operator()(_Sender&& __sndr, _Fun __fun) const {
    auto __domain = __get_early_domain(__sndr);
    return stdexec::transform_sender(__domain, __make_sexpr<__let_t>( __fun,  __sndr));
  }

template <sender_expr_for _Sender, class _Env>
    requires same_as<__early_domain_of_t<_Sender>, dependent_domain>
  static decltype(auto) transform_sender(_Sender&& __sndr, const _Env& __env) {
    return __sexpr_apply( __sndr, __mk_transform_sender_fn<__let_t>(__env));
  }
};

template < class _Domain>
struct __let_impl : __sexpr_defaults {
  static constexpr auto get_attrs = []<class _Child>(__ignore, const _Child& __child) noexcept {
    return __join(__with(_Domain(), get_domain), 0);
  };
};

template <class _Set, class _Domain>
struct __sexpr_impl<__let_t<_Set, _Domain>> : __let_impl< _Domain> {};

namespace ex = stdexec;

template <typename... Ts>
struct type_array;

template <class Values>
struct fallible_just;

using t1 = void ()0;
using t2 = stdexec::__binder_back<ex::__let_t<int>, t1> ;
using t = ex::value_types_of_t<decltype(std::declval<fallible_just<int>> | t2{}), type_array<>, type_array, type_array>;