Enum TypeKind 

pub enum TypeKind {
    Bool,
    I8,
    I16,
    I32,
    I64,
    I128,
    U8,
    U16,
    U32,
    U64,
    U128,
    F32,
    F64,
    Char,
    String,
    Unit,
    Option(Box<TypeKind>),
    List(Box<TypeKind>),
    Map {
        key: Box<TypeKind>,
        value: Box<TypeKind>,
    },
    Tuple(Vec<TypeKind>),
    Struct {
        fields: Vec<Field>,
    },
    Enum {
        variants: Vec<Variant>,
    },
    TypeRef(String),
}

Represents all possible Rust types that can be serialized to RON.

Trait-Based Design

This enum works alongside the trait system in crate::traits:

• List represents any type implementing RonList (Vec, VecDeque, custom types)
• Map represents any type implementing RonMap (HashMap, BTreeMap, custom types)

Custom types implementing these traits will serialize to the same TypeKind variants, allowing the validation and LSP systems to work uniformly.

Variants

Bool

I8

I16

I32

I64

I128

U8

U16

U32

U64

U128

F32

F64

Char

String

Unit

Option(Box<TypeKind>)

List(Box<TypeKind>)

List/sequence type - represents any type implementing RonList.

This includes Vec<T>, VecDeque<T>, HashSet<T>, BTreeSet<T>, arrays, and any custom types implementing RonList.

Map

Map/dictionary type - represents any type implementing RonMap.

This includes HashMap<K, V>, BTreeMap<K, V>, and any custom types implementing RonMap.

Fields

key: Box<TypeKind>

value: Box<TypeKind>

Tuple(Vec<TypeKind>)

Struct

Fields

fields: Vec<Field>

Enum

Fields

variants: Vec<Variant>

TypeRef(String)

Reference to another schema by fully-qualified type path.

Implementations

impl TypeKind

pub fn inner_type(&self) -> Option<&TypeKind>

Get inner type for Option or List.

pub fn map_types(&self) -> Option<(&TypeKind, &TypeKind)>

Get key/value types for Map.

pub fn tuple_types(&self) -> Option<&[TypeKind]>

Get tuple element types.

pub fn struct_fields(&self) -> Option<&[Field]>

Get struct fields.

pub fn enum_variants(&self) -> Option<&[Variant]>

Get enum variants.

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

Get TypeRef path.

pub fn is_primitive(&self) -> bool

Check if this is a primitive type (no nested types).

Trait Implementations

impl Clone for TypeKind

fn clone(&self) -> TypeKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TypeKind

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

Formats the value using the given formatter.

impl Display for TypeKind

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

Formats the value using the given formatter.

impl FromRon for TypeKind

fn from_ast(expr: &Expr<'_>) -> Result<Self>

Core method: deserialize from an AST expression.

fn from_ron_value(value: Value) -> Result<Self>

Construct this type from a RON Value.

fn from_ron(s: &str) -> Result<Self>

Parse a RON string and construct this type.

fn from_ron_reader<R: Read>(reader: R) -> Result<Self>

Read RON from a reader and construct this type.

impl PartialEq for TypeKind

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

fn to_ast(&self) -> Result<Expr<'static>>

Convert this value to a RON AST expression.

fn to_ron(&self) -> Result<String>

Convert this value to a pretty-printed RON string (default format).

fn to_ron_with(&self, config: &FormatConfig) -> Result<String>

Convert this value to a RON string with custom formatting.

fn to_ron_value(&self) -> Result<Value>

Convert this value to a RON Value (via AST).

impl StructuralPartialEq for TypeKind