Introduce WithExecutor adaptor

Author: srijs

futures-core/src/task/context.rs

@@ -110,6 +110,19 @@ if_std! {
                 .expect("No default executor found")
                 .spawn(Box::new(f)).unwrap()
         }
+
+        /// Produce a context like the current one, but using the given executor
+        /// instead.
+        ///
+        /// This advanced method is primarily used when building "internal
+        /// schedulers" within a task.
+        pub fn with_executor<'b>(&'b mut self, executor: &'b mut Executor)
+                            -> Context<'b>
+        {
+            self.with_parts(move |waker, map, _| {
+                Context { map, executor: Some(executor), waker }
+            })
+        }
     }
 }
 

futures-util/src/future/mod.rs

@@ -61,11 +61,13 @@ if_std! {
     mod select_all;
     mod select_ok;
     mod shared;
+    mod with_executor;
     pub use self::catch_unwind::CatchUnwind;
     pub use self::join_all::{join_all, JoinAll};
     pub use self::select_all::{SelectAll, SelectAllNext, select_all};
     pub use self::select_ok::{SelectOk, select_ok};
     pub use self::shared::{Shared, SharedItem, SharedError};
+    pub use self::with_executor::WithExecutor;
 }
 
 impl<T: ?Sized> FutureExt for T where T: Future {}
@@ -875,6 +877,33 @@ pub trait FutureExt: Future {
     {
         recover::new(self, f)
     }
+
+    /// Assigns the provided `Executor` to be used when spawning tasks
+    /// from within the future.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # extern crate futures;
+    /// # extern crate futures_executor;
+    /// use futures::prelude::*;
+    /// use futures::future;
+    /// use futures_executor::{block_on, spawn, ThreadPool};
+    ///
+    /// # fn main() {
+    /// let pool = ThreadPool::new();
+    /// let future = future::ok::<(), _>(());
+    /// let spawn_future = spawn(future).with_executor(pool);
+    /// assert_eq!(block_on(spawn_future), Ok(()));
+    /// # }
+    /// ```
+    #[cfg(feature = "std")]
+    fn with_executor<E>(self, executor: E) -> WithExecutor<Self, E>
+        where Self: Sized,
+              E: ::futures_core::executor::Executor
+    {
+        with_executor::new(self, executor)
+    }
 }
 
 // Just a helper function to ensure the futures we're returning all have the

futures-util/src/future/with_executor.rs

@@ -0,0 +1,33 @@
+use futures_core::{Future, Poll};
+use futures_core::task;
+use futures_core::executor::Executor;
+
+/// Future for the `with_executor` combinator, assigning an executor
+/// to be used when spawning other futures.
+///
+/// This is created by the `Future::with_executor` method.
+#[derive(Debug)]
+#[must_use = "futures do nothing unless polled"]
+pub struct WithExecutor<F, E> where F: Future, E: Executor {
+    executor: E,
+    future: F
+}
+
+pub fn new<F, E>(future: F, executor: E) -> WithExecutor<F, E>
+    where F: Future,
+          E: Executor,
+{
+    WithExecutor { executor, future }
+}
+
+impl<F, E> Future for WithExecutor<F, E>
+    where F: Future,
+          E: Executor,
+{
+    type Item = F::Item;
+    type Error = F::Error;
+
+    fn poll(&mut self, cx: &mut task::Context) -> Poll<F::Item, F::Error> {
+        self.future.poll(&mut cx.with_executor(&mut self.executor))
+    }
+}