proxygen: folly::pushmi Namespace Reference

Namespaces
	__adl

	aliases

	concepts

	detail

	extension_operators

	isolated

	operators

Classes
struct	_pipeable_sender_

struct	abortEF

struct	any_constrained_executor

struct	any_constrained_executor_ref

class	any_constrained_single_sender

struct	any_executor

struct	any_executor_ref

class	any_flow_many_sender

class	any_flow_receiver

class	any_flow_single_sender

class	any_many_sender

class	any_receiver

class	any_single_sender

struct	any_time_executor

struct	any_time_executor_ref

class	any_time_single_sender

struct	blocking_category

struct	cardinality_category

struct	category_query

class	constrained_single_sender

class	constrained_single_sender< Data, DSF, DZF, DEXF >

class	constrained_single_sender< SF, ZF, EXF >

class	constrained_single_sender<>

struct	construct

struct	construct_deduced

struct	construct_deduced< constrained_single_sender >

struct	construct_deduced< flow_many_sender >

struct	construct_deduced< flow_receiver >

struct	construct_deduced< flow_single_sender >

struct	construct_deduced< many_sender >

struct	construct_deduced< receiver >

struct	construct_deduced< single_sender >

struct	construct_deduced< time_single_sender >

struct	entangled

struct	executor_category

struct	flow_category

class	flow_many_sender

class	flow_many_sender< Data, DSF, DEXF >

class	flow_many_sender< SF, EXF >

class	flow_many_sender<>

class	flow_receiver

class	flow_receiver< Data, DVF, DEF, DDF, DStrtF >

class	flow_receiver< VF, EF, DF, StrtF >

class	flow_receiver<>

class	flow_single_sender

class	flow_single_sender< Data, DSF, DEXF >

class	flow_single_sender< SF, EXF >

class	flow_single_sender<>

struct	for_each_fn

struct	has_cardinality

struct	ignoreDF

struct	ignoreNF

struct	ignoreSF

struct	ignoreStrtF

struct	ignoreVF

class	inline_constrained_executor_t

class	inline_executor_t

class	inline_time_executor_t

struct	inlineConstrainedEXF

struct	inlineEXF

struct	inlineTimeEXF

struct	invoke_fn

struct	is_always_blocking

struct	is_always_blocking< PS >

struct	is_always_blocking<>

struct	is_concurrent_sequence

struct	is_concurrent_sequence< PS >

struct	is_concurrent_sequence<>

struct	is_constrained

struct	is_constrained< PS >

struct	is_constrained<>

struct	is_executor

struct	is_executor< PS >

struct	is_executor<>

struct	is_fifo_sequence

struct	is_fifo_sequence< PS >

struct	is_fifo_sequence<>

struct	is_flow

struct	is_flow< PS >

struct	is_flow<>

struct	is_many

struct	is_many< PS >

struct	is_many<>

struct	is_maybe_blocking

struct	is_maybe_blocking< PS >

struct	is_maybe_blocking<>

struct	is_never_blocking

struct	is_never_blocking< PS >

struct	is_never_blocking<>

struct	is_receiver

struct	is_receiver< PS >

struct	is_receiver<>

struct	is_sender

struct	is_sender< PS >

struct	is_sender<>

struct	is_single

struct	is_single< PS >

struct	is_single<>

struct	is_time

struct	is_time< PS >

struct	is_time<>

struct	locked_entangled_pair

struct	locked_shared_entangled_pair

struct	make_constrained_single_sender_fn

struct	make_flow_many_sender_fn

struct	make_flow_receiver_fn

struct	make_flow_single_sender_fn

struct	make_many_sender_fn

struct	make_receiver_fn

struct	make_single_sender_fn

struct	make_time_single_sender_fn

class	many_sender

class	many_sender< Data, DSF, DEXF >

class	many_sender< SF, EXF >

class	many_sender<>

struct	new_thread_executor

struct	on_done_fn

struct	on_error_fn

struct	on_executor_fn

struct	on_now_fn

struct	on_starting_fn

struct	on_submit_fn

struct	on_value_fn

struct	overload_fn

struct	overload_fn< Fn >

struct	overload_fn< Fn, Fns... >

struct	passDDF

struct	passDEF

struct	passDEXF

struct	passDNF

struct	passDSF

struct	passDStrtF

struct	passDVF

struct	passDZF

struct	pipe_fn

class	pool

struct	pool_executor

struct	priorityZeroF

struct	property_query

struct	property_set

struct	property_set_traits

struct	property_set_traits< std::promise< T > >

struct	property_set_traits< std::promise< void > >

struct	property_set_traits< T, std::enable_if_t< Valid< std::decay_t< T >, __properties_t > > >

struct	property_set_traits< T, std::enable_if_t<(bool) Invocable< T & > &&not Valid< T &, __properties_t > > >

struct	property_traits

struct	property_traits< T, std::enable_if_t< Valid< std::decay_t< T >, __property_category_t > > >

class	receiver

class	receiver< Data, DVF, DEF, DDF >

class	receiver< VF, EF, DF >

class	receiver<>

struct	receiver_category

struct	recurse_t

struct	reduce_fn

class	same_executor_factory_fn

struct	send_via

struct	sender_category

struct	sequence_category

struct	shared_entangled

class	single_sender

class	single_sender< Data, DSF, DEXF >

class	single_sender< SF, EXF >

class	single_sender<>

class	strand_executor

class	strand_executor_factory_fn

class	strand_item

class	strand_queue

class	strand_queue_base

struct	strand_queue_receiver

struct	subject

struct	subject< PS, TN... >

struct	systemNowF

class	time_heap_item

class	time_item_process_pred_fn

class	time_queue_dispatch_pred_fn

class	time_single_sender

class	time_single_sender< SF, NF, EXF >

class	time_single_sender<>

class	time_source

class	time_source_executor

class	time_source_executor_factory_fn

class	time_source_queue

class	time_source_queue_base

struct	time_source_queue_receiver

class	time_source_shared

class	time_source_shared_base

struct	trampolineEXF

struct	typelist

Typedefs
template<template< class... > class T, class... AN>
using	deduced_type_t = ::folly::pushmi::invoke_result_t< construct_deduced< T >, AN... >

template<bool B>
using	bool_ = std::integral_constant< bool, B >

template<class F , class... As>
using	invoke_result_t = decltype(folly::pushmi::invoke(std::declval< F >(), std::declval< As >()...))

template<class First , class Second >
using	entangled_pair = std::pair< entangled< First, Second >, entangled< Second, First >>

template<class First , class Second >
using	shared_entangled_pair = std::pair< shared_entangled< First, Second >, shared_entangled< Second, First >>

template<class T >
using	__property_category_t = typename T::property_category

template<class T >
using	property_category_t = __property_category_t< property_traits< T >>

template<class T >
using	__properties_t = typename T::properties

template<class T >
using	properties_t = std::enable_if_t< PropertySet< __properties_t< property_set_traits< T >>>, __properties_t< property_set_traits< T >>>

template<class PS , class P >
using	property_set_index_t = std::enable_if_t< PropertySet< PS > &&Property< P >, decltype(detail::__property_set_index_fn< P >(PS{}))>

template<class PS0 , class PS1 >
using	property_set_insert_t = typename std::enable_if_t< PropertySet< PS0 > &&PropertySet< PS1 >, detail::property_set_insert< PS0, PS1 >>::type

template<class... >
using	void_t = void

template<class T >
using	remove_cvref_t = std::remove_cv_t< std::remove_reference_t< T >>

Functions
template<class... Fns>
auto	overload (Fns...fns) -> overload_fn< Fns... >

template<class... Fns>
auto	on_value (Fns...fns) -> on_value_fn< Fns... >

template<class... Fns>
auto	on_error (Fns...fns) -> on_error_fn< Fns... >

template<class Fn >
auto	on_done (Fn fn) -> on_done_fn< Fn >

template<class... Fns>
auto	on_starting (Fns...fns) -> on_starting_fn< Fns... >

template<class Fn >
auto	on_executor (Fn fn) -> on_executor_fn< Fn >

template<class... Fns>
auto	on_submit (Fns...fns) -> on_submit_fn< Fns... >

template<class Fn >
auto	on_now (Fn fn) -> on_now_fn< Fn >

	PUSHMI_CONCEPT_DEF (template(class PS) concept Cardinality, has_cardinality_v< PS >)

	PUSHMI_CONCEPT_DEF (template(class PS) concept Single, is_single_v< PS >)

	PUSHMI_CONCEPT_DEF (template(class PS) concept Many, is_many_v< PS >)

	PUSHMI_CONCEPT_DEF (template(class PS) concept Flow, is_flow_v< PS >)

	PUSHMI_CONCEPT_DEF (template(class PS) concept Executor, is_executor_v< PS > &&is_sender_v< PS > &&is_single_v< PS >)

	PUSHMI_CONCEPT_DEF (template(class PS) concept Constrained, is_constrained_v< PS > &&is_sender_v< PS >)

	PUSHMI_CONCEPT_DEF (template(class PS) concept Time, is_time_v< PS > &&is_constrained_v< PS > &&is_sender_v< PS >)

	PUSHMI_CONCEPT_DEF (template(class PS) concept AlwaysBlocking, is_always_blocking_v< PS > &&is_sender_v< PS >)

	PUSHMI_CONCEPT_DEF (template(class PS) concept NeverBlocking, is_never_blocking_v< PS > &&is_sender_v< PS >)

	PUSHMI_CONCEPT_DEF (template(class PS) concept MaybeBlocking, is_maybe_blocking_v< PS > &&is_sender_v< PS >)

	PUSHMI_CONCEPT_DEF (template(class PS) concept FifoSequence, is_fifo_sequence_v< PS > &&is_sender_v< PS >)

	PUSHMI_CONCEPT_DEF (template(class PS) concept ConcurrentSequence, is_concurrent_sequence_v< PS > &&is_sender_v< PS >)

	PUSHMI_CONCEPT_DEF (template(class R, class...PropertyN)(concept Receiver)(R, PropertyN...), requires(R &r)(set_done(r), set_error(r, std::exception_ptr{}))&&SemiMovable< R > &&property_query_v< R, PropertyN... > &&is_receiver_v< R > &&!is_sender_v< R >)

	PUSHMI_CONCEPT_DEF (template(class R, class...VN)(concept ReceiveValue)(R, VN...), requires(R &r)(set_value(r, std::declval< VN && >()...))&&Receiver< R > &&True<>)

	PUSHMI_CONCEPT_DEF (template(class R, class E=std::exception_ptr)(concept ReceiveError)(R, E), requires(R &r, E &&e)(set_error(r,(E &&) e))&&Receiver< R > &&SemiMovable< E >)

	PUSHMI_CONCEPT_DEF (template(class D, class...PropertyN)(concept Sender)(D, PropertyN...), requires(D &d)(executor(d), requires_< Executor< decltype(executor(d))>>)&&SemiMovable< D > &&Cardinality< D > &&property_query_v< D, PropertyN... > &&is_sender_v< D > &&!is_receiver_v< D >)

	PUSHMI_CONCEPT_DEF (template(class D, class S, class...PropertyN)(concept SenderTo)(D, S, PropertyN...), requires(D &d, S &&s)(submit(d,(S &&) s))&&Sender< D > &&Receiver< S > &&property_query_v< D, PropertyN... >)

template<class D >
	PUSHMI_PP_CONSTRAINED_USING (Sender< D >, executor_t=, decltype(executor(std::declval< D & >())))

	PUSHMI_CONCEPT_DEF (template(class S, class...PropertyN)(concept FlowReceiver)(S, PropertyN...), Receiver< S > &&property_query_v< S, PropertyN... > &&Flow< S >)

	PUSHMI_CONCEPT_DEF (template(class R, class...VN)(concept FlowReceiveValue)(R, VN...), Flow< R > &&ReceiveValue< R, VN... >)

	PUSHMI_CONCEPT_DEF (template(class R, class E=std::exception_ptr)(concept FlowReceiveError)(R, E), Flow< R > &&ReceiveError< R, E >)

	PUSHMI_CONCEPT_DEF (template(class R, class Up)(concept FlowUpTo)(R, Up), requires(R &r, Up &&up)(set_starting(r,(Up &&) up))&&Flow< R >)

	PUSHMI_CONCEPT_DEF (template(class S, class...PropertyN)(concept FlowSender)(S, PropertyN...), Sender< S > &&property_query_v< S, PropertyN... > &&Flow< S >)

	PUSHMI_CONCEPT_DEF (template(class D, class S, class...PropertyN)(concept FlowSenderTo)(D, S, PropertyN...), FlowSender< D > &&property_query_v< D, PropertyN... > &&FlowReceiver< S >)

	PUSHMI_CONCEPT_DEF (template(class D, class...PropertyN)(concept ConstrainedSender)(D, PropertyN...), requires(D &d)(top(d), requires_< Regular< decltype(top(d))>>)&&Sender< D > &&property_query_v< D, PropertyN... > &&Constrained< D >)

	PUSHMI_CONCEPT_DEF (template(class D, class S, class...PropertyN)(concept ConstrainedSenderTo)(D, S, PropertyN...), requires(D &d, S &&s)(submit(d, top(d),(S &&) s))&&ConstrainedSender< D > &&property_query_v< D, PropertyN... > &&Receiver< S >)

template<class D >
	PUSHMI_PP_CONSTRAINED_USING (ConstrainedSender< D >, constraint_t=, decltype(top(std::declval< D & >())))

	PUSHMI_CONCEPT_DEF (template(class D, class...PropertyN)(concept TimeSender)(D, PropertyN...), requires(D &d)(now(d), requires_< Regular< decltype(now(d)+std::chrono::seconds(1))>>)&&ConstrainedSender< D, PropertyN... > &&Time< D >)

	PUSHMI_CONCEPT_DEF (template(class D, class S, class...PropertyN)(concept TimeSenderTo)(D, S, PropertyN...), ConstrainedSenderTo< D, S, PropertyN... > &&TimeSender< D >)

template<class D >
	PUSHMI_PP_CONSTRAINED_USING (TimeSender< D >, time_point_t=, decltype(now(std::declval< D & >())))

template<class... TN>
constexpr auto	expAnd (TN &&...tn)

template<class T >
constexpr bool	implicitly_convertible_to (T)

	PUSHMI_CONCEPT_DEF (template(class F, class...Args)(concept Invocable)(F, Args...), requires(F &&f)(::folly::pushmi::invoke((F &&) f, std::declval< Args >()...)))

	PUSHMI_CONCEPT_DEF (template(class F, class...Args)(concept NothrowInvocable)(F, Args...), requires(F &&f)(requires_< noexcept(::folly::pushmi::invoke((F &&) f, std::declval< Args >()...))>)&&Invocable< F, Args... >)

template<class First , class Second >
auto	entangle (First f, Second s) -> entangled_pair< First, Second >

template<class T , class Dual >
locked_entangled_pair< T, Dual >	lock_both (entangled< T, Dual > &e)

template<class First , class Second >
auto	shared_entangle (First f, Second s) -> shared_entangled_pair< First, Second >

template<class T , class Dual >
locked_shared_entangled_pair< T, Dual >	lock_both (shared_entangled< T, Dual > &e)

template<class E = std::exception_ptr>
auto	make_any_executor_ref ()

	PUSHMI_TEMPLATE (class E=std::exception_ptr, class Wrapped)(requires Sender< detail

template<class E = std::exception_ptr>
auto	make_any_executor () -> any_executor< E >

template<class E = std::exception_ptr, class CV = std::ptrdiff_t>
auto	make_any_constrained_executor_ref ()

template<class E = std::exception_ptr, class CV = std::ptrdiff_t>
auto	make_any_constrained_executor () -> any_constrained_executor< E, CV >

template<class E = std::exception_ptr, class TP = std::chrono::system_clock::time_point>
auto	make_any_time_executor_ref ()

template<class E = std::exception_ptr, class TP = std::chrono::system_clock::time_point>
auto	make_any_time_executor () -> any_time_executor< E, TP >

	PUSHMI_CONCEPT_DEF (template(class T) concept FlowReceiverDataArg, Receiver< T, is_flow<>> &&not Invocable< T & >)

inline_constrained_executor_t	inline_constrained_executor ()

inline_time_executor_t	inline_time_executor ()

inline_executor_t	inline_executor ()

new_thread_executor	new_thread ()

requires	requires (detail::apply_impl(std::declval< F >(), std::declval< Tuple >(), detail::tupidxs< Tuple >{}))) const expr decltype(auto) apply(F &&f

	PUSHMI_CONCEPT_DEF (template(class R) concept Range, requires(R &&r)(implicitly_convertible_to< bool >(std::begin(r)==std::end(r))))

requires Same< To, is_sender<> > &&Sender< In > auto	via_cast (In in)

requires Same< To, is_sender<> > auto	via_cast (send_via< In > ss)

requires lazy::Sender< std::decay_t< In > > &&decltype(auto) lazy::Invocable< Op &, In >	operator\| (In &&in, Op op)

	PUSHMI_CONCEPT_DEF (template(class T) concept Property, Valid< T, property_category_t >)

	PUSHMI_CONCEPT_DEF (template(class T, class...Set)(concept FoundExactlyOnce)(T, Set...), sum_v<(PUSHMI_PP_IS_SAME(T, Set)?1:0)... >==1)

	PUSHMI_CONCEPT_DEF (template(class...PropertyN)(concept UniqueCategory)(PropertyN...), And< FoundExactlyOnce< property_category_t< PropertyN >, property_category_t< PropertyN >... >... > &&And< Property< PropertyN >... >)

	PUSHMI_CONCEPT_DEF (template(class T) concept PropertySet, detail::is_v< T, property_set >)

	PUSHMI_CONCEPT_DEF (template(class T) concept Properties, Valid< T, properties_t >)

	PUSHMI_CONCEPT_DEF (template(class T) concept ReceiverDataArg, Receiver< T > &&not Invocable< T & >)

requires SenderTo< In, std::promise< T >, is_single<> > std::future< T >	future_from (In in)

template<class E , class TP >
bool	operator< (const strand_item< E > &l, const strand_item< E > &r)

template<class E , class TP >
bool	operator> (const strand_item< E > &l, const strand_item< E > &r)

template<class E , class TP >
bool	operator== (const strand_item< E > &l, const strand_item< E > &r)

template<class E , class TP >
bool	operator!= (const strand_item< E > &l, const strand_item< E > &r)

template<class E , class TP >
bool	operator<= (const strand_item< E > &l, const strand_item< E > &r)

template<class E , class TP >
bool	operator>= (const strand_item< E > &l, const strand_item< E > &r)

requires Invocable< ExecutorFactory & > &&Executor< invoke_result_t< ExecutorFactory & > > &&ConcurrentSequence< invoke_result_t< ExecutorFactory & > > auto	strands (ExecutorFactory ef)

requires Executor< Exec > &&ConcurrentSequence< Exec > auto	strands (Exec ex)

template<class E , class TP >
bool	operator< (const time_heap_item< E, TP > &l, const time_heap_item< E, TP > &r)

template<class E , class TP >
bool	operator> (const time_heap_item< E, TP > &l, const time_heap_item< E, TP > &r)

template<class E , class TP >
bool	operator== (const time_heap_item< E, TP > &l, const time_heap_item< E, TP > &r)

template<class E , class TP >
bool	operator!= (const time_heap_item< E, TP > &l, const time_heap_item< E, TP > &r)

template<class E , class TP >
bool	operator<= (const time_heap_item< E, TP > &l, const time_heap_item< E, TP > &r)

template<class E , class TP >
bool	operator>= (const time_heap_item< E, TP > &l, const time_heap_item< E, TP > &r)

	PUSHMI_CONCEPT_DEF (template(class...Args)(concept True)(Args...), true)

	PUSHMI_CONCEPT_DEF (template(class T, template< class... > class C)(concept Valid)(T, C), True< C< T > >)

	PUSHMI_CONCEPT_DEF (template(class T, template< class... > class Trait, class...Args)(concept Satisfies)(T, Trait, Args...), static_cast< bool >(Trait< T >::type::value))

	PUSHMI_CONCEPT_DEF (template(class T, class U) concept Same, PUSHMI_PP_IS_SAME(T, U)&&PUSHMI_PP_IS_SAME(U, T))

	PUSHMI_CONCEPT_DEF (template(bool...Bs)(concept And)(Bs...), and_v< Bs... >)

	PUSHMI_CONCEPT_DEF (template(bool...Bs)(concept Or)(Bs...), or_v< Bs... >)

	PUSHMI_CONCEPT_DEF (template(class T) concept Object, requires(T p)(p, implicitly_convertible_to< const volatile void * >(p)))

	PUSHMI_CONCEPT_DEF (template(class T, class...Args)(concept Constructible)(T, Args...),)

	PUSHMI_CONCEPT_DEF (template(class T) concept MoveConstructible, Constructible< T, T >)

	PUSHMI_CONCEPT_DEF (template(class From, class To) concept ConvertibleTo, requires(From(&f)())(static_cast< To >(f()))&&std::is_convertible< From, To >::value)

	PUSHMI_CONCEPT_DEF (template(class A, class B) concept DerivedFrom, __is_base_of(B, A))

	PUSHMI_CONCEPT_DEF (template(class A) concept Decayed, Same< A, std::decay_t< A >>)

	PUSHMI_CONCEPT_DEF (template(class T, class U) concept Assignable, requires(T t, U &&u)(t=(U &&) u, requires_< Same< decltype(t=(U &&) u), T >>)&&Same< T, T & >)

	PUSHMI_CONCEPT_DEF (template(class T) concept EqualityComparable, requires(remove_cvref_t< T > const &t)(implicitly_convertible_to< bool >(t==t), implicitly_convertible_to< bool >(t!=t)))

	PUSHMI_CONCEPT_DEF (template(class T) concept SemiMovable, Object< T > &&Constructible< T, T > &&ConvertibleTo< T, T >)

	PUSHMI_CONCEPT_DEF (template(class T) concept Movable, SemiMovable< T > &&Assignable< T &, T >)

	PUSHMI_CONCEPT_DEF (template(class T) concept Copyable, Movable< T > &&Assignable< T &, const T & > &&ConvertibleTo< const T &, T >)

	PUSHMI_CONCEPT_DEF (template(class T) concept Semiregular, Copyable< T > &&Constructible< T >)

	PUSHMI_CONCEPT_DEF (template(class T) concept Regular, Semiregular< T > &&EqualityComparable< T >)

template<class E = std::exception_ptr>
detail::trampoline_id	get_trampoline_id ()

template<class E = std::exception_ptr>
bool	owned_by_trampoline ()

template<class E = std::exception_ptr>
detail::delegator< E >	trampoline ()

template<class E = std::exception_ptr>
detail::nester< E >	nested_trampoline ()

auto	repeat ()

Variables
template<class PS >
PUSHMI_INLINE_VAR constexpr bool	has_cardinality_v = has_cardinality<PS>::value

template<class PS >
PUSHMI_INLINE_VAR constexpr bool	is_single_v = is_single<PS>::value

template<class PS >
PUSHMI_INLINE_VAR constexpr bool	is_many_v = is_many<PS>::value

template<class PS >
PUSHMI_INLINE_VAR constexpr bool	is_flow_v = is_flow<PS>::value

template<class PS >
PUSHMI_INLINE_VAR constexpr bool	is_receiver_v = is_receiver<PS>::value

template<class PS >
PUSHMI_INLINE_VAR constexpr bool	is_sender_v = is_sender<PS>::value

template<class PS >
PUSHMI_INLINE_VAR constexpr bool	is_executor_v = is_executor<PS>::value

template<class PS >
PUSHMI_INLINE_VAR constexpr bool	is_constrained_v = is_constrained<PS>::value

template<class PS >
PUSHMI_INLINE_VAR constexpr bool	is_time_v = is_time<PS>::value

template<class PS >
PUSHMI_INLINE_VAR constexpr bool	is_always_blocking_v

template<class PS >
PUSHMI_INLINE_VAR constexpr bool	is_never_blocking_v

template<class PS >
PUSHMI_INLINE_VAR constexpr bool	is_maybe_blocking_v

template<class PS >
PUSHMI_INLINE_VAR constexpr bool	is_fifo_sequence_v

template<class PS >
PUSHMI_INLINE_VAR constexpr bool	is_concurrent_sequence_v

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_constrained_single_sender_fn	make_constrained_single_sender

template<bool B>
constexpr std::enable_if_t< B, int >	requires_ = 0

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::invoke_fn	invoke

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::for_each_fn	for_each

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::reduce_fn	reduce

PUSHMI_INLINE_VAR constexpr __adl::set_done_fn	set_done {}

PUSHMI_INLINE_VAR constexpr __adl::set_error_fn	set_error {}

PUSHMI_INLINE_VAR constexpr __adl::set_value_fn	set_value {}

PUSHMI_INLINE_VAR constexpr __adl::set_starting_fn	set_starting {}

PUSHMI_INLINE_VAR constexpr __adl::get_executor_fn	executor {}

PUSHMI_INLINE_VAR constexpr __adl::do_submit_fn	submit {}

PUSHMI_INLINE_VAR constexpr __adl::get_top_fn	now {}

PUSHMI_INLINE_VAR constexpr __adl::get_top_fn	top {}

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_flow_many_sender_fn	make_flow_many_sender

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_flow_receiver_fn	make_flow_receiver

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_flow_single_sender_fn	make_flow_single_sender

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_many_sender_fn	make_many_sender

requires Tuple &&	t

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::pipe_fn	pipe

template<class PS , class... ExpectedN>
PUSHMI_INLINE_VAR constexpr bool	property_query_v

template<class PS , class... ExpectedN>
PUSHMI_INLINE_VAR constexpr bool	category_query_v

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_receiver_fn	make_receiver

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_single_sender_fn	make_single_sender

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_time_single_sender_fn	make_time_single_sender

template<bool... Bs>
PUSHMI_INLINE_VAR constexpr bool	and_v

template<bool... Bs>
PUSHMI_INLINE_VAR constexpr bool	or_v

template<int... Is>
PUSHMI_INLINE_VAR constexpr int	sum_v = detail::sum_impl<Is...>()

constexpr const recurse_t	recurse {}

Typedef Documentation

template<class T >

using folly::pushmi::__properties_t = typedef typename T::properties

Definition at line 90 of file properties.h.

template<class T >

using folly::pushmi::__property_category_t = typedef typename T::property_category

Definition at line 29 of file properties.h.

template<bool B>

using folly::pushmi::bool_ = typedef std::integral_constant<bool, B>

Definition at line 443 of file concept_def.h.

template<template< class... > class T, class... AN>

using folly::pushmi::deduced_type_t = typedef ::folly::pushmi::invoke_result_t<construct_deduced<T>, AN...>

Definition at line 70 of file boosters.h.

template<class First , class Second >

using folly::pushmi::entangled_pair = typedef std::pair<entangled<First, Second>, entangled<Second, First>>

Definition at line 216 of file entangle.h.

template<class F , class... As>

using folly::pushmi::invoke_result_t = typedef decltype(folly::pushmi::invoke(std::declval<F>(), std::declval<As>()...))

Definition at line 47 of file functional.h.

template<class T >

using folly::pushmi::properties_t = typedef std::enable_if_t< PropertySet<__properties_t<property_set_traits<T>>>, __properties_t<property_set_traits<T>>>

Definition at line 105 of file properties.h.

template<class T >

using folly::pushmi::property_category_t = typedef __property_category_t<property_traits<T>>

Definition at line 42 of file properties.h.

template<class PS , class P >

using folly::pushmi::property_set_index_t = typedef std::enable_if_t< PropertySet<PS> && Property<P>, decltype(detail::__property_set_index_fn<P>(PS{}))>

Definition at line 148 of file properties.h.

template<class PS0 , class PS1 >

using folly::pushmi::property_set_insert_t = typedef typename std::enable_if_t< PropertySet<PS0> && PropertySet<PS1>, detail::property_set_insert<PS0, PS1>>::type

Definition at line 153 of file properties.h.

template<class T >

using folly::pushmi::remove_cvref_t = typedef std::remove_cv_t<std::remove_reference_t<T>>

Definition at line 81 of file traits.h.

template<class First , class Second >

using folly::pushmi::shared_entangled_pair = typedef std::pair<shared_entangled<First, Second>, shared_entangled<Second, First>>

Definition at line 276 of file entangle.h.

template<class... >

using folly::pushmi::void_t = typedef void

Definition at line 78 of file traits.h.

Function Documentation

template<class First , class Second >

auto folly::pushmi::entangle	(	First	f,
		Second	s
	)		-> entangled_pair<First, Second>

Definition at line 219 of file entangle.h.

References folly::pushmi::entangled< T, Dual >::dual, f, folly::gen::move, and s.

Referenced by entangled_cancellation_factory::operator()(), and TEST_F().

                                                                   {
   entangled<First, Second> ef(std::move(f));
   entangled<Second, First> es(std::move(s));
   ef.dual = std::addressof(es);
   es.dual = std::addressof(ef);
   return {std::move(ef), std::move(es)};
 }

template<class... TN>

constexpr auto folly::pushmi::expAnd ( TN &&... tn )

Definition at line 541 of file concept_def.h.

References folly::pushmi::isolated::expAnd().

Referenced by folly::pushmi::isolated::expAnd().

544 {

requires SenderTo< In, std::promise< void >, is_single<> > std::future< void > folly::pushmi::future_from ( In in )

Definition at line 500 of file receiver.h.

References folly::gen::move, PUSHMI_TEMPLATE(), requires(), and submit.

Referenced by TEST().

                                 {
   std::promise<T> p;
   auto result = p.get_future();
   submit(in, std::move(p));
   return result;
 }

template<class E = std::exception_ptr>

detail::trampoline_id folly::pushmi::get_trampoline_id ( )

Definition at line 248 of file trampoline.h.

References folly::pushmi::detail::trampoline< E >::get_id().

                                         {
   if (!detail::trampoline<E>::is_owned()) {
     std::abort();
   }
   return detail::trampoline<E>::get_id();
 }

template<class T >

constexpr bool folly::pushmi::implicitly_convertible_to ( T )

Definition at line 546 of file concept_def.h.

549 {

inline_constrained_executor_t folly::pushmi::inline_constrained_executor ( )

inline

Definition at line 51 of file inline.h.

Referenced by constrained_single_sender_test().

                                                                    {
   return {};
 }

inline_executor_t folly::pushmi::inline_executor ( )

inline

Definition at line 113 of file inline.h.

Referenced by TEST_F().

                                            {
   return {};
 }

inline_time_executor_t folly::pushmi::inline_time_executor ( )

inline

Definition at line 84 of file inline.h.

Referenced by time_single_sender_test().

                                                      {
   return {};
 }

template<class T , class Dual >

locked_entangled_pair<T, Dual> folly::pushmi::lock_both ( entangled< T, Dual > & e )

Definition at line 257 of file entangle.h.

Referenced by ConcurrentFlowSingleSender::cancellation_test(), ImmediateFlowSingleSender::make_producer(), and inline_executor_flow_single< CancellationFactory >::submit().

                                                                 {
   return locked_entangled_pair<T, Dual>{e};
 }

template<class T , class Dual >

locked_shared_entangled_pair<T, Dual> folly::pushmi::lock_both ( shared_entangled< T, Dual > & e )

Definition at line 312 of file entangle.h.

                                                                               {
   return locked_shared_entangled_pair<T, Dual>{e};
 }

template<class E = std::exception_ptr, class CV = std::ptrdiff_t>

auto folly::pushmi::make_any_constrained_executor ( ) -> any_constrained_executor<E, CV>

Definition at line 308 of file executor.h.

References folly::gen::move, folly::pushmi::detail::PUSHMI_TEMPLATE(), and folly::pushmi::detail::requires().

                                                                         {
   return any_constrained_executor<E, CV>{};
 }

template<class E = std::exception_ptr, class CV = std::ptrdiff_t>

auto folly::pushmi::make_any_constrained_executor_ref ( )

Definition at line 256 of file executor.h.

References folly::pushmi::detail::PUSHMI_TEMPLATE(), and folly::pushmi::detail::requires().

                                          {
   return any_constrained_executor_ref<E, CV>{};
 }

template<class E = std::exception_ptr>

auto folly::pushmi::make_any_executor ( ) -> any_executor<E>

Definition at line 147 of file executor.h.

References folly::gen::move, folly::pushmi::detail::PUSHMI_TEMPLATE(), and folly::pushmi::detail::requires().

                                             {
   return any_executor<E>{};
 }

template<class E = std::exception_ptr>

auto folly::pushmi::make_any_executor_ref ( )

Definition at line 98 of file executor.h.

                              {
   return any_executor_ref<E>{};
 }

template<class E = std::exception_ptr, class TP = std::chrono::system_clock::time_point>

auto folly::pushmi::make_any_time_executor ( ) -> any_time_executor<E, TP>

Definition at line 472 of file executor.h.

References folly::gen::move, folly::pushmi::detail::PUSHMI_TEMPLATE(), and folly::pushmi::detail::requires().

                                                           {
   return any_time_executor<E, TP>{};
 }

template<class E = std::exception_ptr, class TP = std::chrono::system_clock::time_point>

auto folly::pushmi::make_any_time_executor_ref ( )

Definition at line 420 of file executor.h.

References folly::pushmi::detail::PUSHMI_TEMPLATE(), and folly::pushmi::detail::requires().

                                   {
   return any_time_executor_ref<E, TP>{};
 }

template<class E = std::exception_ptr>

detail::nester<E> folly::pushmi::nested_trampoline ( )

inline

Definition at line 265 of file trampoline.h.

                                            {
   return {};
 }

new_thread_executor folly::pushmi::new_thread ( )

inline

Definition at line 50 of file new_thread.h.

                                         {
   return {};
 }

template<class Fn >

auto folly::pushmi::on_done ( Fn fn ) -> on_done_fn<Fn>

Definition at line 285 of file boosters.h.

References folly::gen::move.

Referenced by ConcurrentFlowManySender::cancellation_test(), ConcurrentFlowSingleSender::cancellation_test(), flow_receiver_1_test(), flow_receiver_n_test(), ImmediateFlowManySender::make_consumer(), ImmediateFlowSingleSender::make_consumer(), ImmediateFlowSingleSender::make_producer(), receiver_0_test(), receiver_1_test(), and receiver_n_test().

                                       {
   return on_done_fn<Fn>{std::move(fn)};
 }

template<class... Fns>

auto folly::pushmi::on_error ( Fns... fns ) -> on_error_fn<Fns...>

Definition at line 273 of file boosters.h.

References folly::gen::move.

Referenced by ConcurrentFlowManySender::cancellation_test(), ConcurrentFlowSingleSender::cancellation_test(), flow_receiver_1_test(), flow_receiver_n_test(), main(), ImmediateFlowManySender::make_consumer(), ImmediateFlowSingleSender::make_consumer(), folly::pushmi::detail::no_fail_fn::out_impl< In >::operator()(), folly::pushmi::detail::switch_on_error_fn::out_impl< In, ErrorSelector >::operator()(), receiver_0_test(), receiver_1_test(), and receiver_n_test().

                                                  {
   return on_error_fn<Fns...>{std::move(fns)...};
 }

template<class Fn >

auto folly::pushmi::on_executor ( Fn fn ) -> on_executor_fn<Fn>

Definition at line 307 of file boosters.h.

References folly::gen::move.

Referenced by folly::pushmi::detail::via_fn::in_impl< ExecutorFactory >::operator()().

                                               {
   return on_executor_fn<Fn>{std::move(fn)};
 }

template<class Fn >

auto folly::pushmi::on_now ( Fn fn ) -> on_now_fn<Fn>

Definition at line 329 of file boosters.h.

References folly::gen::move.

                                     {
   return on_now_fn<Fn>{std::move(fn)};
 }

template<class... Fns>

auto folly::pushmi::on_starting ( Fns... fns ) -> on_starting_fn<Fns...>

Definition at line 296 of file boosters.h.

References folly::gen::move.

Referenced by ConcurrentFlowManySender::cancellation_test(), ConcurrentFlowSingleSender::cancellation_test(), ImmediateFlowManySender::make_consumer(), and ImmediateFlowSingleSender::make_consumer().

                                                        {
   return on_starting_fn<Fns...>{std::move(fns)...};
 }

template<class... Fns>

auto folly::pushmi::on_submit ( Fns... fns ) -> on_submit_fn<Fns...>

Definition at line 318 of file boosters.h.

References folly::gen::move.

Referenced by folly::pushmi::detail::submit_transform_out().

                                                    {
   return on_submit_fn<Fns...>{std::move(fns)...};
 }

template<class... Fns>

auto folly::pushmi::on_value ( Fns... fns ) -> on_value_fn<Fns...>

Definition at line 262 of file boosters.h.

References folly::gen::move.

Referenced by ConcurrentFlowManySender::cancellation_test(), ConcurrentFlowSingleSender::cancellation_test(), constrained_single_sender_test(), flow_many_sender_test(), flow_receiver_1_test(), flow_receiver_n_test(), flow_single_sender_test(), ImmediateFlowManySender::make_consumer(), ImmediateFlowSingleSender::make_consumer(), many_sender_test(), folly::pushmi::detail::transform_on< F, is_single<>, true >::operator()(), folly::pushmi::detail::transform_on< F, is_many<> >::operator()(), folly::pushmi::detail::transform_on< F, is_many<>, true >::operator()(), receiver_0_test(), receiver_1_test(), receiver_n_test(), single_sender_test(), TEST_F(), and time_single_sender_test().

                                                  {
   return on_value_fn<Fns...>{std::move(fns)...};
 }

template<class E , class TP >

bool folly::pushmi::operator!=	(	const strand_item< E > &	l,
		const strand_item< E > &	r
	)

Definition at line 53 of file strand.h.

                                                                   {
   return !(l == r);
 }

template<class E , class TP >

bool folly::pushmi::operator!=	(	const time_heap_item< E, TP > &	l,
		const time_heap_item< E, TP > &	r
	)

Definition at line 64 of file time_source.h.

                                     {
   return !(l == r);
 }

template<class E , class TP >

bool folly::pushmi::operator<	(	const strand_item< E > &	l,
		const strand_item< E > &	r
	)

Definition at line 41 of file strand.h.

                                                                  {
   return l.when < r.when;
 }

template<class E , class TP >

bool folly::pushmi::operator<	(	const time_heap_item< E, TP > &	l,
		const time_heap_item< E, TP > &	r
	)

Definition at line 50 of file time_source.h.

References folly::pushmi::time_heap_item< E, TP >::when.

                                                                                {
   return l.when < r.when;
 }

template<class E , class TP >

bool folly::pushmi::operator<=	(	const strand_item< E > &	l,
		const strand_item< E > &	r
	)

Definition at line 57 of file strand.h.

                                                                   {
   return !(l > r);
 }

template<class E , class TP >

bool folly::pushmi::operator<=	(	const time_heap_item< E, TP > &	l,
		const time_heap_item< E, TP > &	r
	)

Definition at line 70 of file time_source.h.

                                     {
   return !(l > r);
 }

template<class E , class TP >

bool folly::pushmi::operator==	(	const strand_item< E > &	l,
		const strand_item< E > &	r
	)

Definition at line 49 of file strand.h.

                                                                   {
   return l.when == r.when;
 }

template<class E , class TP >

bool folly::pushmi::operator==	(	const time_heap_item< E, TP > &	l,
		const time_heap_item< E, TP > &	r
	)

Definition at line 58 of file time_source.h.

References folly::pushmi::time_heap_item< E, TP >::when.

                                     {
   return l.when == r.when;
 }

template<class E , class TP >

bool folly::pushmi::operator>	(	const strand_item< E > &	l,
		const strand_item< E > &	r
	)

Definition at line 45 of file strand.h.

                                                                  {
   return l.when > r.when;
 }

template<class E , class TP >

bool folly::pushmi::operator>	(	const time_heap_item< E, TP > &	l,
		const time_heap_item< E, TP > &	r
	)

Definition at line 54 of file time_source.h.

References folly::pushmi::time_heap_item< E, TP >::when.

                                                                                {
   return l.when > r.when;
 }

template<class E , class TP >

bool folly::pushmi::operator>=	(	const strand_item< E > &	l,
		const strand_item< E > &	r
	)

Definition at line 61 of file strand.h.

                                                                   {
   return !(l < r);
 }

template<class E , class TP >

bool folly::pushmi::operator>=	(	const time_heap_item< E, TP > &	l,
		const time_heap_item< E, TP > &	r
	)

Definition at line 76 of file time_source.h.

                                     {
   return !(l < r);
 }

requires lazy::Sender<std::decay_t<In> >&&decltype(auto) lazy::Invocable<Op&, In> folly::pushmi::operator\|	(	In &&	in,
		Op	op
	)

Definition at line 25 of file piping.h.

                                          {
   return op((In &&) in);
 }

template<class... Fns>

auto folly::pushmi::overload ( Fns... fns ) -> overload_fn<Fns...>

Definition at line 251 of file boosters.h.

References folly::gen::move.

Referenced by folly::pushmi::detail::transform_fn::operator()().

                                                  {
   return overload_fn<Fns...>{std::move(fns)...};
 }

template<class E = std::exception_ptr>

bool folly::pushmi::owned_by_trampoline ( )

Definition at line 256 of file trampoline.h.

References folly::pushmi::detail::trampoline< E >::is_owned().

                            {
   return detail::trampoline<E>::is_owned();
 }

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class R) concept	Range,
		requires(R &&r)(implicitly_convertible_to< bool >(std::begin(r)==std::end(r)))
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class PS) concept	Cardinality,
		has_cardinality_v< PS >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T) concept	Property,
		Valid< T, property_category_t >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class F, class...Args)(concept Invocable)(F, Args...)	,
		requires(F &&f)(::folly::pushmi::invoke((F &&) f, std::declval< Args >()...))
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T, class...Set)(concept FoundExactlyOnce)(T, Set...)	,
		sum_v<(PUSHMI_PP_IS_SAME(T, Set)?1:0)... >	= `=1`
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class...PropertyN)(concept UniqueCategory)(PropertyN...)	,
		And< FoundExactlyOnce< property_category_t< PropertyN >, property_category_t< PropertyN >... >... > &&And< Property< PropertyN >... >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class F, class...Args)(concept NothrowInvocable)(F, Args...)	,
		requires(F &&f)(requires_< noexcept(::folly::pushmi::invoke((F &&) f, std::declval< Args >()...))>)&&Invocable< F, Args... >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class PS) concept	Single,
		is_single_v< PS >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T) concept	PropertySet,
		detail::is_v< T, property_set >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class...Args)(concept True)(Args...)	,
		true
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T, template< class... > class C)(concept Valid)(T, C)	,
		True< C< T > >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class PS) concept	Many,
		is_many_v< PS >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T, template< class... > class Trait, class...Args)(concept Satisfies)(T, Trait, Args...)	,
		static_cast< bool >	Trait< T >::type::value
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T, class U) concept	Same,
		PUSHMI_PP_IS_SAME(T, U)&&PUSHMI_PP_IS_SAME(U, T)
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T) concept	Properties,
		Valid< T, properties_t >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(bool...Bs)(concept And)(Bs...)	,
		and_v< Bs... >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class PS) concept	Flow,
		is_flow_v< PS >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(bool...Bs)(concept Or)(Bs...)	,
		or_v< Bs... >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T) concept	Object,
		requires(T p)(,< * >	p
	)

folly::pushmi::PUSHMI_CONCEPT_DEF ( template(class T, class...Args)(concept Constructible)(T, Args...) )

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T) concept	MoveConstructible,
		Constructible< T, T >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class From, class To) concept	ConvertibleTo,
		requires(From(&f)())(static_cast< To >(f()))&&std::is_convertible< From, To >::value
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class A, class B) concept	DerivedFrom,
		__is_base_of(B, A)
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class A) concept	Decayed,
		Same< A, std::decay_t< A >>
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T, class U) concept	Assignable,
		requires(T t, U &&u)(t=(U &&) u, requires_< Same< decltype(t=(U &&) u), T >>)&&Same< T, T & >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class PS) concept	Executor,
		is_executor_v< PS > &&is_sender_v< PS > &&is_single_v< PS >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T) concept	EqualityComparable,
		requires(remove_cvref_t< T > const &t)(implicitly_convertible_to< bool >(t==t), implicitly_convertible_to< bool >(t!=t))
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class PS) concept	Constrained,
		is_constrained_v< PS > &&is_sender_v< PS >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T) concept	SemiMovable,
		Object< T > &&Constructible< T, T > &&ConvertibleTo< T, T >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T) concept	Movable,
		SemiMovable< T > &&Assignable< T &, T >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T) concept	Copyable,
		Movable< T > &&Assignable< T &, const T & > &&ConvertibleTo< const T &, T >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class PS) concept	Time,
		is_time_v< PS > &&is_constrained_v< PS > &&is_sender_v< PS >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T) concept	Semiregular,
		Copyable< T > &&Constructible< T >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T) concept	Regular,
		Semiregular< T > &&EqualityComparable< T >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class PS) concept	AlwaysBlocking,
		is_always_blocking_v< PS > &&is_sender_v< PS >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class PS) concept	NeverBlocking,
		is_never_blocking_v< PS > &&is_sender_v< PS >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class PS) concept	MaybeBlocking,
		is_maybe_blocking_v< PS > &&is_sender_v< PS >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class PS) concept	FifoSequence,
		is_fifo_sequence_v< PS > &&is_sender_v< PS >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class PS) concept	ConcurrentSequence,
		is_concurrent_sequence_v< PS > &&is_sender_v< PS >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class R, class...PropertyN)(concept Receiver)(R, PropertyN...)	,
		requires(R &r)(set_done(r), set_error(r, std::exception_ptr{}))&&SemiMovable< R > &&property_query_v< R, PropertyN... > &&is_receiver_v< R > &&!is_sender_v< R >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class R, class...VN)(concept ReceiveValue)(R, VN...)	,
		requires(R &r)(set_value(r, std::declval< VN && >()...))&&Receiver< R > &&True<>
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class R, class E=std::exception_ptr)(concept ReceiveError)(R, E)	,
		requires(R &r, E &&e)(set_error(r,(E &&) e))&&Receiver< R > &&SemiMovable< E >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T) concept	ReceiverDataArg,
		Receiver< T > &&not Invocable< T & >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class D, class...PropertyN)(concept Sender)(D, PropertyN...)	,
		requires(D &d)(executor(d), requires_< Executor< decltype(executor(d))>>)&&SemiMovable< D > &&Cardinality< D > &&property_query_v< D, PropertyN... > &&is_sender_v< D > &&!is_receiver_v< D >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class T) concept	FlowReceiverDataArg,
		Receiver< T, is_flow<>> &&not Invocable< T & >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class D, class S, class...PropertyN)(concept SenderTo)(D, S, PropertyN...)	,
		requires(D &d, S &&s)(submit(d,(S &&) s))&&Sender< D > &&Receiver< S > &&property_query_v< D, PropertyN... >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class S, class...PropertyN)(concept FlowReceiver)(S, PropertyN...)	,
		Receiver< S > &&property_query_v< S, PropertyN... > &&Flow< S >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class R, class...VN)(concept FlowReceiveValue)(R, VN...)	,
		Flow< R > &&ReceiveValue< R, VN... >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class R, class E=std::exception_ptr)(concept FlowReceiveError)(R, E)	,
		Flow< R > &&ReceiveError< R, E >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class R, class Up)(concept FlowUpTo)(R, Up)	,
		requires(R &r, Up &&up)(set_starting(r,(Up &&) up))&&Flow< R >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class S, class...PropertyN)(concept FlowSender)(S, PropertyN...)	,
		Sender< S > &&property_query_v< S, PropertyN... > &&Flow< S >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class D, class S, class...PropertyN)(concept FlowSenderTo)(D, S, PropertyN...)	,
		FlowSender< D > &&property_query_v< D, PropertyN... > &&FlowReceiver< S >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class D, class...PropertyN)(concept ConstrainedSender)(D, PropertyN...)	,
		requires(D &d)(top(d), requires_< Regular< decltype(top(d))>>)&&Sender< D > &&property_query_v< D, PropertyN... > &&Constrained< D >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class D, class S, class...PropertyN)(concept ConstrainedSenderTo)(D, S, PropertyN...)	,
		requires(D &d, S &&s)(submit(d, top(d),(S &&) s))&&ConstrainedSender< D > &&property_query_v< D, PropertyN... > &&Receiver< S >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class D, class...PropertyN)(concept TimeSender)(D, PropertyN...)	,
		requires(D &d)(now(d), requires_< Regular< decltype(now(d)+std::chrono::seconds(1))>>)&&ConstrainedSender< D, PropertyN... > &&Time< D >
	)

folly::pushmi::PUSHMI_CONCEPT_DEF	(	template(class D, class S, class...PropertyN)(concept TimeSenderTo)(D, S, PropertyN...)	,
		ConstrainedSenderTo< D, S, PropertyN... > &&TimeSender< D >
	)

template<class D >

folly::pushmi::PUSHMI_PP_CONSTRAINED_USING	(	Sender< D >	,
		executor_t	,
		decltype(executor(std::declval< D & >()))
	)

template<class D >

folly::pushmi::PUSHMI_PP_CONSTRAINED_USING	(	ConstrainedSender< D >	,
		constraint_t	,
		decltype(top(std::declval< D & >()))
	)

template<class D >

folly::pushmi::PUSHMI_PP_CONSTRAINED_USING	(	TimeSender< D >	,
		time_point_t	,
		decltype(now(std::declval< D & >()))
	)

folly::pushmi::PUSHMI_TEMPLATE	(	class E	= `std::exception_ptr`,
		class Wrapped
	)

Definition at line 102 of file executor.h.

References folly::pushmi::detail::PUSHMI_TEMPLATE(), and folly::pushmi::detail::requires().

                                        {
   return any_executor_ref<E>{w};
 }

auto folly::pushmi::repeat ( )

inline

Definition at line 290 of file trampoline.h.

References folly::pushmi::detail::repeat().

Referenced by folly::pushmi::detail::trampoline< E >::submit().

                      {
   return [](auto& exec) { detail::repeat(exec); };
 }

requires folly::pushmi::requires ( detail::apply_impl(std::declval< F >(),std::declval< Tuple >(),detail::tupidxs< Tuple >{}) ) const

template<class First , class Second >

auto folly::pushmi::shared_entangle	(	First	f,
		Second	s
	)		-> shared_entangled_pair<First, Second>

Definition at line 279 of file entangle.h.

References f, folly::lock(), folly::gen::move, mutex, and s.

Referenced by ImmediateFlowSingleSender::make_producer(), shared_cancellation_factory::operator()(), and TEST_F().

                                             {
   struct storage {
     storage(First&& f, Second&& s) : p((First &&) f, (Second &&) s) {}
     std::tuple<First, Second> p;
     std::mutex lock;
   };
   auto p = std::make_shared<storage>(std::move(f), std::move(s));
   shared_entangled<First, Second> ef(
       p, std::get<0>(p->p), std::get<1>(p->p), p->lock);
   shared_entangled<Second, First> es(
       p, std::get<1>(p->p), std::get<0>(p->p), p->lock);
   return {std::move(ef), std::move(es)};
 }

requires Invocable<ExecutorFactory&>&& Executor<invoke_result_t<ExecutorFactory&> >&& ConcurrentSequence< invoke_result_t<ExecutorFactory&> > auto folly::pushmi::strands ( ExecutorFactory ef )

Definition at line 246 of file strand.h.

References folly::gen::move, PUSHMI_TEMPLATE(), and requires().

Referenced by lisp(), main(), pipe(), sugar(), TEST_F(), and p1055::then_execute().

                                  {
   return strand_executor_factory_fn<E, ExecutorFactory>{std::move(ef)};
 }

requires Executor<Exec>&& ConcurrentSequence<Exec> auto folly::pushmi::strands ( Exec ex )

Definition at line 251 of file strand.h.

References folly::gen::move.

                       {
   return strand_executor_factory_fn<E, same_executor_factory_fn<Exec>>{
       same_executor_factory_fn<Exec>{std::move(ex)}};
 }

template<class E = std::exception_ptr>

detail::delegator<E> folly::pushmi::trampoline ( )

inline

Definition at line 261 of file trampoline.h.

Referenced by folly::pushmi::subject< PS, TN... >::executor(), flow_many_sender_test(), flow_single_sender_test(), many_sender_test(), folly::pushmi::operators::flow_from_fn::operator()(), folly::pushmi::trampolineEXF::operator()(), single_sender_test(), and folly::pushmi::new_thread_executor::submit().

                                        {
   return {};
 }

requires Same<To, is_sender<> >&& Sender<In> auto folly::pushmi::via_cast ( In in )

Definition at line 67 of file request_via.h.

References folly::pushmi::send_via< In >::in, PUSHMI_TEMPLATE(), and requires().

Referenced by main().

                      {
   return in;
 }

requires Same<To, is_sender<> > auto folly::pushmi::via_cast ( send_via< In > ss )

Definition at line 73 of file request_via.h.

References folly::pushmi::send_via< In >::in.

                                {
   return ss.in;
 }

Variable Documentation

template<bool... Bs>

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::and_v

Initial value:

PUSHMI_PP_IS_SAME(detail::bools<Bs..., true>, detail::bools<true, Bs...>)

PUSHMI_PP_IS_SAME

#define PUSHMI_PP_IS_SAME(...)

Definition: concept_def.h:68

Definition at line 62 of file traits.h.

template<class PS , class... ExpectedN>

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::category_query_v

Initial value:

category_query<PS, ExpectedN...>::value

value

static const char *const value

Definition: Conv.cpp:50

Definition at line 199 of file properties.h.

PUSHMI_INLINE_VAR constexpr __adl::get_executor_fn folly::pushmi::executor {}

Definition at line 359 of file extension_points.h.

Referenced by folly::FutureDAG::add(), folly::DefaultKeepAliveExecutor::WeakRef::add(), folly::DefaultKeepAliveExecutor::WeakRef::addWithPriority(), folly::pushmi::any_constrained_single_sender< E, TP, VN... >::any_constrained_single_sender(), folly::pushmi::any_flow_many_sender< PE, PV, E, VN >::any_flow_many_sender(), folly::pushmi::any_flow_single_sender< PE, E, VN >::any_flow_single_sender(), folly::pushmi::any_many_sender< E, VN >::any_many_sender(), folly::pushmi::any_single_sender< E, VN >::any_single_sender(), folly::gen::detail::Parallel< Ops >::Generator< Input, Source, InputDecayed, Composed, Output, OutputDecayed >::apply(), folly::coro::co_viaIfAsync(), folly::SerialExecutor::createUnique(), folly::pushmi::detail::blocking_submit_fn::nested_executor_impl::executor(), folly::gen::detail::Parallel< Ops >::Generator< Input, Source, InputDecayed, Composed, Output, OutputDecayed >::foreach(), folly::SemiFuture< T >::getDeferredExecutor(), folly::Executor::getKeepAliveToken(), folly::FutureDAG::go(), fizz::server::detail::handleInvalidEvent(), keepAliveTest(), folly::Executor::makeKeepAlive(), folly::Executor::makeKeepAliveDummy(), folly::futures::map(), wangle::SSLSessionPersistentCacheBase< K >::TimeUtil::now(), folly::pushmi::passDEXF::operator()(), folly::pushmi::detail::executor_fn::impl::operator()(), fizz::server::ServerStateMachine::processAccept(), RecursiveAddTest(), folly::SemiFuture< T >::releaseDeferredExecutor(), folly::pushmi::__adl::requires(), folly::pushmi::__adl::get_executor_fn::requires(), folly::Executor::KeepAlive< folly::VirtualEventBase >::reset(), folly::coro::Task< T >::scheduleOn(), folly::SemiFuture< T >::SemiFuture(), SimpleTest(), folly::SemiFuture< T >::stealDeferredExecutor(), folly::futures::detail::stealDeferredExecutors(), folly::futures::detail::stealDeferredExecutorsVariadic(), folly::TEST(), TEST(), TEST_F(), folly::SemiFuture< T >::via(), folly::Future< T >::via(), folly::window(), and folly::VirtualExecutor::wrapFunc().

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::for_each_fn folly::pushmi::for_each

Referenced by folly::pushmi::for_each_fn::operator()().

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::has_cardinality_v = has_cardinality<PS>::value

Definition at line 35 of file concepts.h.

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::invoke_fn folly::pushmi::invoke

Referenced by BENCHMARK(), folly::pushmi::invoke_fn::operator()(), TEST_F(), and proxygen::HTTP2PriorityQueue::Node::visitBFS().

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::is_always_blocking_v

Initial value:

is_always_blocking<PS>::value

value

static const char *const value

Definition: Conv.cpp:50

Definition at line 207 of file concepts.h.

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::is_concurrent_sequence_v

Initial value:

is_concurrent_sequence<PS>::value

value

static const char *const value

Definition: Conv.cpp:50

Definition at line 280 of file concepts.h.

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::is_constrained_v = is_constrained<PS>::value

Definition at line 175 of file concepts.h.

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::is_executor_v = is_executor<PS>::value

Definition at line 160 of file concepts.h.

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::is_fifo_sequence_v

Initial value:

is_fifo_sequence<PS>::value

value

static const char *const value

Definition: Conv.cpp:50

Definition at line 261 of file concepts.h.

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::is_flow_v = is_flow<PS>::value

Definition at line 107 of file concepts.h.

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::is_many_v = is_many<PS>::value

Definition at line 92 of file concepts.h.

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::is_maybe_blocking_v

Initial value:

is_maybe_blocking<PS>::value

value

static const char *const value

Definition: Conv.cpp:50

Definition at line 243 of file concepts.h.

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::is_never_blocking_v

Initial value:

is_never_blocking<PS>::value

value

static const char *const value

Definition: Conv.cpp:50

Definition at line 225 of file concepts.h.

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::is_receiver_v = is_receiver<PS>::value

Definition at line 122 of file concepts.h.

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::is_sender_v = is_sender<PS>::value

Definition at line 141 of file concepts.h.

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::is_single_v = is_single<PS>::value

Definition at line 77 of file concepts.h.

template<class PS >

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::is_time_v = is_time<PS>::value

Definition at line 190 of file concepts.h.

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_constrained_single_sender_fn folly::pushmi::make_constrained_single_sender

Referenced by folly::pushmi::make_constrained_single_sender_fn::operator()().

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_flow_many_sender_fn folly::pushmi::make_flow_many_sender

Referenced by folly::pushmi::operators::flow_from_fn::operator()(), and folly::pushmi::make_flow_many_sender_fn::operator()().

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_flow_receiver_fn folly::pushmi::make_flow_receiver

Referenced by folly::pushmi::detail::transform_on< F, is_many<>, true >::operator()().

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_flow_single_sender_fn folly::pushmi::make_flow_single_sender

Referenced by folly::pushmi::make_flow_single_sender_fn::operator()().

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_many_sender_fn folly::pushmi::make_many_sender

Referenced by folly::pushmi::operators::from_fn::operator()(), and folly::pushmi::make_many_sender_fn::operator()().

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_receiver_fn folly::pushmi::make_receiver

Referenced by folly::pushmi::operators::flow_from_up< Producer >::done(), folly::pushmi::operators::flow_from_up< Producer >::error(), folly::pushmi::operators::bulk_fn::operator()(), folly::pushmi::detail::on_fn::out_impl< In, ExecutorFactory >::operator()(), folly::pushmi::detail::transform_on< F, is_single<> >::operator()(), folly::pushmi::detail::via_fn::on_value_impl< Out >::operator()(), folly::pushmi::detail::on_fn::time_out_impl< In, ExecutorFactory >::operator()(), folly::pushmi::detail::via_fn::on_error_impl< Out >::operator()(), folly::pushmi::detail::transform_on< F, is_many<> >::operator()(), folly::pushmi::detail::via_fn::on_done_impl< Out >::operator()(), folly::pushmi::operators::flow_from_fn::out_impl< I, S, Exec >::operator()(), folly::pushmi::detail::get_fn< T >::operator()(), and folly::pushmi::operators::flow_from_up< Producer >::value().

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_single_sender_fn folly::pushmi::make_single_sender

Referenced by folly::pushmi::operators::empty(), folly::pushmi::operators::error(), get_setting(), folly::pushmi::operators::bulk_fn::operator()(), folly::pushmi::operators::defer_fn::operator()(), folly::pushmi::operators::just_fn::operator()(), folly::pushmi::make_single_sender_fn::operator()(), and TEST_F().

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::make_time_single_sender_fn folly::pushmi::make_time_single_sender

Referenced by folly::pushmi::make_time_single_sender_fn::operator()().

PUSHMI_INLINE_VAR constexpr __adl::get_top_fn folly::pushmi::now {}

Definition at line 361 of file extension_points.h.

Referenced by folly::pushmi::any_time_executor_ref< E, TP >::any_time_executor_ref().

template<bool... Bs>

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::or_v

Initial value:

= !PUSHMI_PP_IS_SAME(
    detail::bools<Bs..., false>,
    detail::bools<false, Bs...>)

Definition at line 66 of file traits.h.

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::pipe_fn folly::pushmi::pipe

Referenced by main(), and folly::pushmi::pipe_fn::operator()().

template<class PS , class... ExpectedN>

PUSHMI_INLINE_VAR constexpr bool folly::pushmi::property_query_v

Initial value:

property_query<PS, ExpectedN...>::value

value

static const char *const value

Definition: Conv.cpp:50

Definition at line 176 of file properties.h.

Referenced by folly::pushmi::detail::transform_fn::impl< F >::operator()().

constexpr const recurse_t folly::pushmi::recurse {}

Definition at line 28 of file trampoline.h.

Referenced by folly::pushmi::detail::repeat().

PUSHMI_INLINE_VAR constexpr struct folly::pushmi::reduce_fn folly::pushmi::reduce

Referenced by main(), and folly::pushmi::reduce_fn::operator()().

template<bool B>

constexpr std::enable_if_t<B, int> folly::pushmi::requires_ = 0

Definition at line 554 of file concept_def.h.

PUSHMI_INLINE_VAR constexpr __adl::set_done_fn folly::pushmi::set_done {}

Definition at line 355 of file extension_points.h.

PUSHMI_INLINE_VAR constexpr __adl::set_error_fn folly::pushmi::set_error {}

Definition at line 356 of file extension_points.h.

PUSHMI_INLINE_VAR constexpr __adl::set_starting_fn folly::pushmi::set_starting {}

Definition at line 358 of file extension_points.h.

Referenced by folly::pushmi::any_flow_receiver< PE, PV, E, VN >::any_flow_receiver(), ConcurrentFlowManySender::cancellation_test(), ImmediateFlowSingleSender::make_producer(), ImmediateFlowManySender::make_producer(), folly::pushmi::__adl::set_starting_fn::noexcept(), folly::pushmi::operators::flow_from_fn::out_impl< I, S, Exec >::operator()(), folly::pushmi::detail::set_starting_fn::impl< Up >::operator()(), folly::pushmi::__adl::requires(), folly::pushmi::detail::tap_::starting(), inline_executor_flow_single< CancellationFactory >::submit(), inline_executor_flow_single_ignore::submit(), inline_executor_flow_many::submit(), and inline_executor_flow_many_ignore::submit().

PUSHMI_INLINE_VAR constexpr __adl::set_value_fn folly::pushmi::set_value {}

Definition at line 357 of file extension_points.h.

PUSHMI_INLINE_VAR constexpr __adl::do_submit_fn folly::pushmi::submit {}

Definition at line 360 of file extension_points.h.

template<int... Is>

PUSHMI_INLINE_VAR constexpr int folly::pushmi::sum_v = detail::sum_impl<Is...>()

Definition at line 71 of file traits.h.

requires Tuple&& folly::pushmi::t

Initial value:

{

return detail::apply_impl((F &&) f, (Tuple &&) t, detail::tupidxs<Tuple>{})

auto f

Definition: PushmiBenchmarks.cpp:515

folly::pushmi::t

requires Tuple && t

Definition: extension_operators.h:60

Definition at line 60 of file extension_operators.h.

Referenced by folly::pushmi::for_each_fn::identity::operator()(), folly::pushmi::reduce_fn::identity::operator()(), folly::pushmi::__adl::set_value(), and folly::pushmi::new_thread_executor::submit().

PUSHMI_INLINE_VAR constexpr __adl::get_top_fn folly::pushmi::top {}

Definition at line 362 of file extension_points.h.

Referenced by folly::pushmi::any_constrained_executor_ref< E, CV >::any_constrained_executor_ref(), folly::pushmi::any_constrained_single_sender< E, TP, VN... >::any_constrained_single_sender(), folly::exception_tracer::StackTraceStack::empty(), folly::pushmi::time_source_queue< E, TP, NF, Executor >::error(), folly::ConcurrentSkipList< T, Comp, NodeAlloc, MAX_HEIGHT >::findNodeRightDown(), getExceptionStackTraceStack(), folly::pushmi::__adl::do_submit_fn::noexcept(), folly::pushmi::passDZF::operator()(), folly::pushmi::__adl::requires(), folly::pushmi::__adl::get_top_fn::requires(), folly::pushmi::detail::blocking_submit_fn::nested_executor_impl::top(), and folly::pushmi::time_source_queue< E, TP, NF, Executor >::value().

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation