Trait SpawnExt

pub trait SpawnExt: Spawn {
    // Provided methods
    fn spawn<Fut>(&self, future: Fut) -> Result<(), SpawnError>
       where Fut: Future<Output = ()> + Send + 'static { ... }
    fn spawn_with_handle<Fut>(
        &self,
        future: Fut,
    ) -> Result<RemoteHandle<Fut::Output>, SpawnError>
       where Fut: Future + Send + 'static,
             Fut::Output: Send { ... }
    fn compat(self) -> Compat<Self> 
       where Self: Sized { ... }
}

Extension trait for Spawn.

Provided Methods

fn spawn<Fut>(&self, future: Fut) -> Result<(), SpawnError>

where Fut: Future<Output = ()> + Send + 'static,

Spawns a task that polls the given future with output () to completion.

This method returns a Result that contains a SpawnError if spawning fails.

You can use spawn_with_handle if you want to spawn a future with output other than () or if you want to be able to await its completion.

Note this method will eventually be replaced with the upcoming Spawn::spawn method which will take a dyn Future as input. Technical limitations prevent Spawn::spawn from being implemented today. Feel free to use this method in the meantime.

use futures::executor::ThreadPool;
use futures::task::SpawnExt;

let executor = ThreadPool::new().unwrap();

let future = async { /* ... */ };
executor.spawn(future).unwrap();

fn spawn_with_handle<Fut>( &self, future: Fut, ) -> Result<RemoteHandle<Fut::Output>, SpawnError>

where Fut: Future + Send + 'static, Fut::Output: Send,

Available on crate feature channel only.

Spawns a task that polls the given future to completion and returns a future that resolves to the spawned future’s output.

This method returns a Result that contains a RemoteHandle, or, if spawning fails, a SpawnError. RemoteHandle is a future that resolves to the output of the spawned future.

use futures::executor::{block_on, ThreadPool};
use futures::future;
use futures::task::SpawnExt;

let executor = ThreadPool::new().unwrap();

let future = future::ready(1);
let join_handle_fut = executor.spawn_with_handle(future).unwrap();
assert_eq!(block_on(join_handle_fut), 1);

fn compat(self) -> Compat<Self>

where Self: Sized,

Available on crate feature compat only.

Wraps a Spawn and makes it usable as a futures 0.1 Executor. Requires the compat feature to enable.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<Sp> SpawnExt for Sp

where Sp: Spawn + ?Sized,