How to register a rust function that can accept a rhai closure?

[harudagondi]

I am writing a library that exposes fundsp as a rhai module, and I don't know how to register a rust function that can accept a rhai closure. It seems that the rhai book does not mention how to do this.

For example, I want to register a function that looks like this:

fn lfo<F>(f: F) -> Box<dyn AudioUnit32> 
where
    F: Fn(f32) -> Box<dyn AudioUnit32>
{
    Box::new(hacker32::lfo(f))
}

(hacker32 is just a prelude, and Box is clonable)

How exactly do you do this for this situation?

[schungx]

https://rhai.rs/book/language/fn-ptr.html#call-a-function-pointer-within-a-rust-function-as-a-callback

fn lfo(context: NativeCallContext, fp: FnPtr) -> Result<ReturnType, Box<EvalAltResult>> {
    fp.call_within_context(&context, ...)
}

[harudagondi]

tl;dr: Is there a way to register a function that can accept a rhai closure, convert it to a rust closure, and pass it to a different function?

---

I am trying to register every function in the fundsp::hacker32 prelude. All of these functions return An combinators, similar to iterator combinators in rust std.

e.g.

vec![1, 2, 3].into_iter().filter(|x| x % 2 == 0).map(|x| x - 1)

returns a value with a type of:

Map<Filter<IntoIter<{integer}>, [closure]>, [closure]>

that can be boxed to become Box<dyn Iterator<Item = i32>>

similar to how in fundsp:

tag(0, 440.0) >> sine() * 0.2 >> split::<U2>()

returns a value of type:

An<Pipe<f32, Pipe<f32, Tagged<f32>, Unop<f32, Sine<f32>, FrameMulScalar<UInt<UTerm, B1>, f32>>>, Split<UInt<UInt<UTerm, B1>, B0>, f32>>>

that can be boxed to become Box<dyn AudioUnit32>.

Recently, the author of fundsp implemented Clone for every type that implements AudioUnit32, so that it can be used for scriptability stuff. As such, I am trying to make fundsp scriptable using rhai (although I am open to exploring other solutions such as rune, ketos, lua, etc)

Some function are relatively simple. If a function accept only base types such as floats, integers, and other simple clonable stuff, the function would look like this

pub type AudioUnit = Box<dyn h::AudioUnit32>;
pub fn allpass() -> AudioUnit {
 	Box::new(hacker32::allpass())
}
pub fn allpass_hz(f: f32, q: f32) -> AudioUnit {
	Box::new(hacker32::allpass_hz(f, q))
}
pub fn allpass_q(q: f32) -> AudioUnit {
	Box::new(hacker32::allpass_q(q))
}
pub fn allpole() -> AudioUnit {
	Box::new(hacker32::allpole())
}
pub fn allpole_delay(delay_in_samples: f32) -> AudioUnit {
	Box::new(hacker32::allpole_delay(delay_in_samples))
}
// and many more...

I am boxing all of them because the functions in hacker32 return the combinators themselves.

Others have generics in their function, so I just manually registered them.

However, there are functions that accept closures, like:

pub fn branch<N, X, F>(f: F) -> An<MultiBranch<N, f32, X>>
where
    N: Size<f32>,
    N: Size<X>,
    X: AudioNode<Sample = f32>,
    X::Inputs: Size<f32>,
    X::Outputs: Size<f32> + Mul<N>,
    <X::Outputs as Mul<N>>::Output: Size<f32>,
    F: Fn(i64) -> An<X>

pub fn envelope<E, R>(f: E) -> An<Envelope<f32, f32, E, R>>
where
    E: Fn(f32) -> R
    R: ConstantFrame<Sample = f32>,
    R::Size: Size<f32>,

pub fn phaser<X: Fn(f32) -> f32>(
    feedback_amount: f32,
    phase_f: X,
) -> An<impl AudioNode<Sample = f32, Inputs = U1, Outputs = U1>>

(ConstantFrame is clonable, and An can be boxed. The most important thing to note here is f, where it is a closure.)

Is there a way to register a function that can accept a rhai closure, convert it to a rust closure, and pass it to a different function?

[schungx]

OK, let me see if I understand you here:

• hacker32 has functions that return types that all implement AudioUnit32.
• You create Rhai versions of those of those functions by calling into the hacker32 implementation and then Boxing the result to form trait objects that implement AudioUnit32
• You want to create Rhai versions of certain hacker32 functions that accept closures.
• You want those Rhai versions to accept Rhai closures instead.

Am I understanding you correctly?

For example, to implement phaser in Rhai, you'd want a signature:

cosnt FACTOR = 2;

let an = phaser(feedback_amount, |x| x * FACTOR);

[harudagondi]

Yes, I want something like that.

[schungx]

I'm wondering because usually Box<dyn h::AudioUnit32> is not clonable. It shouldn't be able to work with Rhai.

[schungx]

You'd need to use something like Rc<dyn h::AudioUnit32> in order to make it clonable and use it with Rhai...

[schungx]

This works:

fn phaser(x: i64, callback: impl Fn(i64) -> i64) -> i64 {
    callback(x)
}

let mut engine = Engine::new();

engine.register_fn("phaser", |context: NativeCallContext, x: i64, fp: FnPtr| {
    // in a real application you'd not just 'unwrap' but you'd be handling errors
    let callback = Box::new(|x| fp.call_within_context(&context, (x,)).unwrap());
    phaser(x, callback)
});

assert_eq!(
    engine.eval::<i64>("
            const FACTOR = 2;
            phaser(21, |x| x * FACTOR)
    ")?,
    42
);

However, it looks like you'd want to encapsulate that closure directly into the return value (what you call the "combinator").

[schungx]

Are you using the sync feature?

[harudagondi]

Not yet. I was originally not using sync because when dealing with audio, types shouldn't be Sync for performance and correctness reasons. sync requires all types to also be Send + Sync, which is not feasible. Wrapping the AudioUnit32 in a mutex is also not feasible, since mutexes block the thread (i need it to not block the thread).

[schungx]

In that case I can't see why you'd be getting complaints about Send+Sync... Can you copy out some error messages here?

[harudagondi]

Here's the gist: https://gist.github.com/harudagondi/4ca499a1646122f346f9772ac78ec2e9

It's pretty confusing, since the AudioUnit32 trait only requires Send, but the error says it needs to implement Sync (?)

[schungx]

I believe your problem came from An or something requiring Send. You cannot use my example here. It isn't what you want - what you need is to encapsulate the closure into a type (your combinator) which allows it to run later on. You can't do that with this code.

Try my code in the other answer.

[schungx]

This somewhats recreates what you want to do with fundsp. It requires liberal uses of Rc and interior mutability to get around the cloning issue. In other words, you cannot just use Box<dyn Trait> because it is not clonable.

use std::cell::RefCell;
use std::rc::Rc;

type SingleNode = Rc<dyn Node>;

trait Node {
    fn run(&self, x: i64) -> i64;
}

struct PhaserNode {
    func: Box<dyn Fn(i64) -> i64>,
}

impl Node for PhaserNode {
    fn run(&self, x: i64) -> i64 {
        (self.func)(x)
    }
}

// say, this is fundsp's implementation of phaser with closure parameter
// that you'd like to call
fn phaser(callback: impl Fn(i64) -> i64 + 'static) -> impl Node {
    PhaserNode {
        func: Box::new(callback),
    }
}

let mut engine = Engine::new();

let ast = Rc::new(engine.compile(
    "
        const FACTOR = 2;
        phaser(|x| x * FACTOR)
    ",
)?);

let shared_engine = Rc::new(RefCell::new(Engine::new_raw()));   // dummy Engine for now
let engine2 = shared_engine.clone();
let ast2 = ast.clone();

engine.register_fn("phaser", move |fp: FnPtr| {
    let engine = engine2.clone();
    let ast = ast2.clone();

    let callback = Box::new(move |x: i64| fp.call(&engine.borrow(), &ast, (x,)).unwrap());

    Rc::new(phaser(callback)) as SingleNode
});

// replace the dummy Engine with the real one
*shared_engine.borrow_mut() = engine;

// run the script and get back a node
let cb = shared_engine.borrow().eval_ast::<SingleNode>(&ast)?;

// that node can be run
assert_eq!(cb.run(21), 42);

[schungx]

@harudagondi use this one instead. This more closely matches what you want to do, which is to return a type that encapsulates a Rhai closure which can be call by a Rust function later on.

It is very simple to do when all you work with are concrete values, such as the Pipe<T> type for instance. If you're working with a type that internally holds execution logic, plus those logic contains captured external variables in the form of a closure, you essentially have a really involved situation.

[schungx]

Warning: This is relative advanced and convoluted Rust code. It will NOT be easy to understand or fit into your own program. Try to get the idea behind it first.

[harudagondi]

Thank you, I'll try implementing this :) I'll just have to wrap my head around this a little longer