Enum Node 

pub enum Node {
    Ternary {
        condition: Box<Node>,
        true_value: Box<Node>,
        false_value: Box<Node>,
    },
    Binary {
        operator: String,
        left: Box<Node>,
        right: Box<Node>,
    },
    Unary {
        operator: String,
        operand: Box<Node>,
    },
    In {
        negated: bool,
        value: Box<Node>,
        list: Vec<Node>,
    },
    Path {
        relative: bool,
        levels_up: i64,
        segments: Vec<PathSegment>,
    },
    Literal(LiteralValue),
    Group(Box<Node>),
}

An expression AST node (expressions.md §4).

Variants

Ternary

condition ? trueValue : falseValue (right-associative).

Fields

condition: Box<Node>

The boolean condition.

true_value: Box<Node>

Branch evaluated when the condition is truthy.

false_value: Box<Node>

Branch evaluated when the condition is falsy.

Binary

Logical (&& ||) or comparison (== != > >= < <=) operation.

Fields

operator: String

The operator spelling.

left: Box<Node>

Left operand.

right: Box<Node>

Right operand.

Unary

! operand.

Fields

operator: String

The operator spelling (!).

operand: Box<Node>

The negated operand.

In

value [not] in list membership test.

Fields

negated: bool

Whether the test is negated (not in).

value: Box<Node>

The probed value.

list: Vec<Node>

Candidate Literal nodes.

Path

A path reference.

Fields

relative: bool

false → resolved from the data root; true → relative to the field.

levels_up: i64

Additional parent ascents beyond the current field’s parent.

segments: Vec<PathSegment>

Ordered path segments.

Literal(LiteralValue)

A literal value.

Group(Box<Node>)

A parenthesized group wrapping an inner expression.

Implementations

impl Node

pub fn to_value(&self) -> Value

Serialize to the canonical fixture AST shape (no position).

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl PartialEq for Node

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Node