add poll_fn

futures-combinators/src/join.rs

···
 use futures_core::{ScopedFuture, Wake};
 use futures_util::{MaybeDone, MaybeDoneState, maybe_done};
-use std::cell::{Cell, UnsafeCell};
-use std::sync::atomic::Ordering;
-use std::{sync::atomic::AtomicBool, task::Poll};
+use std::{cell::Cell, task::Poll};
 
-/// from yoshuawuyts/futures-concurrency
+/// from [futures-concurrency](https://github.com/yoshuawuyts/futures-concurrency/tree/main)
 /// Wait for all futures to complete.
 ///
 /// Awaits multiple futures simultaneously, returning the output of the futures
···
 pub trait Join<'scope> {
     /// The resulting output type.
     type Output;
+
     /// The [`ScopedFuture`] implementation returned by this method.
     type Future: ScopedFuture<'scope, Output = Self::Output>;
+
     /// Waits for multiple futures to complete.
     ///
     /// Awaits multiple futures simultaneously, returning the output of the futures
     /// in the same container type they we're created once all complete.
     ///
-    /// # Examples
-    ///
-    /// Awaiting multiple futures of the same type can be done using either a vector
-    /// or an array.
-    /// ```rust
-    /// #  futures::executor::block_on(async {
-    /// use futures_concurrency::prelude::*;
-    ///
-    /// // all futures passed here are of the same type
-    /// let fut1 = core::future::ready(1);
-    /// let fut2 = core::future::ready(2);
-    /// let fut3 = core::future::ready(3);
-    ///
-    /// let outputs = [fut1, fut2, fut3].join().await;
-    /// assert_eq!(outputs, [1, 2, 3]);
-    /// # })
-    /// ```
-    ///
-    /// In practice however, it's common to want to await multiple futures of
-    /// different types. For example if you have two different `async {}` blocks,
-    /// you want to `.await`. To do that, you can call `.join` on tuples of futures.
-    /// ```rust
-    /// #  futures::executor::block_on(async {
-    /// use futures_concurrency::prelude::*;
-    ///
-    /// async fn some_async_fn() -> usize { 3 }
-    ///
-    /// // the futures passed here are of different types
-    /// let fut1 = core::future::ready(1);
-    /// let fut2 = async { 2 };
-    /// let fut3 = some_async_fn();
-    /// //                       ^ NOTE: no `.await` here!
-    ///
-    /// let outputs = (fut1, fut2, fut3).join().await;
-    /// assert_eq!(outputs, (1, 2, 3));
-    /// # })
-    /// ```
-    ///
-    /// <br><br>
     /// This function returns a new future which polls all futures concurrently.
     fn join(self) -> Self::Future;
 }
 
 struct WakeStore<'scope> {
     parent: Cell<Option<&'scope dyn Wake<'scope>>>,
-    ready: AtomicBool,
+    ready: Cell<bool>,
 }
 
 impl<'scope> WakeStore<'scope> {
···
         }
     }
     fn take_ready(&self) -> bool {
-        self.ready.swap(false, Ordering::SeqCst)
+        self.ready.replace(false)
     }
 }
 
 impl<'scope> Wake<'scope> for WakeStore<'scope> {
     fn wake(&self) {
-        self.ready.swap(true, Ordering::SeqCst);
+        self.ready.replace(true);
         if let Some(parent) = &self.parent.get() {
             parent.wake();
         }
···
         }
 
         #[allow(non_snake_case)]
+        #[must_use = "futures do nothing unless you `.await` or poll them"]
         pub struct $StructName<'scope, $($F: ScopedFuture<'scope>),+> {
             $($F: MaybeDone<'scope, $F>,)*
             wakers: $namespace::Wakers<'scope>,
···
 impl_join_tuple!(join10 Join10 A B C D E F G H I J);
 impl_join_tuple!(join11 Join11 A B C D E F G H I J K);
 impl_join_tuple!(join12 Join12 A B C D E F G H I J K L);
+
+#[cfg(test)]
+mod tests {
+    use futures_util::poll_fn;
+
+    use super::*;
+
+    #[test]
+    fn basic() {
+        let f1 = poll_fn(|_| Poll::Ready(1));
+        let f2 = poll_fn(|_| Poll::Ready(2));
+        let dummy_waker = WakeStore::new();
+        assert_eq!((f1, f2).join().poll(&dummy_waker), Poll::Ready((1, 2)));
+    }
+}

futures-util/src/lib.rs

···
 mod maybe_done;
+mod poll_fn;
 
 use futures_core::ScopedFuture;
 pub use maybe_done::*;
+pub use poll_fn::poll_fn;
 
 // Just a helper function to ensure the futures we're returning all have the
 // right implementations.

futures-util/src/maybe_done.rs

···
     task::{Poll, ready},
 };
 
+#[must_use = "futures do nothing unless you `.await` or poll them"]
 pub struct MaybeDone<'scope, Fut: ScopedFuture<'scope>> {
     state: UnsafeCell<MaybeDoneState<'scope, Fut>>,
 }

futures-util/src/poll_fn.rs

···
+use core::fmt;
+use std::task::Poll;
+
+use futures_core::{ScopedFuture, Wake};
+
+use crate::assert_future;
+
+/// Future for the [`poll_fn`] function.
+#[must_use = "futures do nothing unless you `.await` or poll them"]
+pub struct PollFn<F> {
+    f: F,
+}
+
+/// Creates a new future wrapping around a function returning [`Poll`].
+///
+/// Polling the returned future delegates to the wrapped function.
+///
+/// # Examples
+///
+/// ```
+/// # futures::executor::block_on(async {
+/// use futures::future::poll_fn;
+/// use futures::task::{Context, Poll};
+///
+/// fn read_line(_cx: &mut Context<'_>) -> Poll<String> {
+///     Poll::Ready("Hello, World!".into())
+/// }
+///
+/// let read_future = poll_fn(read_line);
+/// assert_eq!(read_future.await, "Hello, World!".to_owned());
+/// # });
+/// ```
+pub fn poll_fn<'scope, T, F>(f: F) -> PollFn<F>
+where
+    F: Fn(&'scope dyn Wake) -> Poll<T>,
+{
+    assert_future::<T, _>(PollFn { f })
+}
+
+impl<F> fmt::Debug for PollFn<F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("PollFn").finish()
+    }
+}
+
+impl<'scope, T, F> ScopedFuture<'scope> for PollFn<F>
+where
+    F: Fn(&'scope dyn Wake) -> Poll<T>,
+{
+    type Output = T;
+
+    fn poll(&self, wake: &'scope dyn Wake) -> Poll<T> {
+        (&self.f)(wake)
+    }
+}