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 in the AST.

Fields

name: Option<String>

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

specifications: TypeSpecification

The type specification (Boolean, Number, Quantity, etc.). Serialized as a discriminated union: the variant tag appears as "kind" alongside name and extends, and the variant’s fields are flattened to the top level.

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_quantity(&self) -> bool

Check if this type is quantity

pub fn is_quantity_range(&self) -> bool

pub fn is_number(&self) -> bool

Check if this type is number (dimensionless)

pub fn is_number_range(&self) -> bool

pub fn is_numeric(&self) -> bool

Check if this type is numeric (either quantity 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_date_range(&self) -> bool

pub fn is_time(&self) -> bool

Check if this type is time

pub fn has_trait_duration(&self) -> bool

pub fn is_duration_like_quantity(&self) -> bool

pub fn is_duration_like(&self) -> bool

pub fn is_calendar(&self) -> bool

Check if this type is calendar

pub fn is_ratio(&self) -> bool

Check if this type is ratio

pub fn is_ratio_range(&self) -> bool

pub fn is_calendar_range(&self) -> bool

pub fn is_range(&self) -> bool

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 quantity_family_name(&self) -> Option<&str>

For quantity 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-quantity types, returns None.

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

Returns true if both types are quantity and belong to the same named quantity family.

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

pub fn veto_type() -> Self

Create a Veto LemmaType

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, Quantity, 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 quantity_type_decomposition(&self) -> &BaseQuantityVector

Factor for a unit of this quantity type (for unit conversion during evaluation only). Planning must validate conversions first and return Error for invalid units. If called with a non-quantity type or unknown unit name, panics (invariant violation). Returns the BaseQuantityVector for Quantity types. For base quantitys (after decomposition pass) this is {type_name: 1}. For derived quantitys it is the combined dimensional vector. Panics if called on non-Quantity types.

pub fn is_anonymous_quantity(&self) -> bool

Returns true if this is an anonymous (no-name) Quantity — i.e. an anonymous intermediate produced by cross-axis arithmetic.

pub fn anonymous_for_decomposition(decomposition: BaseQuantityVector) -> Self

Build an anonymous LemmaType for a given dimensional decomposition. Used at plan time to represent the inferred type of cross-axis intermediates.

pub fn quantity_unit_names(&self) -> Option<Vec<&str>>

Declared unit names for a named quantity type (None for non-quantity or anonymous quantity).

pub fn validate_quantity_result_unit( &self, target_unit: &str, ) -> Result<(), String>

Whether a value of this type may be expressed in target_unit (typed named quantity only).

Used by planning (as on typed quantity operands) and evaluation API rule-result conversion.

pub fn validate_rule_result_unit_conversion( &self, target_unit: &str, unit_index: &HashMap<String, LemmaType>, spec_name: &str, ) -> Result<SemanticConversionTarget, String>

Whether source_type may be converted to target_unit for as / API rule-result display.

Mirrors planning check_unit_conversion_types for quantity- and ratio-unit targets. Callers must reject impossible conversions before evaluation.

pub fn quantity_unit_factor(&self, unit_name: &str) -> &RationalInteger

pub fn ratio_unit_factor(&self, unit_name: &str) -> &RationalInteger

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