Grid · Section

Sigils

The seven single-character markers

Reference

Sigils.

Grid's expression grammar is built from a small, closed set of single-character markers. Each one means exactly one thing. Together they form a complete navigation algebra: addressing, projection, matching, linking, type and slot declaration, existence quantification.

The set is locked at seven. The discipline is: extend the language only when a real invariant cannot be expressed in the current set. Adding sigils for ergonomic convenience is forbidden. Strict equality only at the kernel; ranges, comparisons, and fuzzy matching live in prose inside cell bodies, not in the sigil grammar.

For how sigils compose into full expressions, see Language.


`@`, address

The spatial position of a cell. Every address starts with @/.

Five forms:

FormMeaning
@/path/to/cellAbsolute address
@./restRelative; appended to the current context's address
@../restParent; strips the last segment, appends rest
*Single-segment wildcard inside an address
**Deep wildcard across segments

Examples:

study: @/finances/tx/9281
study: @/finances/tx/*           # all direct children of /finances/tx
study: @/finances/**             # everything under /finances
study: type=transaction | study: @./agent-reasoning
study: @/finances/tx/1/note | study: @../

The relative forms (@./, @../) resolve against the current pipeline result. Each cell in the prior stage becomes a context for the next.

`:`, slot projection

Reads a single slot value off a cell.

Syntax: @/path/to/cell:slotname

Returns a synthetic cell whose body is the slot's value. Useful for extracting one field without rendering the whole body.

study: @/finances/tx/9281:amount

If the slot exists, you get back one synthetic cell. If it doesn't, the result is empty.

`=`, strict equality

Equality comparison on a slot, address, or value.

study: @/** where: slot: status = paid
study: @/** where: type = transaction
study: @/** where: address = @/finances/tx/9281

Strict equality only; no fuzzy match, no case folding. For ranges (<, >, <=, >=), the same slot: predicate accepts those operators.

`&`, reference

Marks an explicit reference from one cell to another. Always appears as &@/path inside a cell body.

A cell whose body contains &@/X is an explicit reference to @/X. The reverse-reference index materialized at @/system/refs is built from exactly these sigils. Bare address mentions in prose do not count.

The sigil is what separates intentional links from incidental mentions.

Example cell body:

Met with &@/people/sarah today. We discussed &@/projects/probe-v2.

Queries that use the reference index:

study: refs-of: @/people/sarah                 # cells that cite sarah
study: @/** where: refs @/projects/probe-v2    # same, predicate form

`?`, existence quantifier

A world-state predicate. ?@/path is true if and only if at least one cell matches the path in the current capability projection.

Always appears as ?@/path in a where: clause.

study: type=note where: ?@/system/capabilities/admin
study: type=invoice where: ?@/accounts/closed/**

The first returns all notes if and only if an admin capability cell exists somewhere in the grid. The second returns invoices if any cell under /accounts/closed/ exists.

?@ is independent of the candidate being filtered. It asks a question about the grid as a whole, and either includes or excludes every candidate uniformly.

`#`, type matcher (pattern-cell form)

In pattern cell bodies (used by invariants and salience rules), #typename matches any cell whose type is typename.

In the expression grammar, the equivalent spelling is type=typename. They mean the same thing in different contexts.

Pattern cell body form:

#transaction

Expression form:

study: type=transaction

`+`, with-slot (pattern-cell form)

In pattern cell bodies, +slotname: value asserts that the candidate has a slot of that name with that value.

In the expression grammar, the equivalent spelling is slot: name = value.

Pattern cell body form:

+status=paid

Expression form:

where: slot: status = paid

Why seven and not six

The first six sigils (#, +, @, :, =, &) were locked together as a closed navigation algebra. The seventh, ?, was added later when an invariant about cell relationships could not be expressed in the original six. That extension followed the discipline: a real invariant we tried to write could not be expressed, so the language grew by one capability.

The same discipline applies going forward. There will not be an eighth sigil unless an expressible-only-by-sigil capability is required.

We use cookies to analyze site traffic and improve your experience. By accepting, you consent to the use of cookies for analytics and advertising purposes.