postscriptum 0.1.0

Multi-interpreted-language scripting engine for Rust with Rhai and Python backends
Documentation
use rhai::Engine;
use std::marker::PhantomData;
use std::sync::Arc;

/// A trait for Rhai-callable functions that abstracts over different function arities.
pub trait RhaiFunction: Send + Sync + 'static {
    fn register(&self, engine: &mut Engine);
}

// --- Arity-0 functions (nullary) --------------------------------------------------------

pub struct RhaiFunction0<F, R>
where
    F: Fn() -> R + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    name: String,
    func: Arc<F>,
    _phantom: PhantomData<R>,
}

impl<F, R> RhaiFunction for RhaiFunction0<F, R>
where
    F: Fn() -> R + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    fn register(&self, engine: &mut Engine) {
        let name = self.name.clone();
        let func = self.func.clone();
        engine.register_fn(&name, move || func());
    }
}

pub fn wrap_rhai_fn0<F, R>(name: impl Into<String>, func: F) -> Arc<dyn RhaiFunction + Send + Sync>
where
    F: Fn() -> R + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    Arc::new(RhaiFunction0 {
        name: name.into(),
        func: Arc::new(func),
        _phantom: PhantomData,
    })
}

// --- Arity-1 functions (unary) ----------------------------------------------------------

pub struct RhaiFunction1<F, A, R>
where
    F: Fn(A) -> R + Send + Sync + 'static,
    A: Clone + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    name: String,
    func: Arc<F>,
    _phantom: PhantomData<fn(A) -> R>,
}

impl<F, A, R> RhaiFunction for RhaiFunction1<F, A, R>
where
    F: Fn(A) -> R + Send + Sync + 'static,
    A: Clone + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    fn register(&self, engine: &mut Engine) {
        let name = self.name.clone();
        let func = self.func.clone();
        engine.register_fn(&name, move |a: A| func(a));
    }
}

pub fn wrap_rhai_fn1<F, A, R>(
    name: impl Into<String>,
    func: F,
) -> Arc<dyn RhaiFunction + Send + Sync>
where
    F: Fn(A) -> R + Send + Sync + 'static,
    A: Clone + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    Arc::new(RhaiFunction1 {
        name: name.into(),
        func: Arc::new(func),
        _phantom: PhantomData,
    })
}

// --- Arity-2 functions (binary) ---------------------------------------------------------

pub struct RhaiFunction2<F, A, B, R>
where
    F: Fn(A, B) -> R + Send + Sync + 'static,
    A: Clone + Send + Sync + 'static,
    B: Clone + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    name: String,
    func: Arc<F>,
    _phantom: PhantomData<fn(A, B) -> R>,
}

impl<F, A, B, R> RhaiFunction for RhaiFunction2<F, A, B, R>
where
    F: Fn(A, B) -> R + Send + Sync + 'static,
    A: Clone + Send + Sync + 'static,
    B: Clone + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    fn register(&self, engine: &mut Engine) {
        let name = self.name.clone();
        let func = self.func.clone();
        engine.register_fn(&name, move |a: A, b: B| func(a, b));
    }
}

pub fn wrap_rhai_fn2<F, A, B, R>(
    name: impl Into<String>,
    func: F,
) -> Arc<dyn RhaiFunction + Send + Sync>
where
    F: Fn(A, B) -> R + Send + Sync + 'static,
    A: Clone + Send + Sync + 'static,
    B: Clone + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    Arc::new(RhaiFunction2 {
        name: name.into(),
        func: Arc::new(func),
        _phantom: PhantomData,
    })
}

// --- Arity-3 functions (ternary) --------------------------------------------------------

pub struct RhaiFunction3<F, A, B, C, R>
where
    F: Fn(A, B, C) -> R + Send + Sync + 'static,
    A: Clone + Send + Sync + 'static,
    B: Clone + Send + Sync + 'static,
    C: Clone + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    name: String,
    func: Arc<F>,
    _phantom: PhantomData<fn(A, B, C) -> R>,
}

impl<F, A, B, C, R> RhaiFunction for RhaiFunction3<F, A, B, C, R>
where
    F: Fn(A, B, C) -> R + Send + Sync + 'static,
    A: Clone + Send + Sync + 'static,
    B: Clone + Send + Sync + 'static,
    C: Clone + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    fn register(&self, engine: &mut Engine) {
        let name = self.name.clone();
        let func = self.func.clone();
        engine.register_fn(&name, move |a: A, b: B, c: C| func(a, b, c));
    }
}

pub fn wrap_rhai_fn3<F, A, B, C, R>(
    name: impl Into<String>,
    func: F,
) -> Arc<dyn RhaiFunction + Send + Sync>
where
    F: Fn(A, B, C) -> R + Send + Sync + 'static,
    A: Clone + Send + Sync + 'static,
    B: Clone + Send + Sync + 'static,
    C: Clone + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    Arc::new(RhaiFunction3 {
        name: name.into(),
        func: Arc::new(func),
        _phantom: PhantomData,
    })
}

// --- Arity-4 functions (quaternary) -----------------------------------------------------

pub struct RhaiFunction4<F, A, B, C, D, R>
where
    F: Fn(A, B, C, D) -> R + Send + Sync + 'static,
    A: Clone + Send + Sync + 'static,
    B: Clone + Send + Sync + 'static,
    C: Clone + Send + Sync + 'static,
    D: Clone + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    name: String,
    func: Arc<F>,
    _phantom: PhantomData<fn(A, B, C, D) -> R>,
}

impl<F, A, B, C, D, R> RhaiFunction for RhaiFunction4<F, A, B, C, D, R>
where
    F: Fn(A, B, C, D) -> R + Send + Sync + 'static,
    A: Clone + Send + Sync + 'static,
    B: Clone + Send + Sync + 'static,
    C: Clone + Send + Sync + 'static,
    D: Clone + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    fn register(&self, engine: &mut Engine) {
        let name = self.name.clone();
        let func = self.func.clone();
        engine.register_fn(&name, move |a: A, b: B, c: C, d: D| func(a, b, c, d));
    }
}

pub fn wrap_rhai_fn4<F, A, B, C, D, R>(
    name: impl Into<String>,
    func: F,
) -> Arc<dyn RhaiFunction + Send + Sync>
where
    F: Fn(A, B, C, D) -> R + Send + Sync + 'static,
    A: Clone + Send + Sync + 'static,
    B: Clone + Send + Sync + 'static,
    C: Clone + Send + Sync + 'static,
    D: Clone + Send + Sync + 'static,
    R: Clone + Send + Sync + 'static,
{
    Arc::new(RhaiFunction4 {
        name: name.into(),
        func: Arc::new(func),
        _phantom: PhantomData,
    })
}

/// Rhai-specific function bundle
#[derive(Clone)]
pub struct RhaiFunctionBundle {
    pub functions: Vec<Arc<dyn RhaiFunction + Send + Sync>>,
}

impl Default for RhaiFunctionBundle {
    fn default() -> Self {
        Self::new()
    }
}

impl RhaiFunctionBundle {
    pub fn new() -> Self {
        Self {
            functions: Vec::new(),
        }
    }

    pub fn add_fn0<F, R>(&mut self, name: &str, f: F)
    where
        F: Fn() -> R + Send + Sync + 'static,
        R: Clone + Send + Sync + 'static,
    {
        let func = wrap_rhai_fn0(name, f);
        self.functions.push(func);
    }

    pub fn add_fn1<F, A, R>(&mut self, name: &str, f: F)
    where
        F: Fn(A) -> R + Send + Sync + 'static,
        A: Clone + Send + Sync + 'static,
        R: Clone + Send + Sync + 'static,
    {
        let func = wrap_rhai_fn1(name, f);
        self.functions.push(func);
    }

    pub fn add_fn2<F, A, B, R>(&mut self, name: &str, f: F)
    where
        F: Fn(A, B) -> R + Send + Sync + 'static,
        A: Clone + Send + Sync + 'static,
        B: Clone + Send + Sync + 'static,
        R: Clone + Send + Sync + 'static,
    {
        let func = wrap_rhai_fn2(name, f);
        self.functions.push(func);
    }

    pub fn add_fn3<F, A, B, C, R>(&mut self, name: &str, f: F)
    where
        F: Fn(A, B, C) -> R + Send + Sync + 'static,
        A: Clone + Send + Sync + 'static,
        B: Clone + Send + Sync + 'static,
        C: Clone + Send + Sync + 'static,
        R: Clone + Send + Sync + 'static,
    {
        let func = wrap_rhai_fn3(name, f);
        self.functions.push(func);
    }

    pub fn add_fn4<F, A, B, C, D, R>(&mut self, name: &str, f: F)
    where
        F: Fn(A, B, C, D) -> R + Send + Sync + 'static,
        A: Clone + Send + Sync + 'static,
        B: Clone + Send + Sync + 'static,
        C: Clone + Send + Sync + 'static,
        D: Clone + Send + Sync + 'static,
        R: Clone + Send + Sync + 'static,
    {
        let func = wrap_rhai_fn4(name, f);
        self.functions.push(func);
    }

    /// Register all functions in the bundle to the Rhai engine
    pub fn register(&self, engine: &mut Engine) {
        for func in &self.functions {
            func.register(engine);
        }
    }
}