Suggestion: allow deriving `Template` on enums

[tema3210]

Restrictions: Each enum variant should be tuple like with exactly one variant, wrapped type of each variant should implement Template
Semantics: While useless for top level pages(??), it may be handy for component templates:

• we make dispatch for template components automatic;
• their enumeration easy
• when one wants to render one of many variants of template, currently others still need to be initialized resulting in waste of memory as well as the need to fill unused variants somehow (hello Option and template level matching)

Consider:

#[derive(Template)]
enum OrderStatus {
  Arrived(ArrivedOrder),
  Delivery(DeviveryOrder),
  PendingConfirmation(ConfirmOrder)
}

Isn't that nice?

Edit: removed pointless annotation

[djc]

So what would order_status.html look like in this case?

[tema3210]

So what would order_status.html look like in this case?

Indeed, it's unnecessary.

[djc]

So basically this is kind of a generic derive that forwards to the trait implementation for the unit variant's nested type? I guess other crates already provide something like that...

[Kijewski]

I would lose the single element requirement, and would turn your example

#[derive(Template)]
#[template(path = "hello.html")]
enum OrderStatus {
    Arrived(<elements...>),
    Delivery(<elements...>),
    PendingConfirmation { <elements...> },
}

into:

const _: () = {
    impl Template for OrderStatus {
        fn render(&self) -> Result<String> {
            match self {
                Arrived(_) => {
                    Template_Arrived(<elements...>).render()
                },
                Delivery(<elements...>) => {
                    Template_Delivery(<elements...>).render()
                },
                PendingConfirmation(<elements...>) => {
                    Template_PendingConfirmation(<elements...>).render()
                },
            }
        }

        fn render_into(&self, writer: &mut impl Write + ?Sized) -> Result<()> {
            match self {
                Arrived(<elements...>) => {
                    Template_Arrived(<elements...>).render_into(writer)
                },
                Delivery(<elements...>) => {
                    Template_Delivery(<elements...>).render_into(writer)
                },
                PendingConfirmation { <elements...> } => {
                    Template_PendingConfirmation { <elements...> }.render_into(writer)
                },
            }
        }
    }

    #[derive(Template)]
    #[template(path = "hello.html")]
    struct Template_Arrived<'a>(<&'a elements...>);

    #[derive(Template)]
    #[template(path = "hello.html")]
    struct Template_Delivery<'a>(<&'a elements...>);

    #[derive(Template)]
    struct Template_PendingConfirmation<'a> { <&'a elements...> };
};

Should be easy enough to implement since all the magic can be done by syn, no actual implementation needed.

Most likely it would be more useful to put #[template(…)] next to the variants instead of the enum itself, or the enum could function as the default, that variants can override. But then the problem remains what if not every variant has the same mime-type?

[Kijewski]

I implemented a very simplistic version of my idea, but I don't think there's anymore needed:

• https://crates.io/crates/askama-enum
• https://docs.rs/askama-enum/0.0.1/askama_enum/derive.EnumTemplate.html
• https://github.com/Kijewski/askama-enum

This might serve as a better/simpler multiple templates per struct approach than #600. What do y'all think?

[djc]

It seems nice but pretty niche. :) It's probably good enough as a solution for this issue?

[tema3210]

It seems nice but pretty niche. :) It's probably good enough as a solution for this issue?

Yes. thanks @Kijewski.