Module std::text::template

Go-style text/template rendering.

Parse a template string with parse / try_parse, then render the compiled Template against a Ctx value. Directives inside {{...}} are substituted; all other text passes through verbatim.

Supported directives

Directive	Meaning
{{.key}}	Substitute the scalar bound to key in the context
{{.}}	Substitute the current element (inside {{range}})
{{if .key}}...{{end}}	Render body only when key is non-empty/non-zero
{{if .key}}...{{else}}...{{end}}	Conditional with else branch
{{range .key}}...{{end}}	Iterate a list; inside the body . is the item

Errors

try_parse and render_try return TemplateError: UnclosedDirective, UnclosedBlock, UnexpectedTag, DotOutsideRange, or UnknownDirective. parse and render_template panic with the same human-readable message.

Method-style rendering

Method calls such as t.render(ctx) and t.render_try(ctx) are deferred pending cross-module trait-method dispatch support for imported stdlib user records. Use template.render_template(t, ctx) or template.render_try(t, ctx) instead.

Data model

Because Hew has no reflection and recursive enum/vec nesting is not yet supported by the v0.5 codegen-front, the context is a flat Ctx value with two independent parallel-vector maps:

• scalar map — string keys to string values (integers and bools are stored pre-rendered via ctx_set_int / ctx_set_bool).
• list map — string keys to flat-stored lists of string items, indexed by per-entry start/length metadata.

WHY (flat design): Vec<Entry> where Entry carries a Vec field is rejected by the v0.5 codegen-front ("recursive owned clone/drop thunk synthesis not implemented"). Recursive enum variants (Value::List(Vec<Value>)) trigger the same limit. The flat parallel-vec layout works within these constraints with no expressiveness loss for the basic template surface.

WHEN: replace with a proper recursive Value type once the codegen-front lifts the recursive-clone restriction.

WHAT: the real model is enum Value { Str(string), Num(i64), Bool(bool), Null, List(Vec<Value>), Map(Ctx) } with Ctx as HashMap<string, Value>.

Examples

import std::text::template;

fn main() {
    let ctx = template.new_ctx();
    template.ctx_set_str(ctx, "name", "Alice");
    template.ctx_set_int(ctx, "age", 30);
    let items: Vec<string> = Vec::new();
    items.push("red");
    items.push("green");
    template.ctx_set_list(ctx, "colours", items);

    let t = template.parse("Hello {{.name}}, age {{.age}}!");
    let result = template.render_try(t, ctx);
    match result {
        Ok(s) => println(s),
        Err(e) => println(e),
    }
}

import std::text::template;

fn main() {
    let ctx = template.new_ctx();
    template.ctx_set_str(ctx, "greeting", "hello");
}

template.ctx_set_str(ctx, "name", "Alice");

template.ctx_set_int(ctx, "count", 42);

template.ctx_set_bool(ctx, "active", true);

let colours: Vec<string> = Vec::new();
colours.push("red");
colours.push("blue");
template.ctx_set_list(ctx, "colours", colours);

import std::text::template;

fn main() {
    let ctx = template.new_ctx();
    template.ctx_set_str(ctx, "who", "world");
    let t = template.parse("hello {{.who}}!");
    let r = template.render_try(t, ctx);
    match r {
        Ok(s) => println(s),    // "hello world!"
        Err(_) => println("template error"),
    }
}