Struct cosmic::iced_winit::runtime::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 Fn(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 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.

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<A> + MaybeSend + 'static, ) -> Task<A>

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.

Trait Implementations

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

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

Converts to this type from the input type.