Enum Expr 

pub enum Expr<A> {
    Atom(A),
    Not(Box<Expr<A>>),
    And(Box<Expr<A>>, Box<Expr<A>>),
    Or(Box<Expr<A>>, Box<Expr<A>>),
}

A parsed boolean filter expression, generic over its atom representation.

The parser produces an Expr<RawAtom>. Consumer crates lift atoms to a typed representation (e.g. Expr<TagName>, Expr<PathPattern>, Expr<RelationalAtom>) before evaluation.

Trees built by the parser are left-associative for binary operators and follow the precedence order of QRY-002: ! tightest, then &, then |.

Variants

Atom(A)

A leaf atom.

Not(Box<Expr<A>>)

Negation of an inner expression.

And(Box<Expr<A>>, Box<Expr<A>>)

Logical conjunction of two sub-expressions.

Or(Box<Expr<A>>, Box<Expr<A>>)

Logical disjunction of two sub-expressions.

Implementations

impl<A> Expr<A>

pub fn try_map<B, E, F>(self, f: F) -> Result<Expr<B>, E>

where F: FnMut(A) -> Result<B, E>,

Apply f to every atom in the tree in canonical left-to-right order, returning a new expression whose atoms are of type B. The traversal is fail-fast: the first error returned by f short-circuits the rest.

Errors

Returns the first E produced by f. Subsequent atoms are not visited; consumers that want to accumulate every atom-level error MUST layer their own collection on top.

pub fn eval<F>(&self, f: F) -> bool

where F: FnMut(&A) -> bool,

Evaluate the expression by applying f to each atom and folding the results under the boolean operators of QRY-002.

Short-circuits in the standard way: And stops at the first false, Or stops at the first true.

pub fn try_eval<F, E>(&self, f: F) -> Result<bool, E>

where F: FnMut(&A) -> Result<bool, E>,

Evaluate the expression by applying a fallible predicate f to each atom.

Short-circuits in two ways: an Err propagates immediately, and And / Or stop as soon as the result is determined. Atoms past the short-circuit point are not visited and their predicates are not invoked.

Errors

Returns the first E produced by f.

Trait Implementations

impl<A: Clone> Clone for Expr<A>

fn clone(&self) -> Expr<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for Expr<A>

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

Formats the value using the given formatter.

impl<A: Eq> Eq for Expr<A>

impl<A: PartialEq> PartialEq for Expr<A>

fn eq(&self, other: &Expr<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> StructuralPartialEq for Expr<A>