Allow passing list of args to wasm

Author: RoyalIcing

lib/components_guide/rustler/math.ex

@@ -19,18 +19,25 @@ defmodule ComponentsGuide.Rustler.Math do
 
   def add(_, _), do: error()
   def reverse_string(_), do: error()
+  def wasm_example_n_i32(_, _, _), do: error()
   def wasm_example_0(_, _), do: error()
   def wasm_example_1_i32(_, _, _), do: error()
   def wasm_example_2_i32(_, _, _, _), do: error()
   def wasm_buffer_2_i32(_, _, _, _), do: error()
   def wasm_string_2_i32(_, _, _, _), do: error()
 
   def wasm_example(source, f), do: wasm_example_0(source, f)
-  def wasm_example(source, f, a), do: wasm_example_1_i32(source, f, a)
-  def wasm_example(source, f, a, b), do: wasm_example_2_i32(source, f, a, b)
+  def wasm_example(source, f, a), do: wasm_example_n_i32(source, f, [a]) |> process_result()
+  def wasm_example(source, f, a, b), do: wasm_example_n_i32(source, f, [a, b]) |> process_result()
 
-  def wasm_buffer(source, f, a, b), do: wasm_buffer_2_i32(source, f, a, b) |> List.to_tuple()
+  def wasm_buffer(source, f, a, b) do
+    wasm_buffer_2_i32(source, f, a, b) |> process_result()
+  end
   def wasm_string(source, f, a, b), do: wasm_string_2_i32(source, f, a, b)
 
   defp error, do: :erlang.nif_error(:nif_not_loaded)
+
+  defp process_result([]), do: nil
+  defp process_result([a]), do: a
+  defp process_result(multiple_items), do: List.to_tuple(multiple_items)
 end

native/componentsguide_rustler_math/src/lib.rs

@@ -14,6 +14,16 @@ fn reverse_string(a: String) -> String {
     return a.chars().rev().collect();
 }
 
+#[rustler::nif]
+fn wasm_example_n_i32(source: String, f: String, args: Vec<i32>) -> Result<Vec<i32>, Error> {
+    // return Ok(5);
+    //return Err(Error::Term(Box::new("hello")));
+    return match wasm_example_n_i32_internal(source, false, f, args) {
+      Ok(v) => Ok(v),
+      Err(e) => Err(Error::Term(Box::new(e.to_string())))
+    }
+}
+
 #[rustler::nif]
 fn wasm_example_0(source: String, f: String) -> Result<i32, Error> {
     // return Ok(5);
@@ -281,9 +291,68 @@ fn wasm_example_2_i32_string_internal(wat_source: String, f: String, a: i32, b:
   return Ok(string);
 }
 
+fn wasm_example_n_i32_internal(wat_source: String, buffer: bool, f: String, args: Vec<i32>) -> Result<Vec<i32>, anyhow::Error> {
+  let engine = Engine::default();
+
+  // A `Store` is what will own instances, functions, globals, etc. All wasm
+  // items are stored within a `Store`, and it's what we'll always be using to
+  // interact with the wasm world. Custom data can be stored in stores but for
+  // now we just use `()`.
+  let mut store = Store::new(&engine, ());
+  let mut linker = Linker::new(&engine);
+
+  if buffer {
+    let memory_ty = MemoryType::new(1, None);
+    let memory = Memory::new(&mut store, memory_ty)?;
+    linker.define(&store, "env", "buffer", memory)?;
+  }
+
+  // We start off by creating a `Module` which represents a compiled form
+  // of our input wasm module. In this case it'll be JIT-compiled after
+  // we parse the text format.
+  let module = Module::new(&engine, wat_source)?;
+  
+  // With a compiled `Module` we can then instantiate it, creating
+  // an `Instance` which we can actually poke at functions on.
+  // let instance = Instance::new(&mut store, &module, &[])?;
+  let instance = linker.instantiate(&mut store, &module)?;
+
+  // The `Instance` gives us access to various exported functions and items,
+  // which we access here to pull out our `answer` exported function and
+  // run it.
+  let answer = instance
+      .get_func(&mut store, &f)
+      .expect(&format!("{} was not an exported function", f));
+
+  let func_type = answer.ty(&store);
+  // There's a few ways we can call the `answer` `Func` value. The easiest
+  // is to statically assert its signature with `typed` (in this case
+  // asserting it takes no arguments and returns one i32) and then call it.
+  // let answer = answer.typed::<(i32, i32), i32>(&store)?;
+
+  // let args = vec![a, b];
+  // let args: &[Val] = &[Val::I32(a), Val::I32(b)];
+  // let args: &[Val] = args.iter().map(|i| Val::I32(i)).collect();
+  let args: Vec<Val> = args.into_iter().map(|i| Val::I32(i)).collect();
+
+  let mut result: Vec<Val> = Vec::with_capacity(16);
+  // result.resize(2, Val::I32(0));
+  let result_length = func_type.results().len();
+  result.resize(result_length, Val::I32(0));
+
+  // And finally we can call our function! Note that the error propagation
+  // with `?` is done to handle the case where the wasm function traps.
+  answer.call(&mut store, &args, &mut result)?;
+
+  let result: Vec<_> = result.iter().map(|v| v.unwrap_i32()).collect();
+
+  return Ok(result);
+}
+
 rustler::init!("Elixir.ComponentsGuide.Rustler.Math", [
   add,
   reverse_string,
+  wasm_example_n_i32,
   wasm_example_0,
   wasm_example_1_i32,
   wasm_example_2_i32,

test/components_guide/rustler/math_test.exs

@@ -51,6 +51,7 @@ defmodule ComponentsGuide.Rustler.MathTest do
     """
 
     assert Math.wasm_example(wasm_source, "add", 7, 5) == 12
+    assert Math.wasm_buffer(wasm_source, "add", 7, 5) == 12
   end
 
   test "wasm_example/4 multiplying two numbers" do