How to return {:ok, result} from say NifResult<Type>?

[jonmdev]

To match the Elixir convention, I am trying to return from my Rustler functions {:ok, result} or {:error, error_string}.

I can do the :error case as follows, but can't solve the :ok case:

fn get_id(index: i64) -> NifResult<String> {
    if index >= 1) {
        return Err(rustler::Error::Term(Box::new("attempt to get index outside range"))); 
    }
    else {
        let hello = "HELLO".to_string();
        return Ok( hello); //HOW TO MAKE THIS RETURN {:ok, "HELLO"} rather than just "HELLO"?
    }
}

With the above code, I am able to get {:error, "attempt to get index outside range"} but I still cannot get {:ok, "HELLO"}.

If I just return Ok(hello); then I just get the result without the {:ok, result} tuple wrapping of it.

I also tried

mod my_atoms {
    rustler::atoms! {
        ok
   }
}

with

        let result = (my_atoms::ok, hello); 
        return Ok(result); 

But this does not work either. I tried ChatGPT out of interest but it is just giving me hallucinations of things that don't exist (maybe did at one time but don't now).

It seems logical that if you are going to get {:error, reason} you should also want to get {:ok, result}

How can I do this? Is there some more correct way to do it I am not? Thanks for any help.

[filmor]

The generated atoms are functions, so you'd need to use ok().

[jonmdev]

That did not work either, but I was able to solve this using:

#[rustler::nif]
fn get_id(index: i64) -> Result<String, String> {
    if index >= 1) {
        return Err("hi".to_string()); 
    }
    else {
        return Ok("HELLO".to_string()); 
    }
}

So I suppose I will stick with that. Is that the intended design to your knowledge?

[evnu]

I would expect this to work:

        let result = (my_atoms::ok(), hello); 
        return Ok(result); 

What does the compiler report for that?

[jonmdev]

Doesn't work. You get:

error[E0061]: this enum variant takes 1 argument but 2 arguments were supplied
   --> src/lib.rs:300:16
    |
300 |         return Ok(my_atoms::ok(), "hello".to_string());
    |                ^^ -------------- unexpected argument #1 of type `rustler::Atom`
    |
note: tuple variant defined here
   --> /rustc/eeb90cda1969383f56a2637cbd3037bdf598841c/library/core/src/result.rs:531:5
help: remove the extra argument
    |
300 -         return Ok(my_atoms::ok(), "hello".to_string());
300 +         return Ok("hello".to_string());
    |

You can try it yourself with this code:

use rustler::{NifResult }; 

mod my_atoms {
    rustler::atoms! {
        ok
   }
}

#[rustler::nif]
fn get_ok() -> NifResult<String> { 
        return Ok(my_atoms::ok(), "hello".to_string()); //doesn't work
}

NifResult cannot seem to return {:ok, result}. You can only get this with Result and the method posted above. This was moved to "discussion" for unknown reasons. I think it is a bug. Should I report it again as a bug?

[evnu]

You need to return `Ok((my_atoms::ok(), "hello".to_string()))` (return a tuple). Am 17. Oktober 2024 19:50:04 MESZ schrieb jonmdev ***@***.***>:

…

Doesn't work. You get: ``` error[E0061]: this enum variant takes 1 argument but 2 arguments were supplied --> src/lib.rs:300:16 | 300 | return Ok(my_atoms::ok(), "hello".to_string()); | ^^ -------------- unexpected argument #1 of type `rustler::Atom` | note: tuple variant defined here --> /rustc/eeb90cda1969383f56a2637cbd3037bdf598841c/library/core/src/result.rs:531:5 help: remove the extra argument | 300 - return Ok(my_atoms::ok(), "hello".to_string()); 300 + return Ok("hello".to_string()); | ``` You can try it yourself with this code: ``` use rustler::{NifResult }; mod my_atoms { rustler::atoms! { ok } } #[rustler::nif] fn get_ok() -> NifResult<String> { return Ok(my_atoms::ok(),"hello".to_string()); //doesn't work } ``` `NifResult` cannot seem to return `{:ok, result}`. You can only get this with `Result` and the method posted above. This was moved to "discussion" for unknown reasons. I think it is a bug. Should I report it again as a bug? -- Reply to this email directly or view it on GitHub: #660 (reply in thread) You are receiving this because you commented. Message ID: ***@***.***>

[jonmdev]

That also does not work. I tried that already. It gives:

error[E0308]: mismatched types
   --> src/lib.rs:285:19
    |
285 |         return Ok((my_atoms::ok(), "hello".to_string()));
    |                -- ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `String`, found `(Atom, String)`
    |                |
    |                arguments to this enum variant are incorrect
    |
    = note: expected struct `String`
                found tuple `(rustler::Atom, String)`
help: the type constructed contains `(rustler::Atom, String)` due to the type of the argument passed
   --> src/lib.rs:285:16
    |
285 |         return Ok((my_atoms::ok(), "hello".to_string()));
    |                ^^^-------------------------------------^
    |                   |
    |                   this argument influences the type of `Ok`
note: tuple variant defined here
   --> /rustc/eeb90cda1969383f56a2637cbd3037bdf598841c/library/core/src/result.rs:531:5

Would you agree then this is a bug? If so, can it be moved back to bugs or do you want me to make a new post there again?

[filmor]

It's not a bug, you have to adjust the return type if you are returning a different type. The compiler tells you. So, change NifResult<String> to NifResult<(Atom, String>. Using a bare Result is likely the better option, though.

[jonmdev]

Thank you! You are correct, it does work like this:

use rustler::{NifResult }; 

mod my_atoms {
    rustler::atoms! {
        ok
   }
}

#[rustler::nif]
fn get_ok() -> NifResult<(rustler::atom, String)> { 
        return Ok((my_atoms::ok(), "hello".to_string()));
}

But this is definitely poorer structurally than the Result version here: #660 (reply in thread)

So I will stick with that Result method. Though it is good to know it can be made to work both ways. If we want custom atoms, then this seems to be the right way. Thanks.

[evnu]

To make that work, you need to adapt the return type of your function to `NifResult<(Atom, String), String>` (as this returns a tuple for OK now). I am currently on mobile and can't give a more complete example. Maybe you can simply use Result (see the [encoder](https://github.com/rusterlium/rustler/blob/c2b0a7729a3a04333204107173eedd838f48d44e/rustler/src/types/mod.rs#L122)) An example can be found [in the tests](https://github.com/rusterlium/rustler/blob/c2b0a7729a3a04333204107173eedd838f48d44e/rustler_tests/native/rustler_test/src/test_tuple.rs#L22).

[jonmdev]

Thank you! Yes, it worked like this:

use rustler::{NifResult }; 

mod my_atoms {
    rustler::atoms! {
        ok
   }
}

#[rustler::nif]
fn get_ok() -> NifResult<(rustler::atom, String)> { 
        return Ok((my_atoms::ok(), "hello".to_string()));
}

But this is definitely poorer structurally than the also working plain Result version I posted here: #660 (reply in thread)

So I will stick with that Result method. Thanks again.