Mutable functions

[alpharder]

I know that using mutable functions at templates may sound like a bad idea, but it is what it is.

Is that possible without too much tinkering with generics?

FnMut cannot currently be passed to add_function.

[mitsuhiko]

I could implement Function for Mutex<FnMut(...) -> ...> which would allow this:

use std::sync::Mutex;

use minijinja::{render, value::Value};

fn main() {
    let mut counter = 0;
    let rv = render!(
        "{% for x in range(3) %}{{ f() }}{% endfor %}",
        f => Value::from_function(Mutex::new(move || {
            counter += 1;
            counter
        })),
    );
    assert_eq!(rv, "123");
}

But it would still require that function to be 'static. Borrowing from the stack would require something like the minijinja-stack-ref experiment I'm still not sure how to feel about. Would that restriction make sense for your use case?

[alpharder]

Would that restriction make sense for your use case?

Unfortunately, no.

I've just read this from minijinja-stack-ref:

because MiniJinja requires that all values passed to the template are owned by the runtime engine. Thus it becomes impossible to carry non static lifetimes into the template.

This now explains to me why

it would still require that function to be 'static.

My Rust knowledge is quite limited ATM, so I'm not able to fully understand the underlying limitation.

I guess that's a thoughtful design limitation, and I'm happy to accept that. Will re-consider design on my side instead.

Thanks for your reply!

[alpharder]

Question out of curiosity (feel free to ignore this, we're all busy people):

In my specific scenario I use axum and was planning to:

• clone non-Arced minijinja::Environment every time incoming HTTP request is handled (or create it from scratch, which I guess is more wasteful), so the cloned environment shouldn't be shared across threads I believe
• add a mutable function to the clone (which is intended to be a callback mutating a variable that belongs to the same runtime as the clone, not the values stored by minijinja::Environment nor template context)
• use the clone for rendering templates

From what I understand, in this scenario there should be no practical requirement of 'static lifetime for values passed to clone, right?

[mitsuhiko]

Can you share some code how you are passing data to the environment or the templates? That might make it easier to explain what is the best path to success.

[alpharder]

Thanks for your help. I've created a minimal reproduction repo: https://github.com/alpharder/minijinja-mut-fns-repro/blob/master/src/main.rs

[mitsuhiko]

This case seems simple enough that you can just use an Arc and Mutex yourself:

use std::sync::{Arc, Mutex};

let mut registered_fonts = Arc::new(Mutex::new(HashSet::<String>::new()));
{
    let registered_fonts = register_fonts.clone();
    document_template_renderer_env.add_function("register_font", move |font: String| {
        register_font(font, &available_fonts, &mut registered_fonts.lock().unwrap())
    });
}

You btw don't need to clone the env, you can pass your function when rendering:

use minijinja::{context, value::Value};

let ctx = context! {
    font => "Arial",
    register_font => Value::from_function(move |font: String| { ... })
};

let html_page = document_template_renderer_env
    .render_str(&template, &ctx)
    .unwrap();

Just not that you can't use the json! macro from serde_json toplevel for the context as a serde json value cannot hold a MiniJinja value, but you can put a serde json value into a MiniJinja context:

let ctx = context! {
    foo => json!{ ... }
};