Enum CompoundCommandKind

pub enum CompoundCommandKind<V, W, C> {
    Brace(Vec<C>),
    Subshell(Vec<C>),
    While(GuardBodyPair<C>),
    Until(GuardBodyPair<C>),
    If {
        conditionals: Vec<GuardBodyPair<C>>,
        else_branch: Option<Vec<C>>,
    },
    For {
        var: V,
        words: Option<Vec<W>>,
        body: Vec<C>,
    },
    Case {
        word: W,
        arms: Vec<PatternBodyPair<W, C>>,
    },
}

A specific kind of a CompoundCommand.

Generic over the representation of shell words and commands.

Variants

Brace(Vec<C>)

A group of commands that should be executed in the current environment.

Subshell(Vec<C>)

A group of commands that should be executed in a subshell environment.

While(GuardBodyPair<C>)

A command that executes its body as long as its guard exits successfully.

Until(GuardBodyPair<C>)

A command that executes its body as until as its guard exits unsuccessfully.

If

A conditional command that runs the respective command branch when a certain of the first condition that exits successfully.

Fields

conditionals: Vec<GuardBodyPair<C>>

A list of conditional branch-body pairs.

else_branch: Option<Vec<C>>

An else part to run if no other conditional was taken.

For

A command that binds a variable to a number of provided words and runs its body once for each binding.

Fields

var: V

The variable to bind to each of the specified words.

words: Option<Vec<W>>

The words to bind to the specified variable one by one.

body: Vec<C>

The body to run with the variable binding.

Case

A command that behaves much like a match statment in Rust, running a branch of commands if a specified word matches another literal or glob pattern.

Fields

word: W

The word on which to check for pattern matches.

arms: Vec<PatternBodyPair<W, C>>

The arms to match against.

Trait Implementations

impl<V: Clone, W: Clone, C: Clone> Clone for CompoundCommandKind<V, W, C>

fn clone(&self) -> CompoundCommandKind<V, W, C>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V: Debug, W: Debug, C: Debug> Debug for CompoundCommandKind<V, W, C>

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

Formats the value using the given formatter.

impl<V: PartialEq, W: PartialEq, C: PartialEq> PartialEq for CompoundCommandKind<V, W, C>

fn eq(&self, other: &CompoundCommandKind<V, W, C>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V: Eq, W: Eq, C: Eq> Eq for CompoundCommandKind<V, W, C>

impl<V, W, C> StructuralPartialEq for CompoundCommandKind<V, W, C>