Enum CompoundKind 

#[non_exhaustive]
pub enum CompoundKind<'a> {
    For {
        var: &'a str,
        words: Option<Vec<Word<'a>>>,
        body: Vec<Cmd<'a>>,
    },
    While(GuardBody<'a>),
    Until(GuardBody<'a>),
    If {
        conditionals: Vec<GuardBody<'a>>,
        else_branch: Option<Vec<Cmd<'a>>>,
    },
    Case {
        word: Word<'a>,
        arms: Vec<CaseArm<'a>>,
    },
    CFor {
        init: Option<Arith<'a>>,
        cond: Option<Arith<'a>>,
        step: Option<Arith<'a>>,
        body: Vec<Cmd<'a>>,
    },
    Brace(Vec<Cmd<'a>>),
    Subshell(Vec<Cmd<'a>>),
    DoubleBracket(Vec<Cmd<'a>>),
    Arithmetic(Arith<'a>),
}

The body of a compound command.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

For

for var [in words]; do body; done

Fields

var: &'a str

Loop variable name.

words: Option<Vec<Word<'a>>>

Word list (None = "$@").

body: Vec<Cmd<'a>>

Loop body commands.

While(GuardBody<'a>)

while guard; do body; done

Until(GuardBody<'a>)

until guard; do body; done

If

if cond; then body; [elif ...;] [else ...;] fi

Fields

conditionals: Vec<GuardBody<'a>>

Condition–body pairs (first is if, rest are elif).

else_branch: Option<Vec<Cmd<'a>>>

Optional else branch.

Case

case word in pattern) body;; ... esac

Fields

word: Word<'a>

The word being matched.

arms: Vec<CaseArm<'a>>

Pattern–body arms.

CFor

C-style for loop: for (( init; cond; step )); do body; done

Fields

init: Option<Arith<'a>>

Initialization expression.

cond: Option<Arith<'a>>

Condition expression.

step: Option<Arith<'a>>

Step expression.

body: Vec<Cmd<'a>>

Loop body commands.

Brace(Vec<Cmd<'a>>)

{ body; } — brace group.

Subshell(Vec<Cmd<'a>>)

( body ) — subshell.

DoubleBracket(Vec<Cmd<'a>>)

[[ expression ]] — extended test command.

Arithmetic(Arith<'a>)

(( expression )) — arithmetic command.

Trait Implementations

impl<'a> Clone for CompoundKind<'a>

fn clone(&self) -> CompoundKind<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for CompoundKind<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for CompoundKind<'a>

fn eq(&self, other: &CompoundKind<'a>) -> 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<'a> Eq for CompoundKind<'a>

impl<'a> StructuralPartialEq for CompoundKind<'a>