Calling two different julia functions in same frame

[jeenou]

Hello again!

Thanks for previous help. I have another question about calling multiple julia functions in same frame. I want to call one julia function and use the result as a parameter in the next function.

The code I have now is this:

pub fn _node2<T>(name: &str, is_commodity: bool, is_market: bool) {
    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("src/Project/src/structures.jl")
                .expect("Could not include file");
        }
    }

    // An extended target provides a target for the result we want to return and a frame for
    // temporary data.
    let _x = julia.scope(|mut frame| {

        let n_name = JuliaString::new(&mut frame, name).as_value(); 
        let n_commodity = Value::new(&mut frame, is_commodity); 
        let n_market = Value::new(&mut frame, is_market); 
        

        //First function    
        let module = "Structures"; 
        let function = "create_node"; 
        let _result_node = _call_julia_function3(frame, module, function, n_name, n_commodity, n_market);
        

        //Convert node to commodity if is_commodity is true

        if is_commodity {
            match _result_node {
                Ok(value) => {
                //Second function that takes result_node as a parameter
                    let convert_function = "convert_to_commodity";
                    let convert_result = _call_julia_function1(frame, module, convert_function, value);
                    match convert_result {
                        Ok(_) => println!("Node converted to commodity"),
                        Err(error) => println!("Error converting node to commodity: {:?}", error),
                    }
                }
                Err(error) => println!("Error creating node: {:?}", error),
            }
        }

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

}

Call julia functions:

pub fn _call_julia_function1<'scope, 'a>(mut frame: GcFrame<'scope>, module: &str, function: &str, data1: Value<'scope, 'a>) -> Result<jlrs::prelude::Value<'scope, 'a>, std::boxed::Box<JlrsError>>
{
    unsafe {
        Module::main(&frame)
            .submodule(&frame, module)?
            .as_managed()
            .function(&frame, function)?
            .as_managed()
            //geneerinen call on olemassa myös
            .call1(&mut frame, data1)
            .into_jlrs_result()
    }
}
pub fn _call_julia_function3<'scope, 'a>(mut frame: GcFrame<'scope>, module: &str, function: &str, data1: Value<'scope, 'a>, data2: Value<'scope, 'a>, data3: Value<'scope, 'a>) -> Result<jlrs::prelude::Value<'scope, 'a>, std::boxed::Box<JlrsError>>
{
    unsafe {
        Module::main(&frame)
            .submodule(&frame, module)?
            .as_managed()
            .function(&frame, function)?
            .as_managed()
            //geneerinen call on olemassa myös
            .call3(&mut frame, data1, data2, data3)
            .into_jlrs_result()
         
    }
}

[Taaitaaiger]

The issue with your functions is that they take ownership of the frame, so it can't be used again. What you need to do is let those functions take a mutable reference to a GcFrame instead.

However, it's better to take a Target so you can call the function with other targets than just a GcFrame, and return the result without converting the exceptions to a JlrsError if one has been thrown. You also don't need to annotate the data1 argument with a scope lifetime (NB: the data lifetime is only relevant if you deal with Julia arrays whose contents are borrowed from Rust, otherwise it can always be assumed to be 'static). Something like this should work:

pub fn _call_julia_function1<'target, 'data, T: Target<'target>>(
    target: T, 
    module: &str, 
    function: &str, 
    data1: Value<'_, 'data>
) -> JlrsResult<ValueResult<'target, 'data, T>> {
    unsafe {
        let res = Module::main(&target)
            .submodule(&target, module)?
            .as_managed()
            .function(&target, function)?
            .as_managed()
            //geneerinen call on olemassa myös
            .call1(target, data1);

        Ok(res)
    }
}

[jeenou]

Hi,

still I have a problem with moved value in frame. In this line:

let _convert_result = _call1(frame, module, _convert_function, value).unwrap();

it says in frame:

"use of moved value: frame
value used here after move"

pub fn _node2(name: &str, is_commodity: bool, is_market: bool) {
let mut frame = StackFrame::new();
let mut pending = unsafe { RuntimeBuilder::new().start().expect("Could not init Julia") };
let mut julia = pending.instance(&mut frame);

// Include some custom code defined in MyModule.jl.
// This is safe because the included code doesn't do any strange things.
unsafe {
    let path = PathBuf::from("structures.jl");
    if path.exists() {
        julia.include(path).expect("Could not include file");
    } else {
        julia
            .include("src/Predicer/src/structures.jl")
            .expect("Could not include file");
    }
}

// An extended target provides a target for the result we want to return and a frame for
// temporary data.
let _x = julia.scope(|mut frame| {

    let n_name = JuliaString::new(&mut frame, name).as_value(); 
    let n_commodity = Value::new(&mut frame, is_commodity); 
    let n_market = Value::new(&mut frame, is_market); 
    

        
    let module = "Structures"; 
    let function = "create_node"; 
    let _result_node = _call3(frame, module, function, n_name, n_commodity, n_market).unwrap();
    

    //Convert node to commodity if is_commodity is true


    if is_commodity {
        match _result_node {
            Ok(value) => {
                let _convert_function = "convert_to_commodity";
                let _convert_result = _call1(frame, module, _convert_function, value).unwrap();
                match _convert_result {
                    Ok(_) => println!("Node converted to commodity"),
                    Err(error) => println!("Error converting node to commodity: {:?}", error),
                }
            }
            Err(error) => println!("Error creating node: {:?}", error),
        }
    }

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

}

pub fn call1<'target, 'data, T: Target<'target>>(
target: T,
module: &str,
function: &str,
data1: Value<', 'data>
) -> JlrsResult<ValueResult<'target, 'data, T>> {
unsafe {
let res = Module::main(&target)
.submodule(&target, module)?
.as_managed()
.function(&target, function)?
.as_managed()
//geneerinen call on olemassa myös
.call1(target, data1);

    Ok(res)
}

}

pub fn call2<'target, 'data, T: Target<'target>>(
target: T,
module: &str,
function: &str,
data_1: Value<', 'data>,
data_2: Value<'_, 'data>
) -> JlrsResult<ValueResult<'target, 'data, T>> {
unsafe {
let res = Module::main(&target)
.submodule(&target, module)?
.as_managed()
.function(&target, function)?
.as_managed()
//geneerinen call on olemassa myös
.call2(target, data_1, data_2);

    Ok(res)
}

}

pub fn call3<'target, 'data, T: Target<'target>>(
target: T,
module: &str,
function: &str,
data_1: Value<', 'data>,
data_2: Value<', 'data>,
data_3: Value<', 'data>
) -> JlrsResult<ValueResult<'target, 'data, T>> {
unsafe {
let res = Module::main(&target)
.submodule(&target, module)?
.as_managed()
.function(&target, function)?
.as_managed()
//geneerinen call on olemassa myös
.call3(target, data_1, data_2, data_3);

    Ok(res)
}

}

[Taaitaaiger]

let _result_node = _call3(frame, module, function, n_name, n_commodity, n_market).unwrap();

You move the frame here, you need to use &mut frame instead like you did earlier in the function. I would have liked to not implement Target for GcFrame itself, but that prevents &GcFrame from being used as a non-rooting target.

[jeenou]

Thank you!