
Show HN: Askama – Type-safe, compiled Jinja-like templates for Rust - dochtman
https://github.com/djc/askama
======
bajsejohannes
There's also Bart
([https://github.com/maghoff/bart](https://github.com/maghoff/bart)), inspired
by Mustache. Like Askama, it's typesafe and compile time generated.

~~~
maggit
Hi! I'm the author of Bart. AMA :)

Askama and Bart seem to be pretty similar in use (compile time, based on a
struct definition) except for the template languages. Askama is rich, while
Bart, like Mustache, is deliberately more restricted. ("Logicless", they would
call it. I don't know how to quantify that.)

------
eptcyka
I just wish rocket and diesel got the new tokio goodness, then Rust will
probably replace flask in my workflow.

~~~
d--b
wow, I must have missed a generation, I have literally no idea what you're
talking about.

~~~
steveklabnik
[http://tokio.rs/](http://tokio.rs/) : async io

[https://rocket.rs/](https://rocket.rs/) : a web framework

[http://diesel.rs/](http://diesel.rs/) : ORM/Querybuilder

------
Entangled
Django/Jinja/Stencil should be the de facto standard for all templating
systems so developers can port their work to any platform without sweat.

Kudos for porting Jinja to Rust.

~~~
orf
Jinja yes, django not so much.

~~~
strig
It's essentially the same syntax

~~~
orf
Kind of but not really, Jinja let's you do a lot more. {{(x or y)|filter(z)}}
for example, or even just {{function(a, b, c)}}.

Django is far more restrictive in what you can put between the braces. I think
one of the design goals of it was that designers with little programming
knowledge could write the templates, which is a noble idea but leads to
frustration as anyone who has maintained a large django app will tell you.

~~~
benwilber0
I think part of the motivation for the limitations was to stop people from
putting too much business logic in their templates. You can of course
implement any kind of tag or filter you want and just use that. Or indeed just
use Jinja if you want. Django's templates are perfectly fine and I still
prefer them over the similar alternatives.

~~~
orf
Yeah, I understand the motivation but it doesn't help when you just want to
call a model method with just a single argument.

They are also dog slow :(

------
Entangled
> Because Askama will generate Rust code from your template files, the crate
> will need to be recompiled when your templates change.

Being Swift a compiled language just like Rust, why can we modify the
templates (Stencil, Mustache) in Swift without recompiling the app but not in
Rust?

~~~
detaro
Stencil and Mustache do that because they _don 't_ compile to Swift, but load
and parse templates dynamically. That kind of template language implementation
of course exists for Rust as well. (And the other way round, you could have a
system that's like this submission for Swift, if there isn't one already)

~~~
Entangled
That's exactly the point, why do that in Rust when it can be done without the
need for compiling it? That's the explanation I want to hear. Having to
recompile the whole app just to test changes in the template is absurd in my
handbook.

~~~
dochtman
My main reason was type safety; getting early feedback from the compiler is
really valuable to me.

I don't see compiling them as a big downside, either. What problems do you see
with that?

Tera ([https://github.com/Keats/tera](https://github.com/Keats/tera)) exists
already if that's more your cup of tea.

------
vvanders
This looks awesome, if I'm understanding this right there's type checking with
the template at compile time(I.E. if "name" in the template isn't found in the
Rust struct it's a compile failure).

~~~
dochtman
You understood it right.

