Enum Cmd 

pub enum Cmd<Msg> {
    None,
    Batch(Vec<Cmd<Msg>>),
    Task(Pin<Box<dyn Future<Output = Msg> + Send + 'static>>),
    Msg(Msg),
}

A command representing a side effect to be executed

Commands are declarative descriptions of side effects. The runtime executes them and feeds resulting messages back into the update loop.

Variants

None

No side effect

Batch(Vec<Cmd<Msg>>)

Multiple commands to execute

Task(Pin<Box<dyn Future<Output = Msg> + Send + 'static>>)

An async task that produces a message

Msg(Msg)

Emit a message immediately (next frame)

Implementations

impl<Msg> Cmd<Msg>

pub fn none() -> Self

Create an empty command (no side effect)

pub fn batch(cmds: impl IntoIterator<Item = Cmd<Msg>>) -> Self

Create a batch of commands

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

where F: Future<Output = Msg> + Send + 'static,

Create a command from an async task

pub fn msg(msg: Msg) -> Self

Create a command that emits a message immediately

pub fn map<F, NewMsg>(self, f: F) -> Cmd<NewMsg>

where F: Fn(Msg) -> NewMsg + Send + Sync + Clone + 'static, Msg: Send + 'static, NewMsg: Send + 'static,

Map the message type

impl<Msg> Cmd<Msg>

pub fn is_none(&self) -> bool

Check if this is Cmd::None

pub fn is_task(&self) -> bool

Check if this is Cmd::Task

pub fn is_msg(&self) -> bool

Check if this is Cmd::Msg

pub fn is_batch(&self) -> bool

Check if this is Cmd::Batch

pub fn unwrap_msg(self) -> Msg

Get the message if this is Cmd::Msg, panics otherwise

Panics

Panics if the command is not Cmd::Msg

pub fn as_msg(&self) -> Option<&Msg>

Get the message if this is Cmd::Msg

pub fn as_batch(&self) -> Option<&[Cmd<Msg>]>

Get the batch if this is Cmd::Batch

pub fn len(&self) -> usize

Get the number of commands (1 for non-batch, n for batch, 0 for none)

pub fn is_empty(&self) -> bool

Check if empty (only true for Cmd::None)

impl<Msg: PartialEq> Cmd<Msg>

pub fn is_msg_eq(&self, expected: &Msg) -> bool

Check if this is Cmd::Msg with a specific message

impl<Msg: Debug> Cmd<Msg>

pub fn assert_none(&self)

Assert this is Cmd::None, panics with debug info otherwise

pub fn assert_task(&self)

Assert this is Cmd::Task, panics with debug info otherwise

pub fn assert_msg(&self)

Assert this is Cmd::Msg, panics with debug info otherwise

impl<Msg: Send + 'static> Cmd<Msg>

pub fn try_task<F, T, E, FnOk, FnErr>( future: F, on_ok: FnOk, on_err: FnErr, ) -> Self

where F: Future<Output = Result<T, E>> + Send + 'static, FnOk: FnOnce(T) -> Msg + Send + 'static, FnErr: FnOnce(E) -> Msg + Send + 'static,

Create a command from an async task that returns Result

Example

Cmd::try_task(
    async { fetch_user(id).await },
    |user| Msg::UserLoaded(user),
    |err| Msg::Error(err.to_string()),
)

pub fn from_result<T, E, FnOk, FnErr>( result: Result<T, E>, on_ok: FnOk, on_err: FnErr, ) -> Self

where FnOk: FnOnce(T) -> Msg, FnErr: FnOnce(E) -> Msg,

Create a command from a Result, converting to Msg immediately

Example

Cmd::from_result(
    parse_config(),
    |config| Msg::ConfigLoaded(config),
    |err| Msg::Error(err.to_string()),
)

Trait Implementations

impl<Msg> Default for Cmd<Msg>

fn default() -> Cmd<Msg>

Returns the “default value” for a type.