Syntax Cheat Sheet

A dense single-page reference covering all syntax forms, operators, common patterns, and key prelude functions.

Primitives

Blocks

# Property declaration
name: expression

# Function declaration
f(x, y): expression

# Operator declaration (binary)
(l ++ r): expression

# Operator declaration (prefix / postfix)
(! x): expression
(x ******): expression

# Block literal
{ a: 1 b: 2 c: 3 }

# Commas are optional
{ a: 1, b: 2, c: 3 }

# Nested blocks
{ outer: { inner: "value" } }

Top-level unit: the file itself is an implicit block (no braces needed).

Lists

# List literal
[1, 2, 3]

# Empty list
[]

# Mixed types
[1, "two", :three, true]

String Interpolation

# Insert expressions with {braces}
"Hello, {name}!"

# String anaphora (defines a function)
"#{}"           # one-parameter function
"{0} and {1}"   # two-parameter function

Comments

# Line comment (to end of line)
x: 42 # inline comment

Declarations

Idiot Brackets

Idiot brackets allow custom Unicode bracket pairs to wrap and transform expressions — a general bracket overloading mechanism.

# Declare a bracket pair function
⟦ x ⟧: my-functor(x)

# Use the bracket pair in expressions
result: ⟦ some-expression ⟧  # calls my-functor(some-expression)

Built-in bracket pairs: ⟦⟧, ⟨⟩, ⟪⟫, ⌈⌉, ⌊⌋, ⦃⦄, ⦇⦈, ⦉⦊, «», 【】, 〔〕, 〖〗, 〘〙, 〚〛.

Monadic Blocks

Monadic sequencing (like do-notation) is supported via bracket pairs or block metadata. A bracket block or annotated block followed by .expr desugars to a bind chain.

# Bracket pair definition — explicit functions
⟦{}⟧: { :monad bind: my-bind  return: my-return }

# Bracket pair definition — namespace reference
⟦{}⟧: { :monad namespace: my-monad }

# Block metadata forms (all followed by .return_expr):
{ :name decls }.expr                          # Form 1: bare symbol namespace
{ { monad: name } decls }.expr               # Form 2: monad key
{ { :monad namespace: name } decls }.expr    # Form 3: tagged namespace
{ { :monad bind: f return: r } decls }.expr  # Form 4: explicit inline

# ⟦ a: ma  b: mb ⟧.return_expr
# desugars to: bind(ma, (a): bind(mb, (b): return(return_expr)))
result: ⟦ a: ma  b: mb ⟧.(a + b)

All declarations are bind steps whose names are in scope for later declarations and the return expression. The return expression follows the closing bracket (or block) as .name, .(expr), or .[list].

Metadata Annotations

# Declaration metadata (backtick prefix)
` "Documentation string"
name: value

# Structured metadata
` { doc: "description" associates: :left precedence: 50 }
(l op r): expr

# Unit-level metadata (first expression in file)
{ :doc "Unit description" }
a: 1

Special metadata keys: :target, :suppress, :main, associates, precedence, import.

Function Application

# Parenthesised application (no whitespace before paren)
f(x, y)

# Catenation (pipeline style, single argument)
x f              # equivalent to f(x)
x f g h          # equivalent to h(g(f(x)))

# Partial application (curried)
add(1)           # returns a function adding 1

# Sections (operator with gaps)
(+ 1)            # function: add 1
(* 2)            # function: multiply by 2
(/)              # function: floor divide (two params)
(÷)              # function: precise divide (two params)

Lookup and Generalised Lookup

# Simple lookup
block.key

# Generalised lookup (evaluate RHS in block's scope)
{ a: 3 b: 4 }.(a + b)        # 7
{ a: 3 b: 4 }.[a, b]         # [3, 4]
{ a: 3 b: 4 }."{a} and {b}"  # "3 and 4"

Anaphora (Implicit Parameters)

# Expression anaphora
map(_0 * _0)        # square each element
map(_ + 1)          # increment (each _ is a new param)

# Block anaphora (bullet = Option-8 on Mac)
{ x: •0 y: •1 }    # two-parameter block function

# String anaphora
map("item: {}")     # format each element

Operator Precedence Table

From highest to lowest binding:

User-defined operators default to left-associative, precedence 50. Set custom values via metadata: ` { precedence: 75 associates: :right }

Named precedence levels for use in metadata: lookup, call, bool-unary, exp, prod, sum, shift, bitwise, cmp, append, map, eq, bool-prod, bool-sum, cat, apply, meta.

Block Merge

# Catenation of blocks performs a shallow merge
{ a: 1 } { b: 2 }       # { a: 1 b: 2 }
{ a: 1 } { a: 2 }       # { a: 2 }

# Deep merge operator
{ a: { x: 1 } } << { a: { y: 2 } }  # { a: { x: 1 y: 2 } }

Imports

# Unit-level import
{ import: "lib.eu" }

# Named import
{ import: "cfg=config.eu" }

# Multiple imports
{ import: ["dep-a.eu", "dep-b.eu"] }

# Format override
{ import: "yaml@data.txt" }

# Git import
{ import: { git: "https://..." commit: "sha..." import: "file.eu" } }

Key Prelude Functions

Lists

Blocks

Strings (str namespace)

Serialisation and Parsing

Formats for render-as: :yaml, :json, :toml, :text, :edn, :html. Formats for parse-as: :json, :yaml, :toml, :csv, :xml, :edn, :jsonl.

parse-as is safe for untrusted input — YAML !eu tags are never evaluated.

Combinators

Numbers

Arrays (arr namespace)

The standard +, -, *, / operators are polymorphic and apply element-wise when either operand is an array. Scalar broadcasting is supported.

IO

Assertion Operators

Command Line Quick Reference

eu file.eu                  # Evaluate file, output YAML
eu -j file.eu               # Output JSON
eu -x text file.eu          # Output plain text
eu -e 'expression'          # Evaluate expression
eu a.yaml b.eu              # Merge inputs
eu -t target file.eu        # Render specific target
eu list-targets file.eu     # List targets
eu --seed 42 file.eu        # Deterministic random
eu -Q file.eu               # Suppress prelude
eu fmt file.eu              # Format source
eu dump stg file.eu         # Dump STG syntax
eu -- arg1 arg2             # Pass arguments (io.args)