timeout

fn timeout<T>(int ms, unit -> T body) -> Result<T, TaskError>

use task::{timeout};

Runs body as a task and cancels it if it has not finished after ms milliseconds.

Parameters#

Returns#

Result<T, TaskError>

Errors#

Err(TaskError::TimedOut) when the deadline passed first, and Err(TaskError::Panicked(message)) when body panicked.

Examples#

use task::{timeout, sleep, TaskError};
use tests::assert;
let r = timeout(10, fn () {
    sleep(1000);
    return 1;
});
let timed_out = match r {
    Result::Err(TaskError::TimedOut) => true,
    default => false,
};
assert!(timed_out);
assert!((timeout(1000, fn () => 7) ?? 0) == 7);

See also#

• scope: Runs body with a Scope for starting child tasks, and returns its value once body and every child have finished.
• sleep: Suspends the current task for at least ms milliseconds; other tasks run meanwhile.
• yield_now: Lets other ready tasks run before the current one continues.
• shield: Runs body so that a cancel waits for it to finish instead of interrupting it.
• channel: Creates a channel that holds up to capacity values.
• blocking: Runs work on another OS thread and waits for its result; only the current task waits, the others keep running.
• blocking_with: Like blocking, passing arg to work (it is copied to the other thread, like thread::spawn(work, arg)).
• block_on: Resumes the coroutine handle until it is done and returns its completion value; values it yields are discarded.