convenience Future ext methods: meanwhile and pend_after

Author: wishawa

async_ui_web/src/lib.rs

@@ -43,14 +43,15 @@ pub mod event_traits {
 
 pub mod shortcut_traits {
     /*!
-    Convenience traits. Includes traits for manipulating element classes and rendering str.
+    Traits provided for convenience.
      */
     pub use super::shortcuts::{ShortcutClassList, ShortcutClassListBuilder, ShortcutRenderStr};
+    pub use async_ui_web_core::combinators::UiFutureExt;
 }
 
 pub mod prelude_traits {
     /*!
-    Includes traits from [event_traits][super::event_traits]
+    Includes all traits from [event_traits][super::event_traits]
     and [shortcut_traits][super::shortcut_traits].
     ```
     use async_ui_web::prelude_traits::*;
@@ -59,6 +60,7 @@ pub mod prelude_traits {
     pub use super::shortcuts::{
         ShortcutClassList as _, ShortcutClassListBuilder as _, ShortcutRenderStr as _,
     };
+    pub use async_ui_web_core::combinators::UiFutureExt as _;
     pub use async_ui_web_html::events::{
         EmitElementEvent as _, EmitEvent as _, EmitHtmlElementEvent as _,
     };

async_ui_web_core/src/combinators/extras/mod.rs

@@ -0,0 +1,77 @@
+use std::{future::Future, marker::PhantomData};
+
+/// Provides Future extension methods useful for writing UI.
+///
+/// Implemented for every `Future` type.
+pub trait UiFutureExt: Future + Sized {
+    /// Turn the given future into one that never finishes.
+    ///
+    /// You can specify the output type of the output future to be anything,
+    /// because the future will never produce output.
+    ///
+    /// ```rust
+    /// # async fn my_async_fn() {}
+    /// use async_ui_web_core::combinators::UiFutureExt;
+    /// let fut = my_async_fn().pend_after::<std::convert::Infallible>();
+    /// fut.await; // will never finish
+    /// ```
+    ///
+    /// `f.pend_after()` is equivalent to
+    /// ```rust
+    /// # let f = async {};
+    /// async {
+    /// 	f.await;
+    /// 	std::future::pending()
+    /// }
+    /// ```
+    fn pend_after<T>(self) -> PendAfter<Self, T> {
+        PendAfter {
+            future: Some(self),
+            _phantom: PhantomData,
+        }
+    }
+    /// Run some Future while this one is running.
+    ///
+    /// `f.meanwhile(g)` is equivalent to
+    /// ```rust
+    /// # let (f, g) = (async {}, async{});
+    /// # use async_ui_web_core::combinators::{UiFutureExt, race};
+    /// race((
+    /// 	f,
+    /// 	g.pend_after()
+    /// ))
+    /// ```
+    fn meanwhile<F: Future>(
+        self,
+        effect: F,
+    ) -> <(Self, PendAfter<F, Self::Output>) as super::race::Race>::Future {
+        use super::race::Race;
+        (self, effect.pend_after()).race()
+    }
+}
+
+impl<F: Future> UiFutureExt for F {}
+
+#[pin_project::pin_project]
+pub struct PendAfter<F: Future, T> {
+    #[pin]
+    future: Option<F>,
+    _phantom: PhantomData<T>,
+}
+
+impl<F: Future, T> Future for PendAfter<F, T> {
+    type Output = T;
+
+    fn poll(
+        self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Self::Output> {
+        let mut this = self.project();
+        if let Some(fut) = this.future.as_mut().as_pin_mut() {
+            if fut.poll(cx).is_ready() {
+                this.future.set(None);
+            }
+        }
+        std::task::Poll::Pending
+    }
+}

async_ui_web_core/src/combinators/mod.rs

@@ -1,10 +1,13 @@
 mod common;
+mod extras;
 mod join;
 mod race;
 mod race_ok;
 mod try_join;
 mod utils;
 
+pub use extras::UiFutureExt;
+
 /// Wait for multiple futures to complete.
 ///
 /// Join takes in many "subfutures" and return a single Future.