Struct Cmd 

pub struct Cmd(/* private fields */);

A command that produces a message when executed.

Commands are lazy - they don’t execute until the program runs them. This allows for pure update functions that return commands without side effects.

Example

use bubbletea::{Cmd, Message};
use std::time::Duration;

// A command that produces a message after a delay
fn delayed_message() -> Cmd {
    Cmd::new(|| {
        std::thread::sleep(Duration::from_secs(1));
        Message::new("done")
    })
}

Implementations

impl Cmd

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

where F: FnOnce() -> Message + Send + 'static,

Create a new command from a closure.

pub fn new_optional<F>(f: F) -> Self

where F: FnOnce() -> Option<Message> + Send + 'static,

Create a command that may not produce a message.

pub fn none() -> Option<Self>

Create an empty command that does nothing.

pub fn execute(self) -> Option<Message>

Execute the command and return the resulting message.

pub fn blocking<F>(f: F) -> Self

where F: FnOnce() -> Message + Send + 'static,

Create a command that performs blocking I/O.

This is semantically equivalent to Cmd::new() but makes the blocking intent explicit. When the async feature is enabled, blocking commands are automatically run on tokio’s blocking thread pool via spawn_blocking.

Use this for operations like:

• File I/O (std::fs::read, std::fs::write)
• Network operations with blocking APIs
• CPU-intensive computations
• Thread sleep operations

Example

use bubbletea::{Cmd, Message};

fn read_config() -> Cmd {
    Cmd::blocking(|| {
        let content = std::fs::read_to_string("config.toml").unwrap();
        Message::new(content)
    })
}

pub fn blocking_result<F, T, E, S, Err>( f: F, on_success: S, on_error: Err, ) -> Self

where F: FnOnce() -> Result<T, E> + Send + 'static, S: FnOnce(T) -> Message + Send + 'static, Err: FnOnce(E) -> Message + Send + 'static,

Create a command that performs a blocking operation returning a Result.

Converts Result<T, E> into a message, wrapping both success and error cases. This is convenient for I/O operations that can fail.

Example

use bubbletea::{Cmd, Message};
use std::io;

struct FileContent(String);
struct FileError(io::Error);

fn read_file(path: &'static str) -> Cmd {
    Cmd::blocking_result(
        move || std::fs::read_to_string(path),
        |content| Message::new(FileContent(content)),
        |err| Message::new(FileError(err)),
    )
}