Struct ProcessHandle 

pub struct ProcessHandle<T> { /* private fields */ }

Handle to a spawned process. Resolves to the process’s return value.

Dropping the handle before awaiting detaches the process — it continues to run; its return value, if any, is dropped when the process completes.

use simu::SimEnv;

let mut env = SimEnv::with_seed(0);
let h = env.handle();
env.spawn(async move {
    let hc = h.clone();
    let child = h.spawn(async move {
        hc.timeout(3.0).await;
        "charged" // the child's return value
    });
    let result = child.await; // suspend until the child finishes
    assert_eq!(result, "charged");
    assert_eq!(h.now(), 3.0);
});
env.run();

Implementations

impl<T: 'static> ProcessHandle<T>

pub async fn discard(self)

Await the handle and discard the return value.

Useful with any_of! / all_of!, whose sub-futures must have Output = ().

Trait Implementations

impl<T> Debug for ProcessHandle<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: 'static> Future for ProcessHandle<T>

type Output = T

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<T>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.