Struct Task 

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

A set of concurrent actions to be performed by the iced runtime.

A Task may produce a bunch of values of type T.

Implementations

impl<T> Task<T>

pub fn none() -> Task<T>

Creates a Task that does nothing.

pub fn done(value: T) -> Task<T>

where T: MaybeSend + 'static,

Creates a new Task that instantly produces the given value.

pub fn perform<A>( future: impl Future<Output = A> + MaybeSend + 'static, f: impl FnOnce(A) -> T + MaybeSend + 'static, ) -> Task<T>

where T: MaybeSend + 'static, A: MaybeSend + 'static,

Creates a Task that runs the given Future to completion and maps its output with the given closure.

pub fn run<A>( stream: impl Stream<Item = A> + MaybeSend + 'static, f: impl Fn(A) -> T + MaybeSend + 'static, ) -> Task<T>

where T: 'static,

Creates a Task that runs the given [Stream] to completion and maps each item with the given closure.

pub fn sip<S>( sipper: S, on_progress: impl FnMut(<S as Core>::Progress) -> T + MaybeSend + 'static, on_output: impl FnOnce(<S as Future>::Output) -> T + MaybeSend + 'static, ) -> Task<T>

where S: Core + MaybeSend + 'static, T: MaybeSend + 'static,

Creates a Task that runs the given Sipper to completion, mapping progress with the first closure and the output with the second one.

pub fn batch(tasks: impl IntoIterator<Item = Task<T>>) -> Task<T>

where T: 'static,

Combines the given tasks and produces a single Task that will run all of them in parallel.

pub fn map<O>(self, f: impl FnMut(T) -> O + MaybeSend + 'static) -> Task<O>

where T: MaybeSend + 'static, O: MaybeSend + 'static,

Maps the output of a Task with the given closure.

pub fn then<O>( self, f: impl FnMut(T) -> Task<O> + MaybeSend + 'static, ) -> Task<O>

where T: MaybeSend + 'static, O: MaybeSend + 'static,

Performs a new Task for every output of the current Task using the given closure.

This is the monadic interface of Task—analogous to Future and [Stream].

pub fn chain(self, task: Task<T>) -> Task<T>

where T: 'static,

Chains a new Task to be performed once the current one finishes completely.

pub fn collect(self) -> Task<Vec<T>>

where T: MaybeSend + 'static,

Creates a new Task that collects all the output of the current one into a Vec.

pub fn discard<O>(self) -> Task<O>

where T: MaybeSend + 'static, O: MaybeSend + 'static,

Creates a new Task that discards the result of the current one.

Useful if you only care about the side effects of a Task.

pub fn abortable(self) -> (Task<T>, Handle)

where T: 'static,

Creates a new Task that can be aborted with the returned Handle.

pub fn future(future: impl Future<Output = T> + MaybeSend + 'static) -> Task<T>

where T: 'static,

Creates a new Task that runs the given Future and produces its output.

pub fn stream(stream: impl Stream<Item = T> + MaybeSend + 'static) -> Task<T>

where T: 'static,

Creates a new Task that runs the given [Stream] and produces each of its items.

pub fn units(&self) -> usize

Returns the amount of work “units” of the Task.

impl<T> Task<Option<T>>

pub fn and_then<A>( self, f: impl Fn(T) -> Task<A> + MaybeSend + 'static, ) -> Task<A>

where T: MaybeSend + 'static, A: MaybeSend + 'static,

Executes a new Task after this one, only when it produces Some value.

The value is provided to the closure to create the subsequent Task.

impl<T, E> Task<Result<T, E>>

pub fn and_then<A>( self, f: impl Fn(T) -> Task<Result<A, E>> + MaybeSend + 'static, ) -> Task<Result<A, E>>

where T: MaybeSend + 'static, E: MaybeSend + 'static, A: MaybeSend + 'static,

Executes a new Task after this one, only when it succeeds with an Ok value.

The success value is provided to the closure to create the subsequent Task.

pub fn map_err<E2>( self, f: impl Fn(E) -> E2 + MaybeSend + 'static, ) -> Task<Result<T, E2>>

where T: MaybeSend + 'static, E: MaybeSend + 'static, E2: MaybeSend + 'static,

Maps the error type of this Task to a different one using the given function.

Trait Implementations

impl<T> Debug for Task<T>

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

Formats the value using the given formatter.

impl<T> Default for Task<T>

fn default() -> Task<T>

Returns the “default value” for a type.

impl<T> From<()> for Task<T>

fn from(_value: ()) -> Task<T>

Converts to this type from the input type.