Enum LogosType 

pub enum LogosType {
    Int,
    Float,
    Bool,
    Char,
    Byte,
    String,
    Unit,
    Seq(Box<LogosType>),
    Map(Box<LogosType>, Box<LogosType>),
    Set(Box<LogosType>),
    Option(Box<LogosType>),
    Duration,
    Date,
    Moment,
    Time,
    Span,
    Nat,
    Rational,
    Decimal,
    Complex,
    Modular,
    Quantity,
    Money,
    Uuid,
    UserDefined(Symbol),
    Function(Vec<LogosType>, Box<LogosType>),
    Unknown,
}

Structured type representation for LOGOS values.

Replaces string-based type tracking (e.g., "Vec<i64>", "String") with a proper algebraic data type that supports precise queries.

Variants

Int

Float

Bool

Char

Byte

String

Unit

Seq(Box<LogosType>)

Map(Box<LogosType>, Box<LogosType>)

Set(Box<LogosType>)

Option(Box<LogosType>)

Duration

Date

Moment

Time

Span

Nat

Rational

Exact rational (logicaffeine_base::Rational). A Rational-typed binding keeps division exact (7 / 2 → 7/2) where a bare Int floors. Lowers to LogosRational.

Decimal

Exact base-10 fixed-point (money). + − × stay exact Decimal (scale preserved); ÷ widens to Rational. Built via decimal("19.99"). Lowers to LogosDecimal.

Complex

Exact complex number re + im·i. + − × ÷ stay Complex (closed field). Built via complex(re, im). NOT ordered. Lowers to LogosComplex.

Modular

An element of the ring ℤ/nℤ. + − × ÷ stay Modular (same modulus required, no auto-lift). Built via modular(value, modulus). NOT ordered. Lowers to LogosModular.

Quantity

A dimensioned physical quantity (quantity(2, "inch")). + − require the same dimension, × ÷ combine dimensions, and it may be scaled by a number; built via quantity/convert. The magnitude rides the exact rational tower. Lowers to LogosQuantity. Dimension safety is enforced at runtime (a clean error), like Modular’s ring check.

Money

An exact monetary amount in a currency (money(19.99, "USD") / 19.99 USD). + − require the same currency, × ÷ scale by a number; the amount rides the Decimal tower. Lowers to LogosMoney. Currency safety is enforced at runtime (a clean error), like Quantity.

Uuid

A 128-bit UUID (uuid "…", a random uuid). An opaque identifier — no arithmetic; lowers to LogosUuid. Comparable/orderable by its bytes.

UserDefined(Symbol)

Function(Vec<LogosType>, Box<LogosType>)

First-class function type: fn(P1, P2, …) -> R

Unknown

Implementations

impl LogosType

pub fn is_copy(&self) -> bool

Whether this type is Copy in Rust (no .clone() needed).

This is the single source of truth for clone decisions, replacing is_copy_type(), has_copy_element_type(), has_copy_value_type().

pub fn is_numeric(&self) -> bool

Whether this type is numeric (Int or Float).

pub fn is_string(&self) -> bool

Whether this type is a string.

pub fn is_float(&self) -> bool

Whether this type is a float.

pub fn element_type(&self) -> Option<&LogosType>

Get the element type for sequences and sets.

pub fn value_type(&self) -> Option<&LogosType>

Get the value type for maps.

pub fn key_type(&self) -> Option<&LogosType>

Get the key type for maps.

pub fn numeric_promotion(a: &LogosType, b: &LogosType) -> LogosType

Numeric promotion: Z embeds into R. If either operand is Float, the result is Float. If both are Int (or Nat), the result is Int.

pub fn to_rust_type(&self) -> String

Convert to the Rust type string used in codegen output.

Replaces all ad-hoc string-based type conversions scattered across codegen.rs. This is the single point of truth for LogosType → Rust type string mapping.

pub fn from_type_expr(ty: &TypeExpr<'_>, interner: &Interner) -> LogosType

Build a LogosType from a TypeExpr AST node.

pub fn from_rust_type_str(s: &str) -> LogosType

Parse a Rust type string back into a LogosType (legacy bridge). Handles strings like “i64”, “f64”, “String”, “Vec”, “std::collections::HashMap<String, i64>”, etc.

pub fn from_literal(lit: &Literal) -> LogosType

Infer a LogosType from a literal expression.

Trait Implementations

impl Clone for LogosType

fn clone(&self) -> LogosType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LogosType

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

Formats the value using the given formatter.

impl Hash for LogosType

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 LogosType

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

impl StructuralPartialEq for LogosType