Reference Manual

This chapter is the compact language reference for CEL expressions. It gathers the core grammar, token categories, type names, literal forms, operators, standard-library operations, collections, closures, and sharp edges in one place.

Concept

CEL is an expression language. Every source form in this chapter produces a value or helps compose one. Use the tutorial chapters for worked prose, and use this chapter when you need the exact grammar or a concise rule table.

Syntax

expression = range_expression .
range_expression = ".." [ or_expression ]
                 | "..=" or_expression
                 | or_expression [ ".." [ or_expression ] | "..=" or_expression ] .
or_expression = and_expression { "||" and_expression } .
and_expression = comparison_expression { "&&" comparison_expression } .
comparison_expression = bitwise_or_expression
    [ ("==" | "!=" | "<" | ">" | "<=" | ">=") bitwise_or_expression ] .
bitwise_or_expression = bitwise_xor_expression { "|" bitwise_xor_expression } .
bitwise_xor_expression = bitwise_and_expression { "^" bitwise_and_expression } .
bitwise_and_expression = bitwise_shift_expression { "&" bitwise_shift_expression } .
bitwise_shift_expression = additive_expression { ("<<" | ">>") additive_expression } .
additive_expression = multiplicative_expression { ("+" | "-") multiplicative_expression } .
multiplicative_expression = cast_expression { ("*" | "/" | "%") cast_expression } .
cast_expression = unary_expression { "as" identifier } .
unary_expression = (("-" | "!") unary_expression) | postfix_expression .
postfix_expression = primary_expression {
    "(" [ argument_list ] ")" | "." (unsuffixed_integer | identifier [ "(" [ argument_list ] ")" ])
} .
argument_list = expression { "," expression } .
primary_expression = literal
                   | identifier [ record_fields ]
                   | tuple_or_group
                   | array_expression
                   | if_expression
                   | closure_expression .
record_fields = "{"
    [ field_initializer { "," field_initializer } [ "," ] ] "}" .
field_initializer = identifier ":" expression .
tuple_or_group = "(" [ expression [ "," [ expression { "," expression } ] ] ] ")" .
array_expression = "[" [ expression { "," expression } ] "]"
                 [ ":" type_expr ] .
type_expr = identifier [ "(" type_expr { "," type_expr } ")" ]
          | "[" type_expr "]"
          | "(" [ type_expr [ "," [ type_expr { "," type_expr } ] ] ] ")" .
if_expression = "if" expression "{" expression "}"
              [ "else" ( "{" expression "}" | if_expression ) ] .
closure_expression = "||" expression
                   | "|" closure_param { "," closure_param } "|" expression .
closure_param = identifier ":" type_expr .

Worked examples

(1, 2).0
if ok && ready { [1, 2] } else { [3, 4] }
|pair: (i32, i32)| pair.0 + pair.1
1 + 2..=3 * 4
true as i32

Token table

Type table

Literal table

Operator precedence table

Operator rules table

Numeric call table

All functions in this table belong to the standard library and are available when the evaluation environment installs it. See Standard library for worked examples and fuller prose.

• None of the documented functions are integer-only.
• sqrt, floor, ceil, trunc, fract, and round_ties_even are float-only.
• min, max, and clamp support both integers and floats.
• abs and signum support signed integers and floats, but not unsigned integers.

Collection table

Closure table

Exact rules

• Calls accept zero or more comma-separated arguments and do not accept a trailing comma.
• Tuple indexing uses .N with an unsuffixed integer and may be chained.
• Unannotated arrays are non-empty and homogeneous. A complete type annotation permits an empty array and must match the element type exactly.
• Tuples and arrays are distinct forms and compose recursively, including registered leaves, source unit, and callable values.
• Rust interoperability uses Array<T>, source-ordered canonical lists (Nil/Cons witnesses), and Callable<Args, R> (FnOf witness). Array<Array<T>> converts to Vec<Array<T>>, not allocation-preserving deep native vectors. See collections.
• Arbitrary erased external values require complete shape checks. PreparedSegment and prepared_segment::PreparedRawSegment validate at preparation, not each invocation. Clone, equality, and formatting are explicit independent capabilities.
• Native Rust operations can serve interpreted CEL through typed adapters. A macro-compiled CEL backend does not yet exist.
• Comparison expressions consume one comparison operator.
• Range forms do not chain.
• expr.name and expr.name() invoke the same host-provided unary operation. expr.name(a, b) passes the receiver first, followed by explicit arguments. Each operand evaluates once in source order. A value binding named name does not hide a dot operation, and the member label is not a variable reference.
• (expr.name)() calls the operation’s result normally; it fails if the result is not callable. Dot operations, ordinary calls, and tuple indexing share postfix precedence and may be chained.
• TypeName { field: expression, ... } constructs a host-registered record. Constructor names belong to the type namespace, separate from value names. Field labels are not variable references. Every schema field is required exactly once; unknown, duplicate, missing, and incorrectly typed fields are errors. Field expressions evaluate once in written order, independent of schema order. An empty schema permits TypeName {}; a non-empty field list permits a trailing comma.
• Field types match exactly: an f64 field accepts 1.0, not the i32 literal 1. The static checker uses installed record schemas and operation signatures; known custom types retain their identities instead of unifying with unrelated types. Unknown constructors are errors. Unresolved inputs and calls without metadata remain best-effort, but all their child expressions are still checked.
• Unparenthesized record constructors are forbidden throughout an if condition. Parentheses, call arguments, tuple elements, and array elements start unrestricted expression positions: write if (Sample { value: 3.0 }.value) > 0.0 { ... }. The restriction propagates through operators, ranges, and closure bodies.
• Members are reads/operations, not assignment targets. CEL has no member assignment.
• CEL does not use bracket postfix indexing such as expr[0].
• CEL does not define map literals, object literals, or a ternary operator.
• A closure body resolves its own parameters and does not capture free variables from the enclosing expression.
• A one-element tuple type requires (T,); (T) is grouping.

Edge cases

• Signed +, signed binary -, signed unary -, and signed * overflow report arithmetic overflow.
• Integer / and % failures report division by zero.
• Negative, too-large, or non-u32-fitting shift counts report shift overflow.
• a < b < c is not valid; write a < b && b < c.
• 1..2..3 is not valid.
• ..= is not valid without a right endpoint.
• [] is not valid.
• [(0, 1), (true, 2)] is not valid because element shapes differ.