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

@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).

Rustler 0.22.0-rc makes this a bit easier. It’s not very well documented but I’ve made it work mostly easily.

Could you give me a pointer (pun fully intended ), Dimitar?
I. e. what exactly is it that the new version will make easier?

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.

Sweet! Thank you so much (all of you that is ^_^)
I’ll try that once I get to that project again next week. This looks really promising.

I am also interested in doing this, I’m experimenting with something and will need to pass a reference to a rust object(? My rust knowledge is poor) to elixir so that I can later call other rust methods to it

@dimitarvp I tried to implement the solution you suggested with rustler 0.22.0-rc.0.
I now have the problem that the YOUR_RUST_TYPE_HERE type that I used instead does not implement the ResourceTypeProvider trait and I’m unsure how to impl that correctly… did you have to provide the trait implementation for the type you used in your application?

Doesn’t ring a bell from memory. Do you have a GitHub repo for me to look at?

EDIT: Actually this might be because you have incorrectly implemented Encoder – but not 100% sure.

Unfortunately no because the whole construct is a little complex by now…

But here is the actual code in the rust lib:

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

rustler::atoms! { error, ok, }

type DbConnection = odbx::Connection<odbx::AutocommitOn>;

enum DbConnectionResult {
    Success(ResourceArc<DbConnection>),
    Failure(String),
}

// impl ResourceTypeProvider for DbConnectionResult {
//     fn get_type() -> &'static ResourceType<Self> {
//         rustler::resource::ResourceType {}
//     }
// }

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

#[rustler::nif]
pub fn connect() -> DbConnectionResult {
    // Connect to database using connection string
    let connection_string = "DSN=SYA";
    match odbx::Odbc::connect(&connection_string) {
        Ok(conn) => DbConnectionResult::Success(ResourceArc::new(conn)),
        Err(e) => DbConnectionResult::Failure(String::from("Some error")),
    }
}

#[rustler::nif]
fn add(a: i64, b: i64) -> i64 {
    a + b
}

rustler::init!("Elixir.ExOdbc", [add, connect]);

odbx:: is a package I wrote to patch and adjust several rust odbc packages (which is what makes this whole thing a little complicated…)

The compiler is complaining about the Success(ResourceArc<DbConnection>), since Connection<AutocommitOn> does not implement the trait ResourceTypeProvider