nodes

Base class for all AST nodes.

All nodes track their source location for error reporting. Nodes are immutable for thread-safety.

Root node representing a complete template.

Type declaration: {% template page: Page, site: Site %}

Kida-native feature for type-aware validation.

Template inheritance: {% extends "base.html" %}

Named block for inheritance: {% block name %}...{% end %}

Kida uses unified {% end %} for all block closings.

Include another template: {% include "partial.html" %}

Import functions from template: {% import "funcs.html" as f %}

Import specific functions: {% from "funcs.html" import button, card %}

Output expression: {{ expr }}

Raw text data between template constructs.

Conditional: {% if cond %}...{% elif cond %}...{% else %}...{% end %}

Kida uses unified {% end %} instead of {% endif %}.

For loop: {% for x in items %}...{% empty %}...{% end %}

Kida uses {% empty %} (not {% else %}) and {% end %} (not {% endfor %}).

Async for loop: {% async for x in async_items %}...{% end %}

Native async iteration without wrapper adapters.

While loop: {% while cond %}...{% end %}

Kida-native feature.

Pattern matching: {% match expr %}{% case pattern [if guard] %}...{% end %}

Kida-native feature for cleaner branching than if/elif chains. Supports optional guard clauses for conditional matching.

With guards: {% match api_type %} {% case _ if 'python' in api_type %}Python API {% case _ if 'rest' in api_type %}REST API {% case _ %}Other {% end %}

Template-scoped variable: {% let x = expr %} or {% let a, b = 1, 2 %}

Variables declared with 'let' persist across the template and can be modified within inner scopes. Supports tuple unpacking on the left-hand side.

Kida-native replacement for Jinja's confusing namespace() workaround.

Block-scoped variable: {% set x = expr %} or {% set a, b = 1, 2 %}

Variable is scoped to current block. Use 'let' for template-wide scope. Supports tuple unpacking on the left-hand side.

Export variable from inner scope: {% export x = expr %} or {% export a, b = 1, 2 %}

Explicitly exports a variable from an inner scope (like a for loop) to the enclosing scope. Makes scope behavior explicit and predictable. Supports tuple unpacking on the left-hand side.

Capture block content: {% capture x %}...{% end %}

Kida-native name (clearer than Jinja's {% set x %}...{% endset %}).

Function definition: {% def name(args) %}...{% end %}

Kida uses functions with true lexical scoping instead of macros. Functions can access variables from their enclosing scope.

Slot for component content: {% slot %}

Used inside {% def %} to mark where caller content goes.

Call function with body content: {% call name(args) %}body{% end %}

The body content fills the {% slot %} in the function.

Fragment caching: {% cache key %}...{% end %}

Kida-native built-in caching. No external dependencies required.

Jinja2-style context manager: {% with x = expr %}...{% end %}

Always renders body with variable bindings.

Conditional with block: {% with expr as name %}...{% end %}

Renders body only if expr is truthy. Binds the evaluated expression to the specified variable name(s).

This provides nil-resilience: the block is silently skipped when the expression evaluates to None, empty collections, or other falsy values.

Syntax:

{% with page.author as author %}
    <span>{{ author.name }}</span>
{% end %}

{% with page.author %}
    <span>{{ it.name }}</span>
{% end %}

{% with a, b as x, y %}
    {{ x }}, {{ y }}
{% end %}

Behavior:

• Evaluates expr once
• If truthy: binds result to target, renders body
• If falsy: renders empty block (if provided), or skips entirely
• Restores previous variable binding after block

Contrast with standard With node:

• With: Always renders body with variable bindings
• WithConditional: Only renders if expression is truthy

Apply filter to block: {% filter upper %}...{% end %}

Control autoescaping: {% autoescape true %}...{% end %}

Raw block (no template processing): {% raw %}...{% end %}

Whitespace control block: {% trim %}...{% end %}

Kida-native replacement for Jinja's {%- -%} modifiers. Content inside is trimmed of leading/trailing whitespace.

Break out of loop: {% break %}

Exits the innermost for/while loop. Part of RFC: kida-modern-syntax-features.

Skip to next iteration: {% continue %}

Skips to the next iteration of the innermost for/while loop. Part of RFC: kida-modern-syntax-features.

Remove whitespace between HTML tags: {% spaceless %}...{% end %}

Removes whitespace between > and <, preserving content whitespace. Part of RFC: kida-modern-syntax-features.

Embed template with block overrides: {% embed 'card.html' %}...{% end %}

Like include, but allows overriding blocks in the embedded template. Part of RFC: kida-modern-syntax-features.

Base class for expressions.

Constant value: string, number, boolean, None.

Variable reference: {{ user }}

Tuple expression: (a, b, c)

List expression: [a, b, c]

Dict expression: {a: b, c: d}

Attribute access: obj.attr

Optional attribute access: obj?.attr

Returns None if obj is None/undefined, otherwise obj.attr. Part of RFC: kida-modern-syntax-features.

Subscript access: obj[key]

Optional subscript access: obj?[key]

Returns None if obj is None/undefined, otherwise obj[key]. Part of RFC: kida-modern-syntax-features.

Slice expression: [start:stop:step]

Function call: func(args, **kwargs)

Filter application: expr | filter(args)

Pipeline operator: expr |> filter1 |> filter2

Kida-native syntax for readable filter chains. More readable than deeply nested Jinja filters.

Test application: expr is test(args) or expr is not test(args)

Binary operation: left op right

Unary operation: op operand

Comparison: left op1 right1 op2 right2 ...

Supports chained comparisons like: 1 < x < 10

Boolean operation: expr1 and/or expr2

Conditional expression: a if cond else b

Null coalescing: a ?? b

Returns b if a is None/undefined, otherwise a. Unlike 'or', doesn't treat falsy values (0, '', False, []) as missing. Part of RFC: kida-modern-syntax-features.

Range literal: start..end or start...end

Part of RFC: kida-modern-syntax-features.

Await expression: await expr

Native async support without auto_await() wrappers.

String concatenation: a ~ b ~ c

Multiple ~ operators are collapsed into a single Concat node for efficient string building.

Mark expression as safe (no escaping): {{ expr | safe }}

Loop variable access: {{ loop.index }}

Provides access to loop iteration state.

Inlined filter as direct method call (optimization).

Generated by FilterInliner for common pure filters like upper, lower, strip. The compiler generatesstr(value).method()instead of filter dispatch.