Enum HeapType

pub enum HeapType {
    Extern,
    Func,
    Concrete(FuncType),
    NoFunc,
    Any,
    I31,
    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 extern heap type represents external host data.

Func

The 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.

Concrete(FuncType)

The concrete heap type represents a reference to a function of a specific, concrete type.

This is a subtype of func and a supertype of nofunc.

NoFunc

The 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.

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 as_concrete(&self) -> Option<&FuncType>

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

Returns None for abstract types.

pub fn unwrap_concrete(&self) -> &FuncType

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

pub fn top(&self, engine: &Engine) -> 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 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<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.