Nested Templates

[seijikun]

At the moment, we unfortunately have massive compile-time performance problems (cargo check takes ~ 1min), because we have a lot of invocations of the same macro.

It's a simple table that is composed of invocations:

{% import "components/product_table.jinja" as product_table %}
{{ product_table::row("row1", []) }}
{{ product_table::row("row2", []) }}
{# ... #}

40 lines of this generate 40300 lines of rust code, because each macro invocation inserts the macro code inline.

I came up with the idea to convert the offending macro (that is called a lot of times) into its own Template struct:

    #[derive(Template)]
    #[template(ext = "html", source = r#"
        {% import "components/product_table.jinja" as product_table %}
        {{ product_table::row(title, values) }}
    "#)]
    pub struct Row<'a> {
        title: &'a str,
        values: &'a [TyValue<'a>],
        help: Option<&'a str>,
    }

and to then use it "macro-like":

{{ ui::Row::new("row1", []) | safe }}
{{ ui::Row::new("row2", []) | safe }}

This refactoring reduced the 40300 lines of generated code down to 3000.

Now, the product_table::row macro is only instantiated once, as part of the Row template and the code reused across the different invocations. Luckily, askama understands this and provides __askama_values for rendering. However, the content generated by the template invocation is escaped by default, so now I have to "unescape" each invocation by tagging it with the safe filter.

The askama documentation states this behaves like expected, but does it make sense?

[seijikun]

Since I assume that I'm not the only one with compile time performance issues, maybe we could think of some mechanism to make this escape-hatch more .. elegant?

An idea I came up with is introducing the keyword macrofn:

{% macrofn stuff(a, b) %}
    {{ a }} {{ b }}
{% endmacro %}

which would cause a macro to be expanded only once as its own rust function, instead of being instanced inplace.
I was imagining the function to look something like:

pub fn stuff<AskamaW, T0, T1>(
    __askama_writer: &mut AskamaW,
    __askama_values: &dyn askama::Values,
    a: T0,
    b: T1
) { /* ... */}

With the clear disadvantage, that it's variable scope is isolated. Only what is manually passed in is accessible.
@Kijewski @GuillaumeGomez What do you think about this idea, or do you have better ideas?

[seijikun]

The is defined checks only make sense for variables in the invocation scope though and not for macro arguments, right?
Because afaik, macro arguments are always defined - either explicitly, or with their default value.

{% macro test(argument_variable = "default_value") %}
    {% if argument_variable is defined %}
        {# afaik, this makes no sense - since arguments are always defined, even if they are optional (?) #}
    {% endif %}

    {# scope variables would not be supported by macrofns: #}
    {% if scope_variable is defined %}
    {% endif %}
{% endmacro %}

{% set scope_variable = 5 %}
{{ test("string") }}

That is what I meant with:

With the clear disadvantage, that it's variable scope is isolated. Only what is manually passed in is accessible.

Or did I misunderstand something?

[GuillaumeGomez]

Ah I see, so you want to limit the variable scope. That'd be a pretty big limitation, hence why you suggested to add new macrofn I suppose. Yeah, makes sense.

[seijikun]

Exactly. I don't see a way to implement this for normal macros, other than introduce a limited askama-specific variant.

[GuillaumeGomez]

Yeah I agree. It's a pretty good idea too. What do you @Kijewski ?

[seijikun]

After thinking some more about this ... I don't think this will work without #514

[Kijewski]

However, the content generated by the template invocation is escaped by default, so now I have to "unescape" each invocation by tagging it with the safe filter.

Have a look at the trait HtmlSafe. If you add the line:

impl askama::filters::HtmlSafe for Row<'_> {}

Then you don't have to manually mark invocations as | safe.

[seijikun]

This is absolutely ingenious. Thank you!