Struct NoneRef 

pub struct NoneRef { /* private fields */ }

A reference to the abstract none heap value.

The are no instances of (ref none): it is an uninhabited type.

There is precisely one instance of (ref null none), aka nullref: the null reference.

This NoneRef Rust type’s sole purpose is for use with Func::wrap- and Func::typed-style APIs for statically typing a function as taking or returning a (ref null none) (aka Option<NoneRef>) which is always None.

Example

let mut config = Config::new();
config.wasm_function_references(true);
config.wasm_gc(true);
let engine = Engine::new(&config)?;

let module = Module::new(
    &engine,
    r#"
        (module
            (func (export "f") (param (ref null none))
                ;; If the reference is null, return.
                local.get 0
                ref.is_null none
                br_if 0

                ;; If the reference was not null (which is impossible)
                ;; then raise a trap.
                unreachable
            )
        )
    "#,
)?;

let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let f = instance.get_func(&mut store, "f").unwrap();

// We can cast a `(ref null none)`-taking function into a typed function that
// takes an `Option<NoneRef>` via the `Func::typed` method.
let f = f.typed::<Option<NoneRef>, ()>(&store)?;

// We can call the typed function, passing the null `none` reference.
let result = f.call(&mut store, NoneRef::null());

// The function should not have trapped, because the reference we gave it was
// null (as it had to be, since `NoneRef` is uninhabited).
assert!(result.is_ok());

Implementations

impl NoneRef

pub fn null() -> Option<NoneRef>

Get the null (ref null none) (aka nullexternref) reference.

pub fn null_ref() -> Ref

Get the null (ref null none) (aka nullexternref) reference as a Ref.

pub fn null_val() -> Val

Get the null (ref null none) (aka nullexternref) reference as a Val.

Trait Implementations

impl Clone for NoneRef

fn clone(&self) -> NoneRef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NoneRef

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

Formats the value using the given formatter.

impl PartialEq for NoneRef

fn eq(&self, other: &NoneRef) -> 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 Copy for NoneRef

impl Eq for NoneRef

impl StructuralPartialEq for NoneRef

impl WasmTy for NoneRef