@hauleth 's suggestion is on point.

If you need an example, you could look at wasmex (GitHub - tessi/wasmex: Execute WebAssembly / WASM from Elixir).

For example, a WebAssembly module instance has an elixir representation with an attached Rust struct. It is passed down in some methods defined here to the Rust-layer.

In Rust-land, we override the Wasmex::Native module with the respective rust functions taking that rust-struct reference.

In instance.rs you can see how to attach structs (instance in my case) to elixir objects (new_from_bytes) and how to extract structs from elixir objects (e.g. function_export_exists).

Here’s something that should work with minimal changes:

use rustler::resource::ResourceArc;
use rustler::{Encoder, Env, Term};

rustler::atoms! { error, ok, }

type MyRustReturnType = YOUR_RUST_TYPE_HERE;

enum MyResult {
    Success(ResourceArc<MyRustReturnType>),
    Failure(String),
}

impl<'a> Encoder for MyResult {
    fn encode<'b>(&self, env: Env<'b>) -> Term<'b> {
        match self {
            MyResult::Success(arc) => (ok(), arc).encode(env),
            MyResult::Failure(msg) => (error(), msg).encode(env),
        }
    }
}

// or DirtyCpu, or just remove the "schedule" option and leave the clause to be simply: `#[rustler::nif]`
#[rustler::nif(schedule = "DirtyIo")]
fn something() -> MyResult {
  match function_that_can_fail() {
    Ok(rust_object) => MyResult::Success(ResourceArc::(rust_object)),
    Err(e) => MyResult::Failure(e.to_string()),
  }
}

You might need to remove the lifetime qualifiers though, can’t remember why my code needed them now. Using Rustler’s ResourceArc is crucial here; thanks to it you will receive the Rust object wrapped in a nice Erlang Reference which in the case of this function you’ll see in your iex console like so (in the case of success):

{:ok, #Reference<0.679634982.4171759622.38993>}

…or in case of failure:

{:error, "error message from Rust here"}

Then on the Elixir side you should take care to have the same something() function that Rustler will wrap and pass through to Rust (this is covered in Rustler’s guide). That’s basically it. Poke me if you need more help, Rustler could be tricky and it seems the maintainers don’t have time for it for a long time now.

Use NIF resource for that, you probably will need to dig in Rustler docs how to do that in Rust.

Sure, sorry. I dropped details over in the thread in the rust forums.

The problem was the lifetimes. I needed to replace any datatype that requires a lifetime, with the equivalent datatype that doesn’t (e.g. &str → String, and &[&str] → Vec<String>). I didn’t understand that lifetimes aren’t needed for what I’m doing. They’re only used at compile-time, so in my situation it doesn’t make sense to accept a lifetime parameter. For example, &str requires a known length at compile-time, but my string values are dynamic length.

So instead of…

struct SlidingWindow<'a> {
    map: HashMap<&'a str, Vec<Option<f32>>>,
    labels: &'a [&'a str],
    index: usize,
    length: usize,
    width: usize,
}

…we need to use…

struct SlidingWindow {
    map: HashMap<String, Vec<Option<f32>>>,
    labels: Vec<String>,
    index: usize,
    length: usize,
    width: usize,
}

And one other helpful thing. I realized you can package probably any mutable data in this generic structure:

struct Container {
    mutex: Mutex<MyStruct>,
}

rustler::init!(
    "Elixir.MyNif",
    [func1, func2],
    load = |env: Env, _| {
        rustler::resource!(Container, env);
        true
    }
);

So you put whatever you want into MyStruct, and you wrap it up for elixir like this…

let my_new_struct = MyStruct { ... };
let mutex = Mutex::new(my_new_struct);
let container = Container { mutex };
Ok(ResourceArc::new(container))

…then you can receive the same thing back, lock the mutex, unpack it, and do whatever mutations you need.

#[rustler::nif]
fn print(arc: ResourceArc<Container>) {
    arc.mutex.lock().unwrap().print();
}

I’m happy to say that I have everything working in my project, have a look at master if you’re interested.

Oh, I did exactly the same for my sqlite3 library! Glad that you found the idiom!

Sigh, I should start blogging on these topics. I know it will help a lot of people.