Enum DataDefinition 

pub enum DataDefinition {
    Value {
        value: LiteralValue,
        source: Source,
    },
    TypeDeclaration {
        resolved_type: Arc<LemmaType>,
        declared_default: Option<ValueKind>,
        source: Source,
    },
    Import {
        spec: Arc<LemmaSpec>,
        source: Source,
    },
    Reference {
        target: ReferenceTarget,
        resolved_type: Arc<LemmaType>,
        local_constraints: Option<Vec<(TypeConstraintCommand, Vec<CommandArg>)>>,
        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: Arc<LemmaType>

declared_default: Option<ValueKind>

source: Source

Import

Import (uses): resolved target lemma for this alias.

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. It is materialized into a concrete value by the evaluator when the caller does not supply a value.

The reference itself is evaluated by copying the target’s value (data path) or the target rule’s result in topological order; caller values in crate::planning::execution_plan::DataOverlay override the reference.

Fields

target: ReferenceTarget

resolved_type: Arc<LemmaType>

local_constraints: Option<Vec<(TypeConstraintCommand, Vec<CommandArg>)>>

local_default: Option<ValueKind>

source: Source

Implementations

impl DataDefinition

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

Schema type for value, type-declaration, and reference data; None for imports.

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 bound_value(&self) -> Option<&LiteralValue>

Literal explicitly bound in the spec (data x: literal) or supplied by the caller via crate::planning::execution_plan::DataOverlay. Not a suggestion; see Self::default_suggestion.

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

Suggestion from -> default ... on a type declaration or reference. Surfaces in crate::planning::execution_plan::DataEntry::default for prefill/UI; the evaluator applies it when the caller does not supply a value.

pub fn source(&self) -> &Source

Returns the source location for this data.

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 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.