Enum RefEvalError 

pub enum RefEvalError {
    Ineligible(Vec<Boundary>),
    MissingRelation(String),
    RelationArityMismatch {
        predicate: String,
        atom_arity: usize,
        relation_arity: usize,
    },
    RelationRowArityMismatch {
        predicate: String,
        row_index: usize,
        row_len: usize,
        schema_len: usize,
    },
    RelationValueTypeMismatch {
        predicate: String,
        row_index: usize,
        column: usize,
        expected: ScalarType,
        got: String,
    },
    ConstantTypeMismatch {
        predicate: String,
        position: usize,
        expected: ScalarType,
        got: String,
    },
    ComparisonTypeMismatch {
        left: String,
        right: String,
        op: CompOp,
    },
    UnboundHeadVariable(String),
    IsExprNotSupported,
    ConflictingVariableType {
        var: String,
        first_predicate: String,
        first_position: usize,
        first_type: ScalarType,
        second_predicate: String,
        second_position: usize,
        second_type: ScalarType,
    },
    InferenceConflict {
        predicate: String,
        column: usize,
        first_rule_index: usize,
        first_type: ScalarType,
        second_rule_index: usize,
        second_type: ScalarType,
    },
}

Errors surfaced by evaluate_rule.

Variants

Ineligible(Vec<Boundary>)

The rule was Eligibility::Ineligible — callers must gate on super::analyze / super::analyze_typed before evaluation. Carries the boundary list for diagnostic use.

MissingRelation(String)

A predicate referenced by the rule body was not present in the supplied RefRelationStore.

RelationArityMismatch

A body atom’s arity does not match the supplied relation’s schema arity. The evaluator is the WCOJ correctness oracle — arity drift between rule and fixture must surface as a loud failure, not a silent skip.

Fields

predicate: String

Predicate name being looked up.

atom_arity: usize

Number of terms in the body atom.

relation_arity: usize

Number of columns in the relation schema.

RelationRowArityMismatch

A relation row’s length does not equal the schema’s column count. Rejected before evaluation begins so a malformed fixture fails on entry rather than producing misleading partial-row matches.

Fields

predicate: String

Predicate name owning the malformed row.

row_index: usize

Index of the offending row within the relation.

row_len: usize

Observed length of the row.

schema_len: usize

Expected length per the schema.

RelationValueTypeMismatch

A relation row carries a RefValue whose variant does not match the schema’s ScalarType at that column. Detected before evaluation so type drift in fixtures fails loudly rather than silently corrupting GPU oracle comparisons.

Fields

predicate: String

Predicate name owning the malformed row.

row_index: usize

Row index within the relation.

column: usize

Column index within the row.

expected: ScalarType

Schema-declared type at that column.

got: String

String description of the actual value.

ConstantTypeMismatch

A constant in a body atom could not be coerced to a value compatible with the relation’s column type at that position.

Fields

predicate: String

Predicate name where the mismatch occurred.

position: usize

Argument position (0-based) within the predicate.

expected: ScalarType

Expected scalar type per the relation’s schema.

got: String

String description of the constant for diagnostic use.

ComparisonTypeMismatch

A Comparison body literal could not be evaluated because its operands were of incompatible types.

Fields

left: String

Left-hand operand description.

right: String

Right-hand operand description.

op: CompOp

Operator that was being applied.

UnboundHeadVariable(String)

The rule head referenced a variable that is not bound by any body atom (a free variable in the head).

IsExprNotSupported

The rule body contained an crate::ast::IsExpr — PR 2 rejects rules containing computed bindings via the BodyIsExpr boundary, so this is a defensive arm; if it fires the analyzer let an IsExpr rule through erroneously.

ConflictingVariableType

A variable appears in two body atoms whose relation schemas disagree on the column type at the variable’s position.

Detected by super::evaluate_rule_typed (and the typed fixpoint variants) at the typed-gate phase, before evaluation. Without this check, an evaluator would either silently coerce values across types or fail later with a less precise error pointing at a row, not at the rule.

The two (predicate, position, type) triples are recorded in first-encountered order: walking body atoms in source order, the first atom that types this variable wins first_*; the second atom whose type differs gets second_*. Subsequent agreeing atoms are silent.

Fields

var: String

Variable name as it appears in the source rule.

first_predicate: String

Predicate of the first atom that typed var.

first_position: usize

0-based argument position within first_predicate.

first_type: ScalarType

Schema type at (first_predicate, first_position).

second_predicate: String

Predicate of the conflicting atom.

second_position: usize

0-based argument position within second_predicate.

second_type: ScalarType

Schema type at (second_predicate, second_position).

InferenceConflict

Two rules contributing to the same head predicate disagree on the type of the same column under the PR 8 SCC type inference pass.

Distinct from Self::ConflictingVariableType, which is a within-rule body conflict (one rule, two body atoms typing the same variable differently). This variant is a cross-rule head-column conflict, detected by super::infer_scc_predicate_schemas when back-propagating from rule heads to head-predicate column types.

Surfaced through the typed evaluators via super::FixpointError::RuleEval / super::SccFixpointError::RuleEval; their rule_index field carries second_rule_index (the rule whose typing caused the conflict to be detected; the first rule’s typing was already accepted by then).

Fields

predicate: String

Head predicate name where the conflict was detected.

column: usize

0-based column index where types disagree.

first_rule_index: usize

Rule index (within the predicate’s group) that first typed the column.

first_type: ScalarType

Type derived from the first rule’s body.

second_rule_index: usize

Rule index (within the predicate’s group) that disagrees.

second_type: ScalarType

Type derived from the conflicting rule’s body.

Trait Implementations

impl Clone for RefEvalError

fn clone(&self) -> RefEvalError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RefEvalError

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

Formats the value using the given formatter.

impl PartialEq for RefEvalError

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