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 rule whose head can match a negated atom runs in a strictly lower stratum. The matching fact extension is therefore closed by the time the consuming 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 rule 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<'de> Deserialize<'de> for Literal

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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 Serialize for Literal

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Literal