Enum Expr 

pub enum Expr {
    Identity,
    FieldAccess {
        base: Box<Expr>,
        fields: Vec<String>,
    },
    ArrayAccess {
        array: Box<Expr>,
        index: Box<Expr>,
    },
    ArraySlice {
        array: Box<Expr>,
        start: Option<Box<Expr>>,
        end: Option<Box<Expr>>,
    },
    ArrayIteration(Box<Expr>),
    FunctionCall {
        name: String,
        args: Vec<Expr>,
    },
    BinaryOp {
        left: Box<Expr>,
        op: BinaryOperator,
        right: Box<Expr>,
    },
    UnaryOp {
        op: UnaryOperator,
        expr: Box<Expr>,
    },
    Assignment {
        op: AssignmentOperator,
        target: Box<Expr>,
        value: Box<Expr>,
    },
    Object {
        pairs: Vec<ObjectEntry>,
    },
    Array(Vec<Expr>),
    Literal(Literal),
    Identifier(String),
    Variable(String),
    Paren(Box<Expr>),
    Pipeline(Vec<Expr>),
    If {
        condition: Box<Expr>,
        then_branch: Box<Expr>,
        else_branch: Box<Expr>,
    },
    Sequence(Vec<Expr>),
}

Core expression types in DSQ

Variants

Identity

Identity filter (.)

FieldAccess

Field access (.field or .field.subfield)

Fields

base: Box<Expr>

Base expression (usually Identity for .field)

fields: Vec<String>

Field names

ArrayAccess

Array access (.[index])

Fields

array: Box<Expr>

The array expression

index: Box<Expr>

The index expression

ArraySlice

Array slicing (.[start:end])

Fields

array: Box<Expr>

The array expression

start: Option<Box<Expr>>

Start index (None means 0)

end: Option<Box<Expr>>

End index (None means end)

ArrayIteration(Box<Expr>)

Array iteration (.[])

FunctionCall

Function call (func(args…))

Fields

name: String

Function name

args: Vec<Expr>

Arguments

BinaryOp

Binary operation (left op right)

Fields

left: Box<Expr>

Left operand

op: BinaryOperator

Operator

right: Box<Expr>

Right operand

UnaryOp

Unary operation (op expr)

Fields

op: UnaryOperator

Operator

expr: Box<Expr>

Operand

Assignment

Assignment operation (target += value or target |= value)

Fields

op: AssignmentOperator

Assignment operator

target: Box<Expr>

Target expression

value: Box<Expr>

Value expression

Object

Object construction ({key: value, …})

Fields

pairs: Vec<ObjectEntry>

Key-value pairs

Array(Vec<Expr>)

Array construction ([item1, item2, …])

Literal(Literal)

Literal value

Identifier(String)

Identifier (bare word, could be function name or variable)

Variable(String)

Variable reference ($name)

Paren(Box<Expr>)

Parenthesized expression

Pipeline(Vec<Expr>)

Pipeline (expr1 | expr2 | …)

If

If-then-else expression (if condition then expr else expr end)

Fields

condition: Box<Expr>

Condition expression

then_branch: Box<Expr>

Then branch expression

else_branch: Box<Expr>

Else branch expression

Sequence(Vec<Expr>)

Sequence (expr1, expr2, …)

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 Display 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 Serialize for Expr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Expr