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 map_quantity<F>(self, f: F) -> Self

where F: FnOnce(QuantityUnits, Option<BTreeMap<String, i32>>) -> (QuantityUnits, Option<BTreeMap<String, i32>>),

Functional update of the Quantity payload (units + decomposition). Non-Quantity variants pass through unchanged. The transform receives the owned units and decomposition and returns the replacements.

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 matches_primitive_kind(&self, kind: PrimitiveKind) -> bool

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

pub fn is_calendar_like_quantity(&self) -> bool

pub fn is_calendar_like(&self) -> bool

pub fn is_ratio(&self) -> bool

Check if this type is ratio

pub fn is_ratio_range(&self) -> bool

pub fn is_calendar_quantity_range(&self) -> bool

pub fn is_calendar_like_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) -> Option<&BTreeMap<String, i32>>

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 resolved BaseQuantityVector for Quantity types, or None if the decomposition pass has not yet resolved this type. 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: BTreeMap<String, i32>) -> Self

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

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

Declared unit names when the type carries a non-empty unit table (None otherwise).

pub fn quantity_unit_factor(&self, unit_name: &str) -> &Ratio<i128>

Return the conversion factor for a declared unit name on this quantity type.

pub fn ratio_unit_factor(&self, unit_name: &str) -> &Ratio<i128>

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 Eq for LemmaType

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 StructuralPartialEq for LemmaType