Expressions

Anywhere a value goes can compute it with an expression: attribute values, {…} in strings, if conditions, for … in, and the right-hand sides of declarations.

Expressions are pure. They read names and return values, and never change anything. An expression that reads state is evaluated again when the state changes.

Values

There are six kinds of value:

• { title } is short for { title: title }.
• A trailing comma is allowed in lists, records and calls.
• type_of(x) names a value's kind: "null", "bool", "number", "text", "list" or "record".

Values as text

Where a value is shown as text, in interpolation or an attribute:

For more control, use format_number, percent, join and round (Standard functions).

Truthiness

Conditions (if, &&, ||, !, when) read a value as true or false: null, false, 0, empty text and an empty list are false, and everything else is true, including every record.

Names and fields

• A name reads the scope: a declaration, a prop, a companion's value, or a loop variable.
• A path, post.author.name, reads a field, then its field. On a list, .len is its length.
• A field of a computed value is written after ), ] or }: first(posts).title, { a: 1 }.a.

Reading a name the scope doesn't have, or a field a record doesn't have, is an error. The exception is .field after ), ] or }, which gives null for a missing field. Check first with has(record, "field"), or read with get(record, "field"), which gives null.

Operators

Arithmetic needs numbers: text that reads as a number ("42") counts as one, and anything else is an error, such as "a" * 2.

Comparison:

• When both sides read as numbers (numbers, or text such as "10"), they're compared as numbers: "10" == 10 is true, and "9" < "10" is true.
• Otherwise both sides are compared as text, so lists compare by their text, and any two records are equal. Compare their fields instead.
• null is equal only to null.

Precedence

From loosest to tightest. Every binary operator groups from the left.

So:

• a ?? b + 1 is a ?? (b + 1).
• xs |> len > 2 compares the length: a pipe binds tighter than a comparison, as in Elixir.
• !a == b is rejected, since it's easy to misread: write a != b, or (!a) == b.
• a < b < c compares a < b, a boolean, with c. Write a < b && b < c.
• An if extends as far right as it can, so put one inside other operators in parentheses: 1 + (if big then 10 else 0).

Calls and pipes

A function is called with parentheses, f(x, y), never f x: attributes are separated by spaces, so juxtaposition would be ambiguous.

A pipe passes the value on its left as a call's first argument, so a chain reads left to right:

let shown = posts |> filter(p -> p.published) |> sort_by(p -> p.date) |> reverse |> take(5)
for p in shown { p "{p.title}" }

A pipe into a function with no other arguments needs no parentheses: name |> trim |> lower.

The functions are the standard functions and any the scope adds with Scope::function, which win over a standard function of the same name. Calls to standard functions are checked when the template is parsed: the number of arguments, and where lambdas go.

Lambdas

A lambda is a function written inline, only as a function's argument:

let done = todos |> filter(t -> t.done)
let labels = todos |> map((t, i) -> text(i + 1) + ". " + t.title)
p "{done.len} done: {join(labels)}"

• t -> expr takes one parameter, and (a, b) -> expr takes two.
• The lambdas of map, filter, find, find_index, any, all and count may take a second parameter: the item's index, from 0.
• A lambda reads the names around it, and its parameters hide them.

Records and lists, updated

Values are never changed in place. A step that "changes" a list or record builds a new one:

Updating null with { r | a: 1 } gives a new record { a: 1 }.

List comprehensions

[expression | generators and conditions] builds a list, read left to right:

let open = [t.title | t <- todos, !t.done]
let pairs = [[x, y] | x <- xs, y <- ys, x != y]
ul { for title in open { li "{title}" } }

• name <- list goes through a list, with name as each item for everything after it. Later generators nest inside earlier ones, so pairs takes every y for each x.
• A condition keeps only the items for which it holds.
• A list that's null (not loaded yet) gives nothing to go through, so the result is [].

It's a shorter way to write filter then map: [t.title | t <- todos, !t.done] is todos |> filter(t -> !t.done) |> map(t -> t.title).

To add one item, put it in brackets: todos + [item]. Without them, todos + item is an error: + only adds a list to a list.