Calling multiple different julia functions in Rust

[jeenou]

Hello again,

how can I call multiple different julia functions in Rust so that it could be modular and I don't have to call them in same frame.

For example I have this julia function that I want to call:

function my_fu(x::Int)
return x + 1
end

I have tried to call it in here and return the result:

pub fn call_my_fu(p: i32) -> JlrsResult {
// Initialize the Julia runtime
let mut frame = StackFrame::new();
let mut pending = unsafe { RuntimeBuilder::new().start().expect("Could not init Julia") };
let mut julia = pending.instance(&mut frame);

unsafe {
    let path = PathBuf::from("structures.jl");
    if path.exists() {
        julia.include(path).expect("Could not include file");
    } else {
        julia
            .include("path/structures.jl")
            .expect("Could not include file");
    }
}

let _x = julia.scope(|mut frame| {

    let n_p = Value::new(&mut frame, p); 
              
    let module = "Structures"; 
    let function = "my_fu"; 
    let result = juliainterface::_call1(&mut frame, module, function, n_p).unwrap().into_jlrs_result()?;    

    result
    
}).expect("result is an error");

}

So I could use the result later on as parameter for example in this julia function:

function my_ofu(f::Function, x::Int)
result = f(x)
println("The result is: ", result)
end

I have to call multiple different julia functions in my project so it would be inconvenient to call them all in the same frame, so I need to preserve the results from the functions somewhere to be used again in different julia function. 

[Taaitaaiger]

You can't return Julia data from the scope whose frame roots it. You can either perform all operations you need inside a scope, or if the data is an isbits type you can unbox it and return it because it won't have any lifetimes after it has been unboxed. However, in that second case you will need to convert it to Julia data again in another scope if you want to call some Julia function with it as an argument.

The reason is that while data is rooted in a frame, it won't be freed by the GC until you leave that scope. When you leave a scope, all the roots hat belong to it are cleared and can be freed by the GC if it can't be found through another root which is still valid. By inheriting the lifetime of the frame (or more generally, the target), Julia data can't be returned from the scope in which it has been rooted, which avoids use-after-free bugs.

[jeenou]

I think that unboxing data and converting it again to Julia data in another scope is the answer to my problem, but how do I that? Do you have any examples of that?

[Taaitaaiger]

You need to call Value::unbox to unbox and Value::new to rebox. Basically a Value is a pointer to some data managed by Julia, unboxing converts that pointer to a reference and clones the data.

Any type that implements Unbox can be unboxed, and any type that implements IntoJulia can be boxed. There are a bunch of types that implement these traits "out of the box", like primitive types. For other types it's recommended to generate them from their Julia implementation with the functionality provided by the Reflect module in JlrsCore:

using JlrsCore.Reflect

struct TypeA
    # ...fields
end

struct TypeB{T}
    # ...fields
end

...

layouts = reflect([TypeA, TypeB, ...]);

# Print layouts to standard output
println(layouts)

# Write layouts to file
open("julia_layouts.rs", "w") do f
    write(f, layouts)
end

The interface is pretty simple, you can provide a Vector of types and bindings will be recursively generated for them and the types used as their field types. As long as a type is an isbits type with no type parameters, the generated Rust struct will implement IntoJulia and Unbox.