Enum Expr 

pub enum Expr {
    Claim(String),
    Not(Box<Expr>),
    And(Vec<Expr>),
    Or(Vec<Expr>),
}

A parsed requirement expression over claim names.

And and Or are n-ary: a chain of same-operator children is kept flat in a single Vec<Expr> rather than nested left-folded binary nodes. Construct via Expr::and / Expr::or / Expr::not — those smart constructors splice same-operator children so a and b and c parses to one And([a, b, c]) and (a or b) or c parses to one Or([a, b, c]). The shape change is invisible to evaluation (or and and are associative) but makes diagnostic tree rendering one level shallower per same-op chain.

Variants

Claim(String)

Reference to a single claim by name.

Not(Box<Expr>)

Logical negation.

And(Vec<Expr>)

Logical conjunction over one-or-more children.

Or(Vec<Expr>)

Logical disjunction over one-or-more children.

Implementations

impl Expr

pub fn and(parts: Vec<Expr>) -> Expr

Build an Expr::And from parts, splicing any child that is itself an And so the result is a flat one-level chain.

A single-element vec collapses to its lone child unwrapped. Empty vec is the identity (vacuously True); the parser never produces this, but the constructor is defined for it.

pub fn or(parts: Vec<Expr>) -> Expr

Build an Expr::Or from parts, splicing any child that is itself an Or so the result is a flat one-level chain.

A single-element vec collapses to its lone child unwrapped. Empty vec is the identity (vacuously False); the parser never produces this, but the constructor is defined for it.

pub fn not(inner: Expr) -> Expr

Wrap inner in an Expr::Not.

Named to match Expr::and / Expr::or rather than via std::ops::Not — the constructor triad reads better as Expr::and / Expr::or / Expr::not than as a mix of Expr::and and !expr.

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 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 Eq for Expr

impl StructuralPartialEq for Expr