Enum DType 

pub enum DType {
    Scalar(ScalarDType),
    Vector {
        scalar: ScalarDType,
        count: usize,
    },
    Ptr {
        base: Box<DType>,
        addrspace: AddrSpace,
        size: Option<usize>,
        vcount: usize,
    },
    Image {
        kind: ImageKind,
        shape: Vec<usize>,
    },
}

Data type including scalars, vectors, pointers, and images.

Variants

Scalar(ScalarDType)

Scalar type (single value).

Vector

Vector type (SIMD).

Fields

scalar: ScalarDType

count: usize

Ptr

Pointer type. vcount is the vector count of the pointer itself (1 = scalar pointer, >1 = vector of pointers). This matches Tinygrad’s PtrDType.v field.

Fields

base: Box<DType>

addrspace: AddrSpace

size: Option<usize>

vcount: usize

Image

Image type (for texture operations).

Fields

kind: ImageKind

shape: Vec<usize>

Implementations

impl DType

pub fn can_safe_cast(from: DType, to: DType) -> bool

Check if casting from from to to is safe (preserves value).

pub fn least_upper_dtype(dtypes: &[DType]) -> Option<DType>

Find the least upper bound type for a set of dtypes.

Returns the smallest type that all input types can be safely cast to.

Type promotion rules:

• Scalar + Scalar → promoted Scalar
• Ptr + Ptr → Ptr (same Ptr types)
• Ptr + Scalar(T) → Scalar(T) (Ptr will be auto-loaded in codegen)
• Ptr + Scalar(U) → promoted Scalar (if T and U are compatible)

impl DType

pub fn vec(&self, count: usize) -> DType

Create a vector type from this dtype.

pub fn ptr(self, size: Option<usize>, addrspace: AddrSpace) -> DType

Create a pointer type from this dtype.

pub fn scalar(&self) -> Option<ScalarDType>

pub fn is_vector(&self) -> bool

Check if this is a vector type.

pub fn base(&self) -> ScalarDType

Get the base scalar type (works for both scalars and vectors).

pub fn scalar_dtype(&self) -> DType

Get scalar DType (works on both Scalar and Vector).

Unlike base() which returns ScalarDType, this returns DType. This enables chaining with .vec().

Examples

use morok_dtype::DType;

let vec_dtype = DType::Float32.vec(4);
assert_eq!(vec_dtype.scalar_dtype(), DType::Float32);

// Enable chaining: dtype.scalar_dtype().vec(new_count)
let new_vec = vec_dtype.scalar_dtype().vec(8);
assert_eq!(new_vec, DType::Float32.vec(8));

pub fn with_base(&self, new_base: ScalarDType) -> DType

Create a new dtype with a different base scalar type, preserving vector count.

Useful for type conversions like bool→uint8 where the structure is preserved.

pub fn with_ptr_base(&self, new_base: DType) -> Option<DType>

For Ptr types: replace the base dtype while preserving addrspace, size, and vcount. Returns None if not a Ptr.

pub fn count(&self) -> usize

Get the vector count (1 for scalars).

pub fn vcount(&self) -> usize

Get effective vectorization count (for pointers to vectors).

pub fn bytes(&self) -> usize

pub fn is_bool(&self) -> bool

pub fn is_signed(&self) -> bool

pub fn is_unsigned(&self) -> bool

pub fn is_int(&self) -> bool

pub fn is_float(&self) -> bool

pub fn is_fp8(&self) -> bool

pub fn min_value(&self) -> f64

pub fn max_value(&self) -> f64

pub fn c_style(&self) -> String

impl DType

pub const fn bool_() -> DType

pub const fn int8() -> DType

pub const fn int16() -> DType

pub const fn int32() -> DType

pub const fn int64() -> DType

pub const fn uint8() -> DType

pub const fn uint16() -> DType

pub const fn uint32() -> DType

pub const fn uint64() -> DType

pub const fn float16() -> DType

pub const fn bfloat16() -> DType

pub const fn float32() -> DType

pub const fn float64() -> DType

pub const fn void_() -> DType

pub const fn index() -> DType

impl DType

pub const Bool: DType

pub const Int8: DType

pub const Int16: DType

pub const Int32: DType

pub const Int64: DType

pub const UInt8: DType

pub const UInt16: DType

pub const UInt32: DType

pub const UInt64: DType

pub const FP8E4M3: DType

pub const FP8E5M2: DType

pub const Float16: DType

pub const BFloat16: DType

pub const Float32: DType

pub const Float64: DType

pub const Void: DType

pub const Index: DType

Trait Implementations

impl Clone for DType

fn clone(&self) -> DType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DType

fn deserialize<__D>( __deserializer: __D, ) -> Result<DType, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ScalarDType> for DType

fn from(scalar: ScalarDType) -> DType

Converts to this type from the input type.

impl Hash for DType

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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 DType

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

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for DType

impl StructuralPartialEq for DType