std/expression/lib

The typed tree behind a quoted parameter: Expression<Value> type checks its argument as an ordinary Value and hands it over together with the expression tree that produced it.

A caller writes nothing special for this - passing an ordinary Value where a parameter is declared Expression<Value> is enough. Only the compiler creates one; ExpressionNode is the data an ordinary function can build as well.

• assert - the one function most callers need an Expression<Bool> for.

A place in a source file: what Expression.location and a diagnostic point at.

A description of a type. Data, not reflection: there is no way back from a TypeReference to a type.

The prefix operators a quoted expression can carry, one case per operator.

The infix operators a quoted expression can carry, one case per operator.

Names are already resolved and everything is typed: implicit _, named closure parameters, receivers and implicit self show up as explicit Parameter, Field and Call nodes.

An ordinary ADT. New node kinds come with new versions of the language; providers end their match with _ => Fail(Unsupported(...)) anyway, because they need that arm for calls they do not know.

The name of what was written, never its value: nameOf(user.email) is "email", nameOf(limit) is "limit". For a type there is the compile-time function typeName<User>() instead.

fn label(value: Expression<Int>): String {
  nameOf value
}

const limit = 5
print label(limit)

Panics if condition is false. There are no matchers: the message names the source text of the condition and every value the condition read from around it, one per line, and then the site:

panic: Assertion failed: count < limit
  count = the Int 7
  limit = the Int 5
  at acme/app/src/main.trb:12:1

A scalar - every integer type, every float, Bool, Char and String - is shown as the <kind> <value>, where the word is the language's name for the kind of value and not the name of its type, so Int for an Int64 and Float for a Float64. Everything else is shown by its name and its type, found: Point: a value of the program shown in full needs the whole Show machinery of its type and of every type under it in the binary, and one type that has none would refuse the whole build. Until a capture carries its own encoded value, that is the one thing the two implementations word differently - the interpreter writes a value of type List where a compiled binary writes the name and the type.

const limit = 5
const count = 7
assert(count < limit)

When condition is false.