Enum Ast 

pub enum Ast {
    Comparison {
        offset: usize,
        comparator: Comparator,
        lhs: Box<Ast>,
        rhs: Box<Ast>,
    },
    Condition {
        offset: usize,
        predicate: Box<Ast>,
        then: Box<Ast>,
    },
    Identity {
        offset: usize,
    },
    Expref {
        offset: usize,
        ast: Box<Ast>,
    },
    Flatten {
        offset: usize,
        node: Box<Ast>,
    },
    Function {
        offset: usize,
        name: String,
        args: Vec<Ast>,
    },
    Field {
        offset: usize,
        name: String,
    },
    Index {
        offset: usize,
        idx: i32,
    },
    Literal {
        offset: usize,
        value: Value,
    },
    MultiList {
        offset: usize,
        elements: Vec<Ast>,
    },
    MultiHash {
        offset: usize,
        elements: Vec<KeyValuePair>,
    },
    Not {
        offset: usize,
        node: Box<Ast>,
    },
    Projection {
        offset: usize,
        lhs: Box<Ast>,
        rhs: Box<Ast>,
    },
    ObjectValues {
        offset: usize,
        node: Box<Ast>,
    },
    And {
        offset: usize,
        lhs: Box<Ast>,
        rhs: Box<Ast>,
    },
    Or {
        offset: usize,
        lhs: Box<Ast>,
        rhs: Box<Ast>,
    },
    Slice {
        offset: usize,
        start: Option<i32>,
        stop: Option<i32>,
        step: i32,
    },
    Subexpr {
        offset: usize,
        lhs: Box<Ast>,
        rhs: Box<Ast>,
    },
    VariableRef {
        offset: usize,
        name: String,
    },
    Let {
        offset: usize,
        bindings: Vec<(String, Ast)>,
        expr: Box<Ast>,
    },
}

Represents a JMESPath AST node.

Variants

Comparison

Compares two nodes using a comparator (e.g., foo == bar).

Fields

offset: usize

comparator: Comparator

lhs: Box<Ast>

rhs: Box<Ast>

Condition

Returns the RHS if the predicate yields a truthy value.

Fields

offset: usize

predicate: Box<Ast>

then: Box<Ast>

Identity

Returns the current node.

Fields

offset: usize

Expref

Expression reference (used by sort_by, max_by, etc.).

Fields

offset: usize

ast: Box<Ast>

Flatten

Flattens nested arrays.

Fields

offset: usize

node: Box<Ast>

Function

Calls a function with the given arguments.

Fields

offset: usize

name: String

args: Vec<Ast>

Field

Extracts a field from an object.

Fields

offset: usize

name: String

Index

Accesses an element by index.

Fields

offset: usize

idx: i32

Literal

A literal JSON value.

Fields

offset: usize

value: Value

MultiList

Multi-select list (e.g., [foo, bar]).

Fields

offset: usize

elements: Vec<Ast>

MultiHash

Multi-select hash (e.g., {foo: bar, baz: qux}).

Fields

offset: usize

elements: Vec<KeyValuePair>

Not

Negation (e.g., !expr).

Fields

offset: usize

node: Box<Ast>

Projection

Projects the RHS over each element of the LHS array.

Fields

offset: usize

lhs: Box<Ast>

rhs: Box<Ast>

ObjectValues

Converts an object into an array of its values.

Fields

offset: usize

node: Box<Ast>

And

Logical AND.

Fields

offset: usize

lhs: Box<Ast>

rhs: Box<Ast>

Or

Logical OR.

Fields

offset: usize

lhs: Box<Ast>

rhs: Box<Ast>

Slice

Slices an array (e.g., [0:5:2]).

Fields

offset: usize

start: Option<i32>

stop: Option<i32>

step: i32

Subexpr

Sub-expression (e.g., foo.bar).

Fields

offset: usize

lhs: Box<Ast>

rhs: Box<Ast>

VariableRef

JEP-18: Variable reference (e.g., $name).

Fields

offset: usize

name: String

Let

JEP-18: Let expression (e.g., let $x = expr in body).

Fields

offset: usize

bindings: Vec<(String, Ast)>

expr: Box<Ast>

Trait Implementations

impl Clone for Ast

fn clone(&self) -> Ast

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ast

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

Formats the value using the given formatter.

impl PartialEq for Ast

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