Enum Type 

pub enum Type {
    Any,
    Void,
    Bool,
    U8,
    I8,
    U16,
    I16,
    U32,
    I32,
    U64,
    I64,
    F16,
    F32,
    F64,
    Str,
    Map,
    List,
    Iter,
    Ident {
        name: SmolStr,
        params: Vec<Type>,
    },
    ConstInt(i64),
    ConstBinary {
        op: ConstIntOp,
        left: Rc<Type>,
        right: Rc<Type>,
    },
    Tuple(Vec<Type>),
    Struct {
        params: Vec<Type>,
        fields: Vec<(SmolStr, Type)>,
    },
    Vec(Rc<Type>, u32),
    Array(Rc<Type>, u32),
    ArrayParam(Rc<Type>, Rc<Type>),
    Fn {
        tys: Vec<Type>,
        ret: Rc<Type>,
    },
    Symbol {
        id: u32,
        params: Vec<Type>,
    },
}

Variants

Any

Void

Bool

U8

I8

U16

I16

U32

I32

U64

I64

F16

F32

F64

Str

Map

List

Iter

Ident

Fields

name: SmolStr

params: Vec<Type>

ConstInt(i64)

ConstBinary

Fields

op: ConstIntOp

left: Rc<Type>

right: Rc<Type>

Tuple(Vec<Type>)

Struct

Fields

params: Vec<Type>

fields: Vec<(SmolStr, Type)>

Vec(Rc<Type>, u32)

Array(Rc<Type>, u32)

ArrayParam(Rc<Type>, Rc<Type>)

Fn

Fields

tys: Vec<Type>

ret: Rc<Type>

Symbol

Fields

id: u32

params: Vec<Type>

Implementations

impl Type

pub fn align(&self) -> u32

pub fn storage_width(&self) -> u32

pub fn struct_layout(fields: &[(SmolStr, Type)]) -> (u32, Vec<u32>)

pub fn field_offset(&self, idx: usize) -> Option<u32>

pub fn len(&self) -> usize

pub fn compare_args(left: &[Type], right: &[Type]) -> Option<Vec<Type>>

pub fn force(&self, src: Dynamic) -> Result<Dynamic, DynamicErr>

pub fn width(&self) -> u32

pub fn is_void(&self) -> bool

pub fn is_bool(&self) -> bool

pub fn is_str(&self) -> bool

pub fn is_native(&self) -> bool

pub fn is_any(&self) -> bool

pub fn is_ident(&self) -> bool

pub fn is_struct(&self) -> bool

pub fn get_field(&self, name: &str) -> Result<(usize, &Type)>

pub fn add_field(&mut self, name: SmolStr, ty: Type) -> Result<u32>

pub fn is_vec(&self) -> bool

pub fn is_array(&self) -> bool

pub fn is_int(&self) -> bool

pub fn is_uint(&self) -> bool

pub fn sign(self) -> Self

pub fn is_float(&self) -> bool

pub fn is_f64(&self) -> bool

pub fn is_f32(&self) -> bool

pub fn is_fn(&self) -> bool

pub fn from_args(args: Vec<(SmolStr, Type)>) -> (Self, Vec<SmolStr>)

Trait Implementations

impl Add for Type

type Output = Type

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl Clone for Type

fn clone(&self) -> Type

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Type

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

Formats the value using the given formatter.

impl Default for Type

fn default() -> Type

Returns the “default value” for a type.

impl PartialEq for Type

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

impl Send for Type

impl Sync for Type