Enum Expr 

#[non_exhaustive]
pub enum Expr {
    Literal(Value),
    VarRef(VarPath),
    Interpolated(Vec<StringPart>),
    HereDocBody {
        parts: Vec<SpannedPart>,
        strip_tabs: bool,
    },
    Not(Box<Expr>),
    BinaryOp {
        left: Box<Expr>,
        op: BinaryOp,
        right: Box<Expr>,
    },
    CommandSubst(Vec<Stmt>),
    Test(Box<TestExpr>),
    Positional(usize),
    AllArgs,
    ArgCount,
    VarLength(VarPath),
    VarWithDefault {
        path: VarPath,
        default: Vec<StringPart>,
    },
    Arithmetic(String),
    Command(Command),
    LastExitCode,
    CurrentPid,
    GlobPattern(String),
    ListLiteral(Vec<ListElem>),
    RecordLiteral(Vec<RecordEntry>),
}

An expression that evaluates to a value.

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.

Literal(Value)

Literal value

VarRef(VarPath)

Variable reference: ${VAR} or ${VAR.field} or $VAR

Interpolated(Vec<StringPart>)

String with interpolation: "hello ${NAME}" or "hello $NAME"

HereDocBody

Interpolated heredoc body with per-part spans for diagnostic precision.

Heredoc bodies use this variant; double-quoted strings still use Interpolated to keep the existing path untouched. strip_tabs is true for the <<-EOF form — leading tabs on each body line are stripped from StringPart::Literal content at materialization time (POSIX semantics); offsets in parts reference the verbatim source so spans remain meaningful.

Fields

parts: Vec<SpannedPart>

strip_tabs: bool

Not(Box<Expr>)

Negated condition: ! cmd, ! [[ … ]].

Binds to the command that follows, not to the whole &&/|| chain — ! true && true is (! true) && true, which is bash’s reading and takes the else branch.

BinaryOp

Binary operation: a && b, a || b

Fields

left: Box<Expr>

op: BinaryOp

right: Box<Expr>

CommandSubst(Vec<Stmt>)

Command substitution: $(...) — runs a statement block (the full grammar: pipelines, &&/|| chains, ;/newline sequences, # comments) and returns its accumulated stdout. A single $(cmd) is a one-statement block.

Test(Box<TestExpr>)

Test expression: [[ -f path ]] or [[ $X == "value" ]]

Positional(usize)

Positional parameter: $0 through $9

AllArgs

All positional arguments: $@

ArgCount

Argument count: $#

VarLength(VarPath)

Variable string length: ${#VAR} or ${#path[sub]}

VarWithDefault

Variable with default: ${VAR:-default} / ${path[sub]:-default} — use default if the path is absent (unset root, missing key, out-of-bounds) or empty. The default can contain nested variable expansions and command substitutions.

Fields

path: VarPath

default: Vec<StringPart>

Arithmetic(String)

Arithmetic expansion: $((expr)) - evaluates to integer

Command(Command)

Command as condition: if grep -q pattern file; then - exit code determines truthiness

LastExitCode

Last exit code: $?

CurrentPid

Current shell PID: $$

GlobPattern(String)

Bare glob pattern: *.txt, src/**/*.rs — expanded during arg building

ListLiteral(Vec<ListElem>)

List literal: [a b c], [], [...$xs date]. Value-position only (assignment RHS, in/not in RHS, nested literal interiors) — never argv or a for-head item. See docs/LANGUAGE.md, “Construction — list/record literals”.

RecordLiteral(Vec<RecordEntry>)

Record literal: {name: amy, role: maintainer}, {port:8080} (colon may be spaced or unspaced). Value-position only, same as ListLiteral.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Expr