Enum CompoundCommand

pub enum CompoundCommand {
    Grouping(List),
    Subshell {
        body: Rc<List>,
        location: Location,
    },
    For {
        name: Word,
        values: Option<Vec<Word>>,
        body: List,
    },
    While {
        condition: List,
        body: List,
    },
    Until {
        condition: List,
        body: List,
    },
    If {
        condition: List,
        body: List,
        elifs: Vec<ElifThen>,
        else: Option<List>,
    },
    Case {
        subject: Word,
        items: Vec<CaseItem>,
    },
}

Command that contains other commands

Variants

Grouping(List)

List as a command

Subshell

Command for executing commands in a subshell

Fields

body: Rc<List>

location: Location

For

For loop

Fields

name: Word

values: Option<Vec<Word>>

body: List

While

While loop

Fields

condition: List

body: List

Until

Until loop

Fields

condition: List

body: List

If

If conditional construct

Fields

condition: List

body: List

elifs: Vec<ElifThen>

else: Option<List>

Case

Case conditional construct

Fields

subject: Word

items: Vec<CaseItem>

Trait Implementations

impl Clone for CompoundCommand

fn clone(&self) -> CompoundCommand

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CompoundCommand

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

Formats the value using the given formatter.

impl Display for CompoundCommand

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

Formats the value using the given formatter.

impl FromStr for CompoundCommand

Converts a string to a compound command.

type Err = Option<Error>

Optional error value

The error is None if the first token does not start a compound command. A proper error is returned in Some(_) in case of a syntax error.

fn from_str(s: &str) -> Result<CompoundCommand, Option<Error>>

Parses a string s to return a value of this type.

impl PartialEq for CompoundCommand

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

impl StructuralPartialEq for CompoundCommand