Struct CommandFlow 

pub struct CommandFlow { /* private fields */ }

Available on crate feature std only.

🖥️ ⬡ An executable flow of OS process invocations.

---

^{📍 work/process}

---

A CommandFlow represents one or more Commands executed as a single unit. In the current implementation, commands are arranged linearly, connecting the stdout of each command to the stdin of the next.

Command flows are constructed programmatically (for example via cmd!) and do not involve a shell. As a result:

• No globbing, quoting, or redirection is performed.
• Each command is spawned directly via the OS process API.

Execution is eager: all commands in the flow are spawned before waiting for completion.

See also the cmd! macro for a compact construction syntax.

Implementations

impl CommandFlow

pub fn new(cmd: Command) -> Self

Creates a new flow with a single command.

This is equivalent to a flow of length 1, with no piping.

pub fn command_shell(line: &str) -> Result<Self, ShellWordError>

Available on crate feature shell only.

Creates a one-command flow from shell-like command words.

pub fn then(self, next: Command) -> Self

Appends a command to the flow, piping the previous command into it.

The stdout of the current command is connected to the stdin of next using an OS pipe.

This consumes the flow and returns an extended one, allowing chaining.

Panics

Panics if the flow is empty. This invariant is upheld by construction.

pub fn run(self) -> IoResult<ExitStatus>

Runs the flow and waits for all commands to complete.

All commands are spawned first. The method then waits for each process, returning the exit status of the last command in the flow.

Standard input, output, and error streams are inherited unless modified earlier (for example by piping or capture methods).

Errors

Returns an I/O error if any command fails to spawn or wait.

pub fn stdout(self) -> IoResult<Output>

Runs the flow and captures the standard output of the last command.

The stdout of the final command is redirected into a pipe and fully collected into a byte buffer.

All commands are spawned before any output is read. The method waits for all commands to complete and returns an Output containing the exit status and captured stdout. The stderr field is empty.

Notes

• Output is buffered in memory.
• Stderr is not captured.

Errors

Returns an I/O error if spawning, piping, reading, or waiting fails.

pub fn output(self) -> IoResult<Output>

Runs the flow and captures both stdout and stderr of the last command.

The stdout and stderr streams of the final command are merged into a single byte stream, equivalent to:

... | cmd 2>&1

Notes

• The relative ordering of stdout and stderr bytes is unspecified.
• Output is buffered in memory.

Returns an Output containing the exit status and merged stdout/stderr. The merged output is stored in Output.stdout; stderr is empty.

Errors

Returns an I/O error if spawning, piping, reading, or waiting fails.

pub fn stdout_with<F>(self, f: F) -> IoResult<ExitStatus>

where F: FnMut(&[u8]),

Runs the flow and streams the stdout of the last command to a callback.

The provided function f is invoked incrementally with chunks of bytes as they become available from the final command’s standard output.

This enables streaming consumption without buffering the full output in memory.

Execution model

• All commands are spawned eagerly.
• Bytes are read from the pipe in a loop.
• The callback is invoked on the reader thread.

Notes

• Only stdout of the last command is streamed.
• Stderr is inherited.

Returns the exit status of the last command.

Errors

Returns an I/O error if spawning, piping, reading, or waiting fails.

Trait Implementations

impl Debug for CommandFlow

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

Formats the value using the given formatter.