Enum Subst 

#[non_exhaustive]
pub enum Subst<'a> {
    Cmd(Vec<Cmd<'a>>),
    Arith(Option<Arith<'a>>),
    Len(Param<'a>),
    Indirect(&'a str),
    PrefixList(&'a str),
    Transform(&'a str, u8),
    Default(Param<'a>, Option<Word<'a>>),
    Assign(Param<'a>, Option<Word<'a>>),
    Error(Param<'a>, Option<Word<'a>>),
    Alt(Param<'a>, Option<Word<'a>>),
    TrimSuffixSmall(Param<'a>, Option<Word<'a>>),
    TrimSuffixLarge(Param<'a>, Option<Word<'a>>),
    TrimPrefixSmall(Param<'a>, Option<Word<'a>>),
    TrimPrefixLarge(Param<'a>, Option<Word<'a>>),
    Replace(Param<'a>, Option<Word<'a>>, Option<Word<'a>>),
    ReplaceAll(Param<'a>, Option<Word<'a>>, Option<Word<'a>>),
    ReplacePrefix(Param<'a>, Option<Word<'a>>, Option<Word<'a>>),
    ReplaceSuffix(Param<'a>, Option<Word<'a>>, Option<Word<'a>>),
    Substring(Param<'a>, &'a str, Option<&'a str>),
    Upper(bool, Param<'a>),
    Lower(bool, Param<'a>),
    ArrayElement(&'a str, Word<'a>),
    ArrayAll(&'a str),
    ArrayLen(&'a str),
    ArraySlice(&'a str, &'a str, Option<&'a str>),
}

A substitution or parameter expansion.

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.

Cmd(Vec<Cmd<'a>>)

Command substitution: $(cmd) or `cmd`.

Arith(Option<Arith<'a>>)

Arithmetic expansion: $((expr)).

Len(Param<'a>)

String length: ${#var}.

Indirect(&'a str)

${!var} — indirect variable expansion.

PrefixList(&'a str)

${!prefix*} / ${!prefix@} — list variables matching prefix.

Transform(&'a str, u8)

${var@Q} — parameter transformation (quoting).

Default(Param<'a>, Option<Word<'a>>)

${var:-word} / ${var-word} — default value.

Assign(Param<'a>, Option<Word<'a>>)

${var:=word} / ${var=word} — assign default.

Error(Param<'a>, Option<Word<'a>>)

${var:?word} / ${var?word} — error if unset.

Alt(Param<'a>, Option<Word<'a>>)

${var:+word} / ${var+word} — alternate value.

TrimSuffixSmall(Param<'a>, Option<Word<'a>>)

${var%pattern} — remove shortest suffix match.

TrimSuffixLarge(Param<'a>, Option<Word<'a>>)

${var%%pattern} — remove longest suffix match.

TrimPrefixSmall(Param<'a>, Option<Word<'a>>)

${var#pattern} — remove shortest prefix match.

TrimPrefixLarge(Param<'a>, Option<Word<'a>>)

${var##pattern} — remove longest prefix match.

Replace(Param<'a>, Option<Word<'a>>, Option<Word<'a>>)

${var/pattern/replacement} — replace first match.

ReplaceAll(Param<'a>, Option<Word<'a>>, Option<Word<'a>>)

${var//pattern/replacement} — replace all matches.

ReplacePrefix(Param<'a>, Option<Word<'a>>, Option<Word<'a>>)

${var/#pattern/replacement} — replace prefix match.

ReplaceSuffix(Param<'a>, Option<Word<'a>>, Option<Word<'a>>)

${var/%pattern/replacement} — replace suffix match.

Substring(Param<'a>, &'a str, Option<&'a str>)

${var:offset:length} — substring extraction.

Upper(bool, Param<'a>)

${var^} / ${var^^} — uppercase (bool: all if true).

Lower(bool, Param<'a>)

${var,} / ${var,,} — lowercase (bool: all if true).

ArrayElement(&'a str, Word<'a>)

${arr[index]} — array element access (index is a Word for $((expr)) support).

ArrayAll(&'a str)

${arr[@]} or ${arr[*]} — all array elements.

ArrayLen(&'a str)

${#arr[@]} — array length.

ArraySlice(&'a str, &'a str, Option<&'a str>)

${arr[@]:offset:length} — array slice.

Trait Implementations

impl<'a> Clone for Subst<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Subst<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Subst<'a>

fn eq(&self, other: &Subst<'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 Subst<'a>

impl<'a> StructuralPartialEq for Subst<'a>