Struct Task

pub struct Task<'a, T = (), E = ()> { /* private fields */ }

Tasks can be used to execute code in Task Kit’s runner thread pool. This is the key primive of this crate. It can be used to build and organize asyncronous code paths.

For more on how to use tasks see the crate documentation.

#Examples

Polling example:

let mut i = 0;
let task: Task<u32, ()> = Task::new(move || {
  if i < 100 {
    i += 1;
    Pending
  } else {
    Resolve(i)
  }
});

Long running example:

let task: Task<u32, ()> = Task::with(move || {
  let mut i = 0;
  while i < 100 {
    i += 1;
  }
  i
});

Implementations

impl<'a, T, E> Task<'a, T, E>

where T: 'a, E: 'a,

pub fn new<F>(task: F) -> Self

where F: FnMut() -> State<T, E> + 'a,

Create a new task from a closure returning a State

Provide the new function a closure that contains the logic you wish to execute asyncronously. This closure will be executed upon the thread pool within the runner until your closure returns an instance of State::Resolve containing a value or an instance of State::Reject containing an error value.

Arguments

• task - A closure containing code to be executed asyncronously by the runner.

Examples

let task: Task<String, ()> = Task::new(|| Resolve(do_something_blocking()));

pub fn from(val: T) -> Self

Create a new task from a value.

Useful only in cases where you need to pass a task to something, but already have the value you wish to resolve.

Arguments

• val - The value you’d like the task to resolve

Examples

let task: Task<String, ()> = Task::from(my_string);

pub fn with<F>(with: F) -> Self

where F: FnMut() -> T + 'a,

Create a new task from a closure returning a value.

The closure will only be executed once by the runner, and is expected to return the value you wish to resolve.

Arguments

• with - A closure that will return the value you’d like the task to resolve.

Examples

let task: Task<String, ()> = Task::with(|| do_something_blocking());

pub fn join<U>(self, task: Task<'a, U, E>) -> Task<'a, (T, U), E>

where U: 'a,

Create a new merged task from the current task instance and a second task

Join will return a new task that will resolve a tuple containing the results from both the task join is called upon, and the task passed in.

Both the current task and the second task passed in will still execute in parallel.

Arguments

• task - A second task to join with the current task

Examples

let merged_task = my_task.join(my_other_task);

pub fn state(&self) -> &State<T, E>

Get the task state

Returns a reference to the internal state of the task

pub fn poll(&mut self) -> Option<Result<T, E>>

Executes the closure within the task once

If the task resolves or rejects then the returned option will contain a result object.

pub fn wait(self) -> Option<Result<T, E>>

Executes the closure within the task blocking until the task completes

pub fn map<F, U>(self, map: F) -> Task<'a, U, E>

where F: FnMut(T) -> U + 'a, U: 'a,

pub fn then<F, U>(self, task: F) -> Task<'a, U, E>

where F: FnMut(T) -> State<U, E> + 'a, U: 'a,

pub fn done<F>(self, done: F) -> Task<'a, (), E>

where F: FnMut(T) + 'a,

pub fn recover<F, O>(self, recover: F) -> Task<'a, T, O>

where F: FnMut(E) -> State<T, O> + 'a, O: 'a,

pub fn catch<F>(self, catch: F) -> Task<'a, T, ()>

where F: FnMut(E) + 'a,

impl<'a, T, E> Task<'a, T, E>

where T: PartialEq + 'a, E: PartialEq + 'a,

pub fn eq(self, task: Task<'a, T, E>) -> Task<'a, bool, E>

pub fn ne(self, task: Task<'a, T, E>) -> Task<'a, bool, E>

impl<'a, T, E> Task<'a, T, E>

where T: PartialOrd + 'a, E: PartialOrd + 'a,

pub fn lt(self, task: Task<'a, T, E>) -> Task<'a, bool, E>

pub fn le(self, task: Task<'a, T, E>) -> Task<'a, bool, E>

pub fn gt(self, task: Task<'a, T, E>) -> Task<'a, bool, E>

pub fn ge(self, task: Task<'a, T, E>) -> Task<'a, bool, E>

Trait Implementations

impl<'a, T, E> Debug for Task<'a, T, E>

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

Formats the value using the given formatter.

impl<'a, T, E> Executable for Task<'a, T, E>

fn exec(&mut self) -> bool

Execute the task or other custom type

impl<'a, T, E> Send for Task<'a, T, E>

impl<'a, T, E> Sync for Task<'a, T, E>