Struct DataEntry 

pub struct DataEntry {
    pub lemma_type: LemmaType,
    pub bound_value: Option<LiteralValue>,
    pub default: Option<LiteralValue>,
}

A spec’s public interface: its data (inputs) and rules (outputs) with full structured type information.

Built from an ExecutionPlan via ExecutionPlan::schema (all data and rules) or ExecutionPlan::schema_for_rules (scoped to specific rules and only the data they need).

Shared by the HTTP server, the CLI, the MCP server, WASM, and any other consumer. Carries the real LemmaType and LiteralValue so consumers can work at whatever fidelity they need — structured types for input forms, or Display for plain text.

This is the IO contract consumers can rely on:

• data: required/provided inputs with full type constraints
• rules: produced outputs with full result types

For cross-spec composition, planning validates that referenced specs satisfy this contract. Plan hashes are complementary: they lock full behavior. One data input in a SpecSchema.

A named struct instead of a (type, bound, default) tuple so JSON-native consumers (TypeScript, Python, …) get stable field names. bound_value holds a spec or caller-fixed literal; default is only a -> default ... suggestion.

Fields

lemma_type: LemmaType

bound_value: Option<LiteralValue>

default: Option<LiteralValue>

Trait Implementations

impl Clone for DataEntry

fn clone(&self) -> DataEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DataEntry

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DataEntry

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for DataEntry

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

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 DataEntry