HoloLang / Syntax

Field references, literals, operators, date operations and aggregate functions: the parts every rule is built from.

Syntax Reference

Field References

Fields from the data model are referenced with the @ prefix. Field names must match the data structure exactly:

# Simple field references
@company_siret
@f110_net_n
@exercise_start_date

# Nested field access (dot notation for objects with subproperties)
@salary.amount
@employee.address.city
@grossremuneration.iso4217currencycode

For nested objects, use dot notation to access subproperties. Each part of the path must exist in the data.

The whole payload.@document is a reserved root naming every extracted field as one value. It is legal wherever a container is (STRINGIFY(@document) hands the whole document to an LLM_JUDGE prompt) and is a type error in a comparison. @document.total is @total spelled from the root, indexes included (@document.reps[0].nom). Like enriched, it wins over a schema field of the same name. In a dossier's validity rules @document is the document being judged; in a dossier's consistency rules the bare requirement inside STRINGIFY (STRINGIFY(@case.documents.releve)) is the bound document's whole payload.

# Every field of the document, as one JSON value
ASSERT LLM_JUDGE(CONCAT('Is this a genuine payslip? ', STRINGIFY(@document)))
ASSERT STRINGIFY(@document) CONTAINS 'SARL'

# A field spelled from the root - the same thing as @total
ASSERT @document.total == @document.subtotal + @document.tax WITHIN 0.01

Literals

Numbers (integers and decimals, can be negative) and strings (single or double quoted):

# Numbers
100
-50.5
0

# Strings
'SARL'
"active"

Operators

Precedence, tightest first: ( ) → functions → ^ → */ → +- → & → comparisons → NOT → AND/OR.

The left side of a comparison takes a field or a function call, never bare arithmetic: ASSERT @a - @b > 0 does not parse. Write ASSERT ABS(@a - @b) > 0, or move the arithmetic to the right side.

Functions and Predicates

Every function below returns a value and may therefore lead a comparison, which plain arithmetic cannot. The predicates are the exception: they answer a yes/no question and belong where a condition goes.

# Presence as a question: an optional block that must be complete once started
IF ISPRESENT(@guarantor) THEN REQUIRED @guarantor_income
IF ISBLANK(@married_name) THEN REQUIRED @birth_name
WARN IF ISBLANK(@iban)
ASSERT NOT ISBLANK(@tax_number)

# Substring, folded like ==
ASSERT @line_label CONTAINS 'urssaf'
ASSERT @line_label NOT CONTAINS 'cancelled'
IF @title CONTAINS 'invoice' THEN REQUIRED @total_incl_tax

# Every element / at least one element - conditions, never vacuous
ASSERT ALL(@statements[].balance > 0)
IF ANY(@representatives[].role == 'Manager') THEN REQUIRED @company_register
WARN IF NOT ALL(@statements[].is_valid == 'false' OR @statements[].balance > 0)

# Membership in an array expression, element by element
ASSERT @client_name IN ARRAY_AGG(@representatives[].name)
ASSERT @naf_code NOT IN ARRAY_CONCAT(@excluded_codes, @suspended_codes)

# Fallbacks, so an optional field can enter a formula
@total = @base + IFNULL(@bonus, 0)
ASSERT IFNULL(@married_name, @birth_name) == @account_holder

# Scalar helpers
ASSERT @rent <= MAX(@income_1, @income_2) / 3
@vat = ROUND(@amount_excl_tax * 0.2, 2)

# Age and gaps
ASSERT DATEDIFF(TODAY, @birth_date, YEAR) >= 18
ASSERT ABS(DATEDIFF(@signature_date, @issue_date, DAY)) <= 30

# Power, and building text
@area = @side ^ 2
@full_name = @first_name & ' ' & @last_name
ASSERT @account_holder == @first_name & ' ' & @last_name

Date Operations

HoloLang supports date literals, the TODAY keyword for relative date checks, and date interval tolerances.

Date Literals

Use DATE(year, month, day) for fixed date comparisons:

# Compare against a fixed date
ASSERT @due_date > DATE(2026, 01, 15)
ASSERT @start_date < @end_date

# Equality with date interval tolerance
ASSERT @filing_date == DATE(2026, 01, 15) WITHIN 7 DAY

TODAY - Relative Date Checks

Use TODAY for dynamic date comparisons relative to the current date. Combine with + or - and a date interval for offset checks:

# Must be in the future
ASSERT @due_date > TODAY

# Must be within the last 6 months
ASSERT @statement_date > TODAY - 6 MONTH

# Must not be more than 1 year out
ASSERT @end_date < TODAY + 1 YEAR

# Must be within 3 weeks of today
ASSERT @filing_date == TODAY WITHIN 3 WEEK

# Conditional: active items must expire in the future
IF @is_active == 1 THEN ASSERT @expiry_date > TODAY

Aggregate Functions

Aggregate functions operate on array fields. Use [] to indicate array iteration:

The one bracket rule.[] means per element, and it only ever lives inside an aggregate's argument: COUNT(@representants[]), SUM(@items[].amount), ARRAY_AGG(@reps[].nom). A bare array path is the array as ONE value, which is what the ARRAY_* value functions take: ARRAY_LENGTH(@representants), ARRAY_TO_STRING(@representants, ', '), STRINGIFY(@representants). A [] anywhere else is a parse error with a hint, and a path carries at most one [].

# Sum all amounts in line items
@total = SUM(@items[].amount)

# Count number of transactions
ASSERT COUNT(@transactions[]) > 0

# Verify total matches sum of parts
ASSERT @invoice_total == SUM(@line_items[].subtotal) WITHIN 0.01

# Check average value
ASSERT AVG(@scores[].value) >= 50

# Combine with other expressions
@grand_total = SUM(@items[].amount) + @tax + @shipping

# Filtered aggregates (WHERE clause on an item field)
@revenue = SUM(@items[].amount) WHERE category == 'Revenue'
ASSERT COUNT(@transactions[]) > 0 AND SUM(@transactions[].amount) != 0

# Collect elements into an array, and scan it
ASSERT ARRAY_AGG(@representants[].nom) CONTAINS @nom_client

# Join elements into one string (delimiter defaults to ',')
ASSERT STRING_AGG(@lignes[].description, ' | ') CONTAINS 'panneau'

# Oldest / newest element - MIN/MAX work on numbers, dates and strings
ASSERT MIN(@bank_statements[].start_date) <= TODAY - 3 MONTH
ASSERT MAX(@bank_statements[].end_date) >= TODAY - 1 MONTH

Element Expressions

The aggregate argument may be a full expression over one array's [] references (arithmetic, CONCAT, any value function), evaluated once per element:

# Per-element arithmetic: line totals against the invoice total
ASSERT SUM(@lignes[].quantite * @lignes[].prix_unitaire) == @total WITHIN 0.01

# Per-element composition, ordered, filtered, joined into one readable string
ASSERT ARRAY_TO_STRING(ARRAY_AGG(CONCAT(@bank_statements[].start_date, ' - ', @bank_statements[].end_date) ORDER BY start_date) WHERE is_valid == 'true', ', ') CONTAINS '2026-01-01'

# A scalar reference beside element references is legal - it reads the
# document once per element
ASSERT ARRAY_AGG(CONCAT(@societe, ':', @reps[].nom)) CONTAINS 'ACME'

Three rules apply:

• All [] references in one aggregate must share the same array. Two different arrays are refused with an explanation.
• Aggregates cannot nest.
• The expression form is loud on bad data: a non-numeric string inside SUM's arithmetic errors the rule, where the bare-path form keeps its historical quiet skip.

Quantifiers: ALL / ANY

ALL(condition) and ANY(condition) evaluate one condition once per element of one array, the same element context an aggregate's argument gets. They are predicates, not values: they go where a condition goes and take NOT, AND and OR.

# Every statement in credit
ASSERT ALL(@releves[].solde > 0)

# A condition on any element, gating a requirement
IF ANY(@representants[].qualite == 'Gérant') THEN REQUIRED @kbis

# Composed per element; a scalar field beside the element references is legal
WARN IF NOT ALL(@bs[].is_valid == 'false' OR @bs[].solde > 0)
ASSERT ANY(@representants[].nom == @nom_client)

# Predicates nest inside; arithmetic is allowed on the RIGHT side
ASSERT ALL(ISPRESENT(@representants[].nom))
ASSERT ALL(@plafond >= @lines[].qty * @lines[].price)

# "No element does" - because an empty array is false for ANY as well
ASSERT NOT ANY(@bs[].solde < 0)

Four rules apply:

• The condition holds at least one [] reference, all on one array. Two roots are refused.
• No aggregate or quantifier nests inside.
• A quantifier is never a value, so ALL(…) == 'true' is a parse error.
• Neither is ever vacuous. An empty or absent array is false for ALL as for ANY, so an array with nothing in it never passes as “every element passed”. Write “no element does” as NOT ANY(…).

A failing quantifier reports a tally, ALL(@bs[].solde > 0) [2 of 3 elements], and the same 2/3 lands in the rule's actual values. In a dossier's consistency rules the array may also be a requirement's documents, for example ALL(@case.documents.releves[].siren == @case.documents.kbis.siren); see the dossier documentation.

Array Value Functions

These take the bare array: the array as one value, no []. Names and semantics are BigQuery's; the recorded divergences follow the language's own missing-path rule (quiet absence) rather than BigQuery's NULL errors.

Where an array value can flow. An array value is accepted in four places:

• as an ARRAY_* function's array operand;
• inside STRINGIFY;
• as the LEFT (haystack) side of CONTAINS, CONTAINS_SUBSTR and CONTAINS_ALL_WORDS, where ARRAY_AGG(@reps[].nom) CONTAINS 'DUPONT' scans the elements;
• as the RIGHT side of IN / NOT IN, where it is a set of whole values. @nom_client IN ARRAY_AGG(@reps[].nom) tests each element with the engine's own ==, as IN ('a', 'b') does, and an empty set is false, never an error.

Only an array expression gets this; the older @x IN @field keeps its split-the-string reading. Scalar positions refuse an array at authoring time: ARRAY_AGG(...) == 'x', arithmetic, CONCAT arguments (use ARRAY_TO_STRING), and LLM_JUDGE's prompt directly (wrap it in STRINGIFY or ARRAY_TO_STRING).

Element Indexing

A path may select one element by position: 0-based like BigQuery's bare subscript, and negative counts from the end (our recorded divergence: BigQuery only has that in ARRAY_SLICE). By deliberate contrast, SUBSTRING, LEFT and RIGHT stay 1-based, BigQuery's own split.

# First and last element
ASSERT @representants[0].nom == @nom_dirigeant
ASSERT @representants[-1].nom == @nom

# Composes with dotted paths and with iteration
ASSERT @a[0].b[2].c == 5
ASSERT COUNT(@reps[0].adresses[]) > 0

# Out of range resolves quietly to absent, like any missing path - gate it:
IF COUNT(@representants[]) > 0 THEN ASSERT ISPRESENT(@representants[0].nom)

An indexed path is legal everywhere a plain reference is (comparisons, ISPRESENT/ISBLANK, function arguments), but not as a formula assignment target.