Question: Is it possible to have an indexer return a callable closure back to Rhai?

[makspll]

I am trying to attach an indexer function which performs a dynamic lookup on a function registry (basically bunch of Arc<fn>'s with a specifc signature).

I want to be able to:

let my_dynamic_type = ...
my_dynamic_type.dynamic_function("asd")
my_dynamic_type.dynamic_function2("asd")

given:

#[derive(Clone, Debug, Copy, PartialEq)]
pub struct RhaiStaticReflectReference(pub TypeId);

impl CustomType for RhaiStaticReflectReference {
    fn build(mut builder: rhai::TypeBuilder<Self>) {
        builder
            .with_name(std::any::type_name::<RhaiStaticReflectReference>())
            .with_indexer_get(|self_: &mut Self, index: Dynamic| {
                let world = ThreadWorldContainer.get_world();
                let type_id = self_.0;
                let key: ScriptValue = ScriptValue::from_dynamic(index)?;

                let key = match key.as_string() {
                    // i.e. `dynamic_function` is looked up
                    Ok(name) => match world.lookup_function([type_id], name) {
                        Ok(func) => return ScriptValue::Function(func).into_dynamic(),
                        Err(key) => ScriptValue::String(key),
                    },
                    Err(key) => key,
                };

                let world = ThreadWorldContainer.get_world();
                Err::<_, Box<EvalAltResult>>(
                    InteropError::missing_function(type_id, key.display_with_world(world.clone()))
                        .into(),
                )
            });
    }
}

I know that Dynamic supports FnPtr which you can create via a ScriptFuncDef, however that seems to only be appropriate for actual "script defined" functions