Enum wasmtime::HeapType

pub enum HeapType {
    Extern,
    Func,
    ConcreteFunc(FuncType),
    NoFunc,
    Any,
    I31,
    Array,
    ConcreteArray(ArrayType),
    None,
}

Available on crate feature runtime only.

The heap types that can Wasm can have references to.

Subtyping and Equality

HeapType does not implement Eq, because heap types have a subtyping relationship, and so 99.99% of the time you actually want to check whether one type matches (i.e. is a subtype of) another type. You can use the HeapType::matches method to perform these types of checks. If, however, you are in that 0.01% scenario where you need to check precise equality between types, you can use the HeapType::eq method.

Variants

Extern

The abstract extern heap type represents external host data.

Func

The abstract func heap type represents a reference to any kind of function.

This is the top type for the function references type hierarchy, and is therefore a supertype of every function reference.

ConcreteFunc(FuncType)

A reference to a function of a specific, concrete type.

These are subtypes of func and supertypes of nofunc.

NoFunc

The abstract nofunc heap type represents the null function reference.

This is the bottom type for the function references type hierarchy, and therefore nofunc is a subtype of all function reference types.

Any

The abstract any heap type represents all internal Wasm data.

This is the top type of the internal type hierarchy, and is therefore a supertype of all internal types (such as i31, structs, and arrays).

I31

The i31 heap type represents unboxed 31-bit integers.

This is a subtype of any and a supertype of none.

Array

The abstract array heap type represents a reference to any kind of array.

This is a subtype of any and a supertype of all concrete array types, as well as a supertype of the abstract none heap type.

ConcreteArray(ArrayType)

A reference to an array of a specific, concrete type.

These are subtypes of the array heap type (therefore also a subtype of any) and supertypes of the none heap type.

None

The abstract none heap type represents the null internal reference.

This is the bottom type for the internal type hierarchy, and therefore none is a subtype of internal types.

Implementations

impl HeapType

pub fn is_extern(&self) -> bool

Is this the abstract extern heap type?

pub fn is_func(&self) -> bool

Is this the abstract func heap type?

pub fn is_no_func(&self) -> bool

Is this the abstract nofunc heap type?

pub fn is_any(&self) -> bool

Is this the abstract any heap type?

pub fn is_i31(&self) -> bool

Is this the abstract i31 heap type?

pub fn is_none(&self) -> bool

Is this the abstract none heap type?

pub fn is_abstract(&self) -> bool

Is this an abstract type?

Types that are not abstract are concrete, user-defined types.

pub fn is_concrete(&self) -> bool

Is this a concrete, user-defined heap type?

Types that are not concrete, user-defined types are abstract types.

pub fn is_concrete_func(&self) -> bool

Is this a concrete, user-defined function type?

pub fn as_concrete_func(&self) -> Option<&FuncType>

Get the underlying concrete, user-defined function type, if any.

Returns None if this is not a concrete function type.

pub fn unwrap_concrete_func(&self) -> &FuncType

Get the underlying concrete, user-defined type, panicking if this is not a concrete function type.

pub fn is_concrete_array(&self) -> bool

Is this a concrete, user-defined array type?

pub fn as_concrete_array(&self) -> Option<&ArrayType>

Get the underlying concrete, user-defined array type, if any.

Returns None for if this is not a concrete array type.

pub fn unwrap_concrete_array(&self) -> &ArrayType

Get the underlying concrete, user-defined type, panicking if this is not a concrete array type.

pub fn top(&self) -> HeapType

Get the top type of this heap type’s type hierarchy.

The returned heap type is a supertype of all types in this heap type’s type hierarchy.

pub fn is_top(&self) -> bool

Is this the top type within its type hierarchy?

pub fn matches(&self, other: &HeapType) -> bool

Does this heap type match the other heap type?

That is, is this heap type a subtype of the other?

Panics

Panics if either type is associated with a different engine from the other.

pub fn eq(a: &HeapType, b: &HeapType) -> bool

Is heap type a precisely equal to heap type b?

Returns false even if a is a subtype of b or vice versa, if they are not exactly the same heap type.

Panics

Panics if either type is associated with a different engine from the other.

Trait Implementations

impl Clone for HeapType

fn clone(&self) -> HeapType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HeapType

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

Formats the value using the given formatter.

impl Display for HeapType

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

Formats the value using the given formatter.

impl From<ArrayType> for HeapType

fn from(a: ArrayType) -> Self

Converts to this type from the input type.

impl From<FuncType> for HeapType

fn from(f: FuncType) -> Self

Converts to this type from the input type.

impl Hash for HeapType

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.