Struct LemmaType 

pub struct LemmaType {
    pub name: Option<String>,
    pub specifications: TypeSpecification,
    pub extends: TypeExtends,
}

Resolved type after planning

Contains a type specification and optional name. Created during planning from TypeSpecification and TypeDef in the AST.

Fields

name: Option<String>

Optional type name (e.g., “age”, “temperature”)

specifications: TypeSpecification

The type specification (Boolean, Number, Scale, etc.)

extends: TypeExtends

What this type extends (primitive or custom from a spec)

Implementations

impl LemmaType

pub fn new( name: String, specifications: TypeSpecification, extends: TypeExtends, ) -> Self

Create a new type with a name

pub fn without_name( specifications: TypeSpecification, extends: TypeExtends, ) -> Self

Create a type without a name (anonymous/inline type)

pub fn primitive(specifications: TypeSpecification) -> Self

Create a primitive type (no name, extends Primitive)

pub fn name(&self) -> String

Get the type name, or a default based on the type specification

pub fn is_boolean(&self) -> bool

Check if this type is boolean

pub fn is_scale(&self) -> bool

Check if this type is scale

pub fn is_number(&self) -> bool

Check if this type is number (dimensionless)

pub fn is_numeric(&self) -> bool

Check if this type is numeric (either scale or number)

pub fn is_text(&self) -> bool

Check if this type is text

pub fn is_date(&self) -> bool

Check if this type is date

pub fn is_time(&self) -> bool

Check if this type is time

pub fn is_duration(&self) -> bool

Check if this type is duration

pub fn is_ratio(&self) -> bool

Check if this type is ratio

pub fn vetoed(&self) -> bool

Check if this type is veto

pub fn is_undetermined(&self) -> bool

True if this type is the undetermined sentinel (type could not be inferred).

pub fn has_same_base_type(&self, other: &LemmaType) -> bool

Check if two types have the same base type specification (ignoring constraints)

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

For scale types, returns the family name (root of the extension chain). For Custom extends, returns the family field; for Primitive, returns the type’s own name (the type is the root). For non-scale types, returns None.

pub fn same_scale_family(&self, other: &LemmaType) -> bool

Returns true if both types are scale and belong to the same scale family (same family name). Two anonymous primitive scales (no name, no family) are considered compatible.

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

Create a default value from this type’s default constraint (if any)

pub fn veto_type() -> Self

Create a Veto LemmaType (internal use only - not user-declarable)

pub fn undetermined_type() -> Self

LemmaType sentinel for undetermined type (used during inference when a type cannot be determined). Propagates through expressions and is never present in a validated graph.

pub fn decimal_places(&self) -> Option<u8>

Decimal places for display (Number, Scale, and Ratio). Used by formatters. Ratio: optional, no default; when None display is normalized (no trailing zeros).

pub fn example_value(&self) -> &'static str

Get an example value string for this type, suitable for UI help text

pub fn scale_unit_factor(&self, unit_name: &str) -> Decimal

Factor for a unit of this scale type (for unit conversion during evaluation only). Planning must validate conversions first and return Error for invalid units. If called with a non-scale type or unknown unit name, panics (invariant violation).

Trait Implementations

impl Clone for LemmaType

fn clone(&self) -> LemmaType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LemmaType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LemmaType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for LemmaType

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

Formats the value using the given formatter.

impl Hash for LemmaType

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 LemmaType

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

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 LemmaType

impl StructuralPartialEq for LemmaType