Enum Literal 

pub enum Literal {
    Positive(Atom),
    Negative(Atom),
    Filter(BuiltinFilter),
    Bind {
        var: VariableSymbol,
        expr: BindExpr,
    },
    Aggregate(AggregateBody),
}

Datalog body literal — a positive or negated atom, a built-in filter expression, or a built-in BIND(expr AS ?var) form.

Rule bodies in Datalog¬ are conjunctions of literals. Positive literals must match facts in the database; negative literals must not match. Negation semantics follow the stratified negation-as-failure convention: every negated atom references only predicates in strictly lower strata, so the set of facts the negation is evaluated against is already closed by the time the rule fires.

Filter literals carry a BuiltinFilter expression that guards the current candidate binding — the evaluator drops a binding whenever the filter does not evaluate to true.

Bind literals carry a BindExpr expression and a fresh variable name; the evaluator extends the current candidate binding with var → eval(expr, binding) and the new variable is then visible to all subsequent body literals (including further Binds, Filters, the rule head, and SPARQL-style constraints over computed values). Filter and bind literals participate in safety analysis but contribute no edges to the predicate dependency graph used by stratification.

Variants

Positive(Atom)

Positive literal — the body atom must match a fact.

Negative(Atom)

Negative literal — the body atom must not match any fact.

Filter(BuiltinFilter)

Built-in filter expression evaluated against the current candidate binding.

Bind

BIND(expr AS ?var) — extend the current candidate binding with a computed value. var must be fresh (untouched by any earlier positive atom or Bind); every variable inside expr must be bound by an earlier positive atom or Bind.

Fields

var: VariableSymbol

The fresh variable produced by this bind.

expr: BindExpr

The expression to compute. Evaluated against the current candidate binding.

Aggregate(AggregateBody)

Aggregation sub-query — fold the inner body into a per-group aggregate result that the outer body sees as a freshly-bound variable. See AggregateBody for the scoping and inner-body restrictions; the evaluator wiring is a deferred extension follow-up.

Implementations

impl Literal

pub fn atom(&self) -> Option<&Atom>

Access the underlying atom, when this literal carries one.

Returns None for Literal::Filter, Literal::Bind, and Literal::Aggregate — none of which carries a single fact-matching atom in its top-level position. (An aggregate’s inner literals live inside AggregateBody::inner_body.)

pub fn is_positive(&self) -> bool

True when the literal is positive.

pub fn is_negative(&self) -> bool

True when the literal is negated.

pub fn is_filter(&self) -> bool

True when the literal is a BuiltinFilter guard.

pub fn is_bind(&self) -> bool

True when the literal is a BIND(expr AS ?var) form.

pub fn is_aggregate(&self) -> bool

True when the literal is an aggregation sub-query.

Trait Implementations

impl Clone for Literal

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Literal

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

Formats the value using the given formatter.

impl Eq for Literal

impl Hash for Literal

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Literal

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Literal