pub enum HeapType {
Show 13 variants
Extern,
NoExtern,
Func,
ConcreteFunc(FuncType),
NoFunc,
Any,
Eq,
I31,
Array,
ConcreteArray(ArrayType),
Struct,
ConcreteStruct(StructType),
None,
}
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 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.
§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
, struct
s, and
array
s).
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.
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§
source§impl HeapType
impl HeapType
sourcepub fn is_no_func(&self) -> bool
pub fn is_no_func(&self) -> bool
Is this the abstract nofunc
heap type?
sourcepub fn is_abstract(&self) -> bool
pub fn is_abstract(&self) -> bool
Is this an abstract type?
Types that are not abstract are concrete, user-defined types.
sourcepub fn is_concrete(&self) -> bool
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.
sourcepub fn is_concrete_func(&self) -> bool
pub fn is_concrete_func(&self) -> bool
Is this a concrete, user-defined function type?
sourcepub fn as_concrete_func(&self) -> Option<&FuncType>
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.
sourcepub fn unwrap_concrete_func(&self) -> &FuncType
pub fn unwrap_concrete_func(&self) -> &FuncType
Get the underlying concrete, user-defined type, panicking if this is not a concrete function type.
sourcepub fn is_concrete_array(&self) -> bool
pub fn is_concrete_array(&self) -> bool
Is this a concrete, user-defined array type?
sourcepub fn as_concrete_array(&self) -> Option<&ArrayType>
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.
sourcepub fn unwrap_concrete_array(&self) -> &ArrayType
pub fn unwrap_concrete_array(&self) -> &ArrayType
Get the underlying concrete, user-defined type, panicking if this is not a concrete array type.
sourcepub fn is_concrete_struct(&self) -> bool
pub fn is_concrete_struct(&self) -> bool
Is this a concrete, user-defined struct type?
sourcepub fn as_concrete_struct(&self) -> Option<&StructType>
pub fn as_concrete_struct(&self) -> Option<&StructType>
Get the underlying concrete, user-defined struct type, if any.
Returns None
for if this is not a concrete struct type.
sourcepub fn unwrap_concrete_struct(&self) -> &StructType
pub fn unwrap_concrete_struct(&self) -> &StructType
Get the underlying concrete, user-defined type, panicking if this is not a concrete struct type.
sourcepub fn top(&self) -> HeapType
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.
sourcepub fn bottom(&self) -> HeapType
pub fn bottom(&self) -> HeapType
Get the bottom type of this heap type’s type hierarchy.
The returned heap type is a subtype of all types in this heap type’s type hierarchy.
Trait Implementations§
source§impl From<StructType> for HeapType
impl From<StructType> for HeapType
source§fn from(s: StructType) -> Self
fn from(s: StructType) -> Self
Auto Trait Implementations§
impl Freeze for HeapType
impl !RefUnwindSafe for HeapType
impl Send for HeapType
impl Sync for HeapType
impl Unpin for HeapType
impl !UnwindSafe for HeapType
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§unsafe fn clone_to_uninit(&self, dst: *mut T)
unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read more