Enum DataDefinition 

pub enum DataDefinition {
    Value {
        value: LiteralValue,
        source: Source,
    },
    TypeDeclaration {
        resolved_type: LemmaType,
        declared_default: Option<ValueKind>,
        source: Source,
    },
    SpecRef {
        spec: Arc<LemmaSpec>,
        source: Source,
    },
    Reference {
        target: ReferenceTarget,
        resolved_type: LemmaType,
        local_constraints: Option<Vec<Constraint>>,
        local_default: Option<ValueKind>,
        source: Source,
    },
}

Resolved data value for the execution plan: aligned with DataValue but with source per variant.

Variants

Value

Value-holding data: current value (literal or default); type is on the value.

Fields

value: LiteralValue

source: Source

TypeDeclaration

Type-only data: schema known, value to be supplied (e.g. via with_values). declared_default carries the -> default ... payload for this binding or the default inherited from the parent type chain, if any; value-promoting code uses it instead of re-deriving defaults from TypeSpecification.

Fields

resolved_type: LemmaType

declared_default: Option<ValueKind>

source: Source

SpecRef

Spec reference data: holds the resolved spec.

Fields

spec: Arc<LemmaSpec>

source: Source

Reference

Value-copy reference to another data or a rule result.

resolved_type is the merged type that the copied value must satisfy at evaluation time. Merging folds together: (1) the LHS’s own declared type, if any; (2) the target’s type (data schema type or rule return type); (3) any local_constraints written after the -> on the reference itself. Merging happens in a dedicated pass once all data and rule types are known; before that pass, resolved_type holds a provisional value and must not be consumed for type checking.

local_constraints preserves the raw constraint list from the reference’s -> ... tail (e.g. minimum 5 in data license2: law.other -> minimum 5) for that merging pass. It is None when the reference has no trailing constraints.

local_default carries any default <value> constraint from the reference’s -> ... tail. The reference-merge pass extracts it from the constraint list during type resolution; the evaluator falls back to it when the target value/rule is missing or vetoes for missing data so the downstream sees the declared default instead of a missing-data veto.

The reference itself is evaluated by copying the target’s value (data path) or the target rule’s result in topological order; with_data_values entries for a referenced path override the reference with a literal.

Fields

target: ReferenceTarget

resolved_type: LemmaType

local_constraints: Option<Vec<Constraint>>

local_default: Option<ValueKind>

source: Source

Implementations

impl DataDefinition

pub fn schema_type(&self) -> Option<&LemmaType>

Returns the schema type for value, type-declaration, and reference data; None for spec references.

pub fn value(&self) -> Option<&LiteralValue>

Returns the literal value when the data already holds one. A Reference’s value is produced by the evaluator at runtime, so at plan-time it has no value yet.

pub fn schema_default(&self) -> Option<LiteralValue>

Schema-level default for this data: the value to surface in [SpecSchema::data]’s default field.

Differs from Self::value: Value data already carries the literal (a default that planning promoted to a value), so both return the same thing for that variant. For Reference and TypeDeclaration the schema-level default lives separately from the runtime value (the reference’s copied target value, or the type-only data’s user-supplied value); we synthesize the LiteralValue from the declared default and the resolved_type here so callers don’t have to. SpecRef has no schema default.

pub fn source(&self) -> &Source

Returns the source location for this data.

pub fn spec_arc(&self) -> Option<&Arc<LemmaSpec>>

Returns the referenced spec Arc for spec reference data; None otherwise.

pub fn spec_ref(&self) -> Option<&str>

Returns the referenced spec name for spec reference data; None otherwise.

pub fn reference_target(&self) -> Option<&ReferenceTarget>

Returns the reference target when this data copies a value from another data path or rule result; None otherwise.

Trait Implementations

impl Clone for DataDefinition

fn clone(&self) -> DataDefinition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DataDefinition

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DataDefinition

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DataDefinition

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for DataDefinition

impl StructuralPartialEq for DataDefinition