Enum Type 

pub enum Type {
    Any,
    Void,
    Bool,
    U8,
    I8,
    U16,
    I16,
    U32,
    I32,
    U64,
    I64,
    F16,
    F32,
    F64,
    Str,
    Map,
    List(Rc<Type>),
    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(Rc<Type>)

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

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

两个类型相加得到的“公共类型“,也是 VM 里混合宽度算术结果类型的推断规则。

优先级(从高到低):

1. 完全相同的类型 → 自身;
2. 任一为字符串 → Str(支持 任意 + 字符串 拼接);
3. 任一为 Any → Any(动态值参与即退化为动态);
4. 任一为浮点 → 取较宽的浮点(有 f64 则 f64,否则 f32);
5. 任一为有符号整数 → 取双方较大宽度的有符号整数(有符号优先于无符号);
6. 任一为无符号整数 → 取双方较大宽度的无符号整数;
7. 其它 → Any。

注意:有符号在第 5 步先于无符号被处理,因此 i32 + u32 结果是 i32(按宽度, 不做无符号回绕检查)。宽度按 Type::width 计算。

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 Eq for 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 Send for Type

impl Sync for Type