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: Self, to: Self) -> bool

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

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

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<T> + Ptr<T> → Ptr<T> (same Ptr types)
• Ptr<T> + Scalar(T) → Scalar(T) (Ptr will be auto-loaded in codegen)
• Ptr<T> + Scalar(U) → promoted Scalar (if T and U are compatible)

impl DType

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

Create a vector type from this dtype.

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

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

Check if this is an image (texture) 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 svod_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) -> Self

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<Self>

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_() -> Self

pub const fn int8() -> Self

pub const fn int16() -> Self

pub const fn int32() -> Self

pub const fn int64() -> Self

pub const fn uint8() -> Self

pub const fn uint16() -> Self

pub const fn uint32() -> Self

pub const fn uint64() -> Self

pub const fn float16() -> Self

pub const fn bfloat16() -> Self

pub const fn float32() -> Self

pub const fn float64() -> Self

pub const fn void_() -> Self

pub const fn index() -> Self

impl DType

pub const Bool: Self

pub const Int8: Self

pub const Int16: Self

pub const Int32: Self

pub const Int64: Self

pub const UInt8: Self

pub const UInt16: Self

pub const UInt32: Self

pub const UInt64: Self

pub const FP8E4M3: Self

pub const FP8E5M2: Self

pub const Float16: Self

pub const BFloat16: Self

pub const Float32: Self

pub const Float64: Self

pub const Void: Self

pub const Index: Self

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

Formats the value using the given formatter.

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

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ScalarDType> for DType

fn from(scalar: ScalarDType) -> Self

Converts to this type from the input type.

impl Hash for DType

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 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::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for DType

impl StructuralPartialEq for DType