Enum HeapType

Source

pub enum HeapType {
Show 19 variants    Extern,
    NoExtern,
    Func,
    ConcreteFunc(FuncType),
    NoFunc,
    Any,
    Eq,
    I31,
    Array,
    ConcreteArray(ArrayType),
    Struct,
    ConcreteStruct(StructType),
    Exn,
    ConcreteExn(ExnType),
    ConcreteCont(ContType),
    Cont,
    NoCont,
    None,
    NoExn,
}

Expand description

The heap types that can Wasm can have references to.

§Subtyping Hierarchy

Wasm has three different heap type hierarchies:

Function types
External types
Internal (struct and array) types
Exception types

Each hierarchy has a top type (the common supertype of which everything else in its hierarchy is a subtype of) and a bottom type (the common subtype of which everything else in its hierarchy is supertype of).

§Function Types Hierarchy

The top of the function types hierarchy is func; the bottom is nofunc. In between are all the concrete function types.

                         func
                      /  /  \  \
     ,----------------  /    \  -------------------------.
    /                  /      \                           \
   |              ,----        -----------.                |
   |              |                       |                |
   |              |                       |                |
(func)    (func (param i32))    (func (param i32 i32))    ...
   |              |                       |                |
   |              |                       |                |
   |              `---.        ,----------'                |
    \                  \      /                           /
     `---------------.  \    /  ,------------------------'
                      \  \  /  /
                        nofunc

Additionally, some concrete function types are sub- or supertypes of other concrete function types, if that was declared in their definition. For simplicity, this isn’t depicted in the diagram above.

§External

The top of the external types hierarchy is extern; the bottom is noextern. There are no concrete types in this hierarchy.

 extern
   |
noextern

§Internal

The top of the internal types hierarchy is any; the bottom is none. The eq type is the common supertype of all types that can be compared for equality. The struct and array types are the common supertypes of all concrete struct and array types respectively. The i31 type represents unboxed 31-bit integers.

                                  any
                                 / | \
   ,----------------------------'  |  `--------------------------.
  /                                |                              \
 |                        .--------'                               |
 |                        |                                        |
 |                      struct                                   array
 |                     /  |   \                                 /  |   \
i31             ,-----'   |    '-----.                   ,-----'   |    `-----.
 |             /          |           \                 /          |           \
 |            |           |            |               |           |            |
 |        (struct)    (struct i32)    ...        (array i32)    (array i64)    ...
 |            |           |            |               |           |            |
 |             \          |           /                 \          |           /
  \             `-----.   |    ,-----'                   `-----.   |    ,-----'
   \                   \  |   /                                 \  |   /
    \                   \ |  /                                   \ |  /
     \                   \| /                                     \| /
      \                   |/                                       |/
       \                  |                                        |
        \                 |                                       /
         \                '--------.                             /
          \                        |                            /
           `--------------------.  |   ,-----------------------'
                                 \ |  /
                                  none

Additionally, concrete struct and array types can be subtypes of other concrete struct and array types respectively, if that was declared in their definitions. Once again, this is omitted from the above diagram for simplicity.

§Exceptions

The top of the exception types hierarchy is exn; the bottom is noexn. At the WebAssembly level, there are no concrete types in this hierarchy. However, internally we do reify a heap type for each tag, similar to how continuation objects work.

  exn
 / | \
(exn $t) ...
 \ | /
noexn

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

This is the top type for the external type hierarchy, and therefore is the common supertype of all external reference types.

§

NoExtern

The abstract noextern heap type represents the null external reference.

This is the bottom type for the external type hierarchy, and therefore is the common subtype of all external reference types.

§

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 eq, i31, structs, and arrays).

§

Eq

The abstract eq heap type represenets all internal Wasm references that can be compared for equality.

This is a subtype of any and a supertype of i31, array, struct, and none heap types.

§

I31

The i31 heap type represents unboxed 31-bit integers.

This is a subtype of any and eq, 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 eq, 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 eq) and supertypes of the none heap type.

§

Struct

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

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

§

ConcreteStruct(StructType)

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

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

§

Exn

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

This is a supertype of the internal concrete exception heap types and the noexn heap type.

§

ConcreteExn(ExnType)

A concrete exception object with a specific tag.

These are internal, not exposed at the Wasm level, but useful in our implementation and host API. These are subtypes of exn and supertypes of noexn.

§

ConcreteCont(ContType)

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

These are subtypes of cont and supertypes of nocont.

§

Cont

The cont heap type represents a reference to any kind of continuation.

This is the top type for the continuation objects type hierarchy, and is therefore a supertype of every continuation object.

§

NoCont

The nocont heap type represents the null continuation object.

This is the bottom type for the continuation objects type hierarchy, and therefore nocont is a subtype of all continuation object types.

§

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.

§

NoExn

The noexn heap type represents the null exception object.

This is the bottom type for the exception objects type hierarchy.

Enum HeapType Copy item path

§Subtyping Hierarchy

§Function Types Hierarchy

§External

§Internal

§Exceptions

§Subtyping and Equality

Variants§

Extern

NoExtern

Func

ConcreteFunc(FuncType)

NoFunc

Any

Eq

I31

Array

ConcreteArray(ArrayType)

Struct

ConcreteStruct(StructType)

Exn

ConcreteExn(ExnType)

ConcreteCont(ContType)

Cont

NoCont

None

NoExn

Implementations§

impl HeapType

pub fn is_extern(&self) -> bool

pub fn is_func(&self) -> bool

pub fn is_no_func(&self) -> bool

pub fn is_any(&self) -> bool

pub fn is_i31(&self) -> bool

pub fn is_none(&self) -> bool

pub fn is_cont(&self) -> bool

pub fn is_exn(&self) -> bool

pub fn is_no_exn(&self) -> bool

pub fn is_abstract(&self) -> bool

pub fn is_concrete(&self) -> bool

pub fn is_concrete_func(&self) -> bool

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

pub fn unwrap_concrete_func(&self) -> &FuncType

pub fn is_concrete_array(&self) -> bool

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

pub fn unwrap_concrete_array(&self) -> &ArrayType

pub fn is_concrete_cont(&self) -> bool

pub fn as_concrete_cont(&self) -> Option<&ContType>

pub fn is_concrete_struct(&self) -> bool

pub fn as_concrete_struct(&self) -> Option<&StructType>

pub fn unwrap_concrete_cont(&self) -> &ContType

pub fn unwrap_concrete_struct(&self) -> &StructType

pub fn is_concrete_exn(&self) -> bool

pub fn as_concrete_exn(&self) -> Option<&ExnType>

pub fn top(&self) -> HeapType

pub fn is_top(&self) -> bool

pub fn bottom(&self) -> HeapType

pub fn is_bottom(&self) -> bool

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

§Panics

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

§Panics

Trait Implementations§

impl Clone for HeapType

fn clone(&self) -> HeapType

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

impl Debug for HeapType

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

impl Display for HeapType

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

impl From<ArrayType> for HeapType

fn from(a: ArrayType) -> Self

impl From<ContType> for HeapType

fn from(f: ContType) -> Self

impl From<ExnType> for HeapType

fn from(e: ExnType) -> Self

impl From<FuncType> for HeapType

fn from(f: FuncType) -> Self

impl From<StructType> for HeapType

fn from(s: StructType) -> Self

Enum HeapType

fn hash<H: Hasher>(&self, state: &mut H)

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<T> CloneToUninit for T
where T: Clone,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

impl<T> ToOwned for T
where T: Clone,

impl<T> ToString for T
where T: Display + ?Sized,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,