Enum Quant 

pub enum Quant<'a> {
    InSet {
        binder: Located<'a, &'a str>,
        set: Located<'a, &'a str>,
    },
    Relation {
        left: Located<'a, &'a str>,
        predicate: Located<'a, &'a str>,
        right: Located<'a, &'a str>,
    },
}

A FOR EACH quantifier on a PREMISE/RULE header. It instantiates the premise’s whole body once per element, substituting the binder. The quantifier lives in the header (not the body), so there is exactly one per statement and the body grammar is untouched — a second FOR EACH is structurally unrepresentable, which is what bounds the desugar to a linear number of clauses (no domain products).

Variants

InSet

FOR EACH <binder> IN <set> — range over the elements of a declared Statement::Set. The binder is the name the body’s atoms refer to.

Fields

binder: Located<'a, &'a str>

The name bound inside the body (substituted per element).

set: Located<'a, &'a str>

The declared set this ranges over.

Relation

FOR EACH <left> <predicate> <right> — range over the declared FACT pairs of that relation (e.g. every FACT a linked b), binding left to a pair’s subject and right to its object. This is the channel for multi-element constraints (graphs, dependencies): the pair is pinned by data, so the desugar is linear in the number of facts, never a product.

Fields

left: Located<'a, &'a str>

Bound to each matching fact’s subject.

predicate: Located<'a, &'a str>

The relation predicate whose facts are ranged over.

right: Located<'a, &'a str>

Bound to each matching fact’s object.

Trait Implementations

impl<'a> Clone for Quant<'a>

fn clone(&self) -> Quant<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Quant<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Quant<'a>

fn eq(&self, other: &Quant<'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 Quant<'a>