Enum Expr 

pub enum Expr {
    Literal(Value),
    VarRef(VarPath),
    Interpolated(Vec<StringPart>),
    BinaryOp {
        left: Box<Expr>,
        op: BinaryOp,
        right: Box<Expr>,
    },
    CommandSubst(Box<Pipeline>),
    Test(Box<TestExpr>),
    Positional(usize),
    AllArgs,
    ArgCount,
    VarLength(String),
    VarWithDefault {
        name: String,
        default: Vec<StringPart>,
    },
    Arithmetic(String),
    Command(Command),
    LastExitCode,
    CurrentPid,
}

An expression that evaluates to a value.

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"

BinaryOp

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

Fields

left: Box<Expr>

op: BinaryOp

right: Box<Expr>

CommandSubst(Box<Pipeline>)

Command substitution: $(pipeline) - runs a pipeline and returns its result

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(String)

Variable string length: ${#VAR}

VarWithDefault

Variable with default: ${VAR:-default} - use default if VAR is unset or empty The default can contain nested variable expansions and command substitutions

Fields

name: String

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: $$

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

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 StructuralPartialEq for Expr