Exporting a function to JS
Alright now that we've got a good grasp on JS objects and how they're working,
let's take a look at another feature of wasm-bindgen
: exporting functionality
with types that are richer than just numbers.
The basic idea around exporting functionality with more flavorful types is that
the Wasm exports won't actually be called directly. Instead the generated
foo.js
module will have shims for all exported functions in the Wasm module.
The most interesting conversion here happens with strings so let's take a look at that.
# #![allow(unused_variables)] #fn main() { #[wasm_bindgen] pub fn greet(a: &str) -> String { format!("Hello, {}!", a) } #}
Here we'd like to define an ES module that looks like
// foo.d.ts
export function greet(a: string): string;
To see what's going on, let's take a look at the generated shim
import * as wasm from './foo_bg';
function passStringToWasm(arg) {
const buf = new TextEncoder('utf-8').encode(arg);
const len = buf.length;
const ptr = wasm.__wbindgen_malloc(len, 1);
let array = new Uint8Array(wasm.memory.buffer);
array.set(buf, ptr);
return [ptr, len];
}
function getStringFromWasm(ptr, len) {
const mem = new Uint8Array(wasm.memory.buffer);
const slice = mem.slice(ptr, ptr + len);
const ret = new TextDecoder('utf-8').decode(slice);
return ret;
}
export function greet(arg0) {
const [ptr0, len0] = passStringToWasm(arg0);
try {
const ret = wasm.greet(ptr0, len0);
const ptr = wasm.__wbindgen_boxed_str_ptr(ret);
const len = wasm.__wbindgen_boxed_str_len(ret);
const realRet = getStringFromWasm(ptr, len);
wasm.__wbindgen_boxed_str_free(ret);
return realRet;
} finally {
wasm.__wbindgen_free(ptr0, len0, 1);
}
}
Phew, that's quite a lot! We can sort of see though if we look closely what's happening:
-
Strings are passed to Wasm via two arguments, a pointer and a length. Right now we have to copy the string onto the Wasm heap which means we'll be using
TextEncoder
to actually do the encoding. Once this is done we use an internal function inwasm-bindgen
to allocate space for the string to go, and then we'll pass that ptr/length to Wasm later on. -
Returning strings from Wasm is a little tricky as we need to return a ptr/len pair, but Wasm currently only supports one return value (multiple return values is being standardized). To work around this in the meantime, we're actually returning a pointer to a ptr/len pair, and then using functions to access the various fields.
-
Some cleanup ends up happening in wasm. The
__wbindgen_boxed_str_free
function is used to free the return value ofgreet
after it's been decoded onto the JS heap (usingTextDecoder
). The__wbindgen_free
is then used to free the space we allocated to pass the string argument once the function call is done.
Next let's take a look at the Rust side of things as well. Here we'll be looking at a mostly abbreviated and/or "simplified" in the sense of this is what it compiles down to:
# #![allow(unused_variables)] #fn main() { pub extern "C" fn greet(a: &str) -> String { format!("Hello, {}!", a) } #[export_name = "greet"] pub extern "C" fn __wasm_bindgen_generated_greet( arg0_ptr: *const u8, arg0_len: usize, ) -> *mut String { let arg0 = unsafe { let slice = ::std::slice::from_raw_parts(arg0_ptr, arg0_len); ::std::str::from_utf8_unchecked(slice) }; let _ret = greet(arg0); Box::into_raw(Box::new(_ret)) } #}
Here we can see again that our greet
function is unmodified and has a wrapper
to call it. This wrapper will take the ptr/len argument and convert it to a
string slice, while the return value is boxed up into just a pointer and is
then returned up to was for reading via the __wbindgen_boxed_str_*
functions.
So in general exporting a function involves a shim both in JS and in Rust with
each side translating to or from Wasm arguments to the native types of each
language. The wasm-bindgen
tool manages hooking up all these shims while the
#[wasm_bindgen]
macro takes care of the Rust shim as well.
Most arguments have a relatively clear way to convert them, bit if you've got any questions just let me know!