Owned version of Notified<'_>

[Razz4780]

Several times I've found myself frustrated with Notify semantics. Notify::notify_waiters allows for notifying only those Notified instances that were acquired before the call. This makes it hard to use this interface when working with background tasks.

Example:

async fn example() {
    let notify = Arc::new(Notify::new());

    for _ in 0..10 {
        let notify = notify.clone();
        tokio::spawn(async move {
            let notified = notify.notified();

            tokio::select! {
                _ = some_logic() => {},
                _ = notified => {}
            }

            some_cleanup().await;
        });
    }

    some_other_logic().await;

    notify.notify_waiters();
}

In the snippet above, spawned background tasks may not pick up the notification from the Notify::notify_waiters call. It seems to me that Notify was designed specifically for this kind of problems. However, the interface does not allow for a safe solution, as Notified cannot be sent between tasks.

I can work around this problem by using other primitives, like a Semaphore or a Shared<oneshot::Receiver> that never receives any value (instead, waits for the sender to be dropped), but I think Notify would be much simpler and easier to understand.

Would be nice to have an owned version of Notified, e.g like this:

impl Notify {
    pub fn notified_owned(self: Arc<Self>) -> NotifiedOwned { ... }
}

If this sounds ok, I'm willing to implement it

[Daniel-Aaron-Bloom]

As an alternative, this is presently doable (but a bit painful) with ouroboros or similar.

#[ouroboros::self_referencing]
struct NotifyOwnedData {
    data: Arc<Notify>,

    #[borrows(data)]
    #[not_covariant]
    borrowed: Pin<Box<Notified<'this>>>,
}

pub struct NotifyOwned(NotifyOwnedData);

impl NotifyOwned {
    fn notified(data: Arc<Notify>) -> Self {
        Self(NotifyOwnedDataBuilder {
            data,
            borrowed_builder: move |data: &Arc<Notify>| {
                Box::pin(data.notified())
            },
        }
        .build())
    }
}

impl Future for NotifyOwned {
    type Output = ();

    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
        self.0.with_borrowed_mut(|b| {
            b.as_mut().poll(cx)
        })
    }
}