Enum TypeKind 

pub enum TypeKind {
    I8,
    I16,
    I32,
    I64,
    U8,
    U16,
    U32,
    U64,
    Isize,
    Usize,
    F16,
    F32,
    F64,
    Bool,
    Unit,
    Struct(StructId),
    Enum(EnumId),
    Array(ArrayTypeId),
    PtrConst(PtrConstTypeId),
    PtrMut(PtrMutTypeId),
    Module(ModuleId),
    Error,
    Never,
    ComptimeType,
    ComptimeStr,
    ComptimeInt,
}

The kind of a type - used for pattern matching.

This enum mirrors the structure of the Type enum but is designed for pattern matching. During the migration to Type(InternedType), code that pattern matches on types will use ty.kind() to get a TypeKind.

This separation allows incremental migration: all pattern matches can be updated to use .kind() while Type is still an enum, then Type can be replaced with Type(InternedType) without breaking existing code.

Variants

I8

8-bit signed integer

I16

16-bit signed integer

I32

32-bit signed integer

I64

64-bit signed integer

U8

8-bit unsigned integer

U16

16-bit unsigned integer

U32

32-bit unsigned integer

U64

64-bit unsigned integer

Isize

Pointer-sized signed integer

Usize

Pointer-sized unsigned integer

F16

IEEE 754 binary16 (half-precision float)

F32

IEEE 754 binary32 (single-precision float)

F64

IEEE 754 binary64 (double-precision float)

Bool

Boolean

Unit

The unit type (for functions that don’t return a value)

Struct(StructId)

User-defined struct type

Enum(EnumId)

User-defined enum type

Array(ArrayTypeId)

Fixed-size array type: [T; N]

PtrConst(PtrConstTypeId)

Raw pointer to immutable data: ptr const T

PtrMut(PtrMutTypeId)

Raw pointer to mutable data: ptr mut T

Module(ModuleId)

A module type (from @import)

Error

An error type (used during type checking to continue after errors)

Never

The never type - represents computations that don’t return

ComptimeType

The comptime type - the type of types themselves

ComptimeStr

The comptime string type - compile-time only string values

ComptimeInt

The comptime integer type - compile-time only integer values

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<(), Error>

Formats the value using the given formatter.

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 Copy for TypeKind

impl Eq for TypeKind

impl StructuralPartialEq for TypeKind