Value

A value is an expression, in the context of a statement, that provides a value to that statement. Values, statements and conditions work together to express business logic at an appropriate level of abstraction — detailed enough to be meaningful, but not so specific as to constrain implementation.

RIDDL 2.0 replaced what had been a mostly-opaque quoted string with a real value-expression system. A literal string is still accepted everywhere, so pseudo-code remains available where structure would be false precision.

The Seven Forms¶

Form	Syntax	Meaning
Literal	`"some text"`	Opaque pseudo-code, or a literal constant
Value reference	`order.total`	A field, state field, function input, or `let` local
Constructor	`OrderPlaced(id, total = x)`	Builds a message or record
Get	`get from input SignupForm`	Reads a UI input or an entity state
Call	`call function Pricing.Total(a, b)`	Invokes a pure function for its result
Prompt	`prompt("compute the discount")`	A value computed by AI at generation time
Boolean	`a > b and not c`	A structured boolean expression

Value References¶

A value reference names something in scope. Four sources are consulted, in order:

the on clause's message binding — bare ord is the whole message, ord.field reaches into it
a field of the handled message, the entity state, or a function's requires input
a definition reached by a qualified path, such as GState.active
a named constant

A let local is also a value reference, but resolves lexically rather than through the symbol table: it is visible only after its declaration and is shadowed inside nested blocks.

Constructors¶

A constructor builds a message or record inline, rather than requiring it be assembled elsewhere first:

yield event OrderPlaced(orderId, total = cart.total, currency = "USD")
morph entity Order to state Done with record DoneData()

Arguments are positional first, then named. Count, names, ordering and (best effort) types are all checked against the target's fields.

Get¶

get from reads a value from a UI input or an entity state:

let email   = get from input SignupForm
let current = get from state Active

Call¶

call invokes a function — and only a function, since functions are the only definitions guaranteed pure — and produces its result:

let total = call function Pricing.CalculateTotal(subtotal, taxRate = rate)

A call is value-producing rather than a bare statement, so it composes with let, set, return and constructor arguments. Calling something that declares no returns is an Error.

Prompt¶

prompt("...") denotes a value computed by AI at generation time:

set field recommendation to prompt("suggest a complementary product")

It is distinguished from the do statement by its parentheses. The statement describes an action for a human to implement; the value denotes something AI computes.

Boolean Expressions¶

Precedence runs or < and < not < comparison < atom, with parentheses to group:

when order.isPaid and not (order.isCancelled or order.isRefunded) then ??? end

and, or, not, true and false are context-sensitive: they are recognized only inside a boolean expression, so they remain legal identifiers everywhere else in the language.

Comparisons are type-safe and reference-only

Both operands of a comparison must be a typed reference — a value reference, a get from, or a named constant — never a literal. This is enforced at parse time, so count > 5, count > "5", count > true and count > R(1) all fail to parse.

To compare against a fixed value, name it:

constant MaxItems is Natural = "100"
when cart.itemCount > MaxItems then error "too many items" end

The point is to remove magic constants from models and to make every comparison check the types on both sides. == and != require operands of the same category; <, >, <= and >= require an ordered numeric type on both sides.

true and false remain valid boolean atoms — usable with and, or, not, and standalone — just not as comparison operands.

Where Values Are Used¶

Statement	Operand
`set`	the assigned value
`let`	the bound expression
`put`	the published value
`return`	the returned value
`send`, `tell`, `yield`	a message reference or constructor
`morph`	a record reference or constructor
`when`, `require`, `invariant`	a condition
`match`	the subject, and each comparison pattern's comparand

Occurs In¶

Contains¶

Values may contain other values — a constructor's arguments, a call's arguments, and a boolean expression's operands are all themselves values.