hkaiser changed the topic of #ste||ar to: STE||AR: Systems Technology, Emergent Parallelism, and Algorithm Research | stellar-group.org | HPX: A cure for performance impaired parallel applications | github.com/STEllAR-GROUP/hpx | This channel is logged: irclog.cct.lsu.edu
hkaiser has quit [Quit: Bye!]
K-ballo1 has joined #ste||ar
K-ballo has quit [Ping timeout: 268 seconds]
K-ballo1 is now known as K-ballo
zao has quit [*.net *.split]
zao has joined #ste||ar
ms[m] has quit [*.net *.split]
ms[m] has joined #ste||ar
Yorlik has joined #ste||ar
Yorlik has quit [Read error: Connection reset by peer]
<satacker[m]>
section 10.8.1.1 does not define `get_completion_signatures` for `is_awaitable<S,P>` . It's not even in their implementation.
<satacker[m]>
Ref: 4th point in above section
<satacker[m]>
CC hkaiser
<hkaiser_>
satacker[m]: could be an oversight
<satacker[m]>
This is what's bugging me for a couple of days
<hkaiser_>
otoh, get_completion_signatures is something that is exposed by senders
<hkaiser_>
is is_awaitable<> a sender?
<satacker[m]>
is_awaitable is not a sender
<hkaiser_>
satacker[m]: why should it expose get_completion_signatures, then
<satacker[m]>
sender is defined if it has valid completion signatures ig
<hkaiser_>
yes
<hkaiser_>
but if it's not a sender, then it shouldn't expose those
<satacker[m]>
it shouldn't
<hkaiser_>
right
<satacker[m]>
but get completion signatures should consider is a sender is an awaitable even when it has a promise type that is explicitly needed for it to be satisfied as an awaitable
<satacker[m]>
s/is/if/
<satacker[m]>
for example `is_awaitable<S>` may not be an awaitable, but `is_awaitable<S,P>` could be one
<hkaiser_>
satacker[m]: do you mean as_awaitable<>?
<satacker[m]>
no, `is_awaitable`
<hkaiser_>
so you're trying to implement the awaitable concept?
<satacker[m]>
When `is_awaitable_v<S>` is true, this will work right?
<hkaiser_>
what 'will work'?
<satacker[m]>
But if `is_awaitable_v<S>` is false, does this necessarily mean it's not an awaitable? It could be within a coroutine context i.e. a promise type. Is this correct?
<hkaiser_>
it says, that if _Sender is an awaitable, the completion signatures for _Sender should be generated as coded
<satacker[m]>
hkaiser_: `get_completion_signatures` will return some completion signatures other than `no such completion signature`
<hkaiser_>
yes, but that's the completion signatures for _Sender, not for is_awaitable<>
hkaiser has joined #ste||ar
<hkaiser>
if get_completion_signatures are requested for a type that is an awaitable (i.e. not a sender), then they are generated on the fly based on the type returned when awaiting on it
<satacker[m]>
`_Sender` may be an awaitable even if `is_awitable_v<_Sender>` is false
<hkaiser>
is_sender<_Sender> will most likely be false for awaitables (is_awaitable<_Sender> == true)
hkaiser_ has quit [Ping timeout: 244 seconds]
<satacker[m]>
yes, i am just saying that `is_awaitable<_Sender> ` maybe false even when _Sender is an awaitable
<hkaiser>
this is done so you can write: (co_await some_expr) | some_receiver
<hkaiser>
uhh, that doesn't sound right
<hkaiser>
is_awaitable<_Sender> will be true if _Sender is awaitable, what would be the sense in it otherwise?
<hkaiser>
or is there a 'special' is_awaitable<> that doesn't cover all things co_await could be used with?