@hauleth 's suggestion is on point.

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

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.