How would I implement a trait within an engine and change plugin function signature?

[gitstashpop]

Hi, I'm very new to Rhai/Rust.

Problem

I would like to implement a trait in my Engine declaration code, and not expose functions in Rhai scripts that take the trait as an argument. For example, the implementation would be pub fn hello(arg1: &str, arg2: &str) but in Rhai, I would only want hello(arg2: &str) to be available.

I have a working example (which follows) without using Rhai plugin macros, but I was wondering if there is a better way to do this/something more idiomatic. It also seems like overriding each function that I implement this way with an implementation of the trait might not be the most scalable engine registration code.

Thanks!

Code

Rhai crate

pub trait Policy: Debug {
    fn is_allowed(&self, path: &str) -> bool;
}

pub fn my_fn(
    policy: &impl Policy,
    path: &str,
) -> Result<String, Box<EvalAltResult>> {
    if !policy.is_allowed(path) {
        return Err(format!("not allowed {}!!!", path).into());
    }

   // rest of my code
   ...
}

Engine creation code in a different crate

fn engine_create_and_register() -> Engine {
    let mut engine = Engine::new();

    // implements the trait Policy elsewhere
    let policy = MyImpl::new();

    let fn_overload =
        move |path: &str| -> Result<String, Box<EvalAltResult>> {
            my_fn(&policy, path)
        };

    engine.register_fn("my_fn", fn_overload);
    engine
}

Call my script

Notice that when my Rhai script is written, I do not need to provide the Policy implementation, which is my desired behavior

my_fn("/tmp/hello.txt");

[schungx]

Not very sure what you want to achieve... It seems to be working for you, correct?

If your function differs from the implementation in number of parameters, then you must obviously provide the missing arguments somehow. In your example you capture it in a closure.

This is very proper way to do things in Rust. They are different functions afterall...

[gitstashpop]

@schungx I really liked the cleanliness of using the procedural macros to generate a Rhai plugin. I break that model with my working implementation. I was generally looking to see if what I have is ok based on Rust/Rhai best practices and it sounds like the answer is yes. Thank you!

[schungx]

That's correct. If your functions encapsulate some data, then the only way to specify it is via a closure, which cannot be done with procedural macros.