μ

grammar reference

Grammar

μ is parsed right-to-left. A program is a sequence of expressions separated by newlines or semicolons. The last expression in a sequence is the result.

program    ::= sequence EOF
sequence   ::= expr (';' expr)*
expr       ::= name ':' expr          -- assignment
             | verb_expr
verb_expr  ::= composition verb adverb? verb_expr   -- dyadic
             | verb adverb? verb_expr              -- monadic / adverb
             | composition
composition ::= strand ('.' strand)*               -- function composition
strand     ::= atom+                               -- juxtaposition / apply
atom       ::= '(' sequence ')'
             | '[' sequence (';' sequence)* ']'    -- vector literal
             | '{' arg_list? sequence '}'  adverb?   -- lambda
             | name
             | integer
             | float
             | char_literal
             | string_literal
             | symbol
arg_list   ::= '[' name (';' name)* ']'
vector     ::= '[' sequence (';' sequence)* ']'   -- bracket vector (expr1;expr2;...)
adverb     ::= '/' | '\'              -- fold / scan (after a verb)
             | '/:'                   -- each-right (after a verb or function)
             | '\:'                   -- each-left  (after a verb or function)
             | "'"                    -- each       (postfix on a name or lambda)

Verbs

Verbs are single characters. Their meaning depends on arity (monadic = one argument, dyadic = two).

Adverbs

Adverbs modify a verb or function to produce a new function. The left operand determines the mode at evaluation time.

Disambiguation of f/ left operand at evaluation time (mirrors K):

• integer left (n f/ x) → iterate-n fold
• no left (f/ list) → fold with verb, or map-then-fold with lambda
• function literal with operand ({body}/ x) → converge
• 3-arg step function + bracket vector ({[a;x;i]…}/[(seed); list]) → ternary fold/scan; index i is 0-based

Function Composition

The . operator composes two functions: f . g creates a new function that applies g first, then f to the result: (f . g)(x) = f(g(x)).

Composition has higher precedence than verbs but lower than strands: sqrt . sq 9 parses as sqrt . (sq 9), not (sqrt . sq) 9. To apply the composition: (sqrt . sq) 9 or f: sqrt . sq; f 9. Math keywords bind to one atom: sqrt sq 9 is sqrt(sq 9) = sqrt 81 = 9.

I/O keywords

File and data keywords for reading, writing, and parsing structured data. In the CLI, read and write operate on local file paths. In the WASM playground, csv works via the JavaScript fetch bridge (MuWASM.loadCSV).

The table format (headers; columns) is a 2-element list: element 0 is a list of symbols (column names), element 1 is a list of column vectors. Index with t@0 for headers and (t@1)@i for column i.

Conditional semantics (cond)

Inside a lambda body, a semicolon-separated sequence acts as a K-style conditional chain, not a plain sequence:

{e0; e1; e2; e3}   -- if e0 truthy → return e1; else if e2 truthy → return e3; ...

Each even-indexed expression is a condition; if truthy its successor is evaluated and returned, stopping evaluation. A tail with no matching condition returns nil. A single expression {e0} is returned directly (no cond logic).

cfib:{x=0; 1; x=1; 1; (cfib x-1)+(cfib x-2)}
cfib 10   -- → 89

-- Truthiness: non-zero values are truthy.
-- Dyadic < and > return the min/max value, not a boolean:
--   0>x  is truthy when x>0 (returns x), falsy when x=0 (returns 0)
-- Boolean greater-than idiom: 0>a-b  (truthy when a>b, falsy otherwise)

Lambda forms

List Comprehensions

List comprehensions provide a concise way to create lists from existing lists, with optional filtering. They desugar to nested each' expressions.

[expr | var <- list; guard]

| introduces the generator. Multiple generators nest left-to-right. An optional guard (after ;) filters elements — only elements for which the guard is truthy are included in the result.

Desugaring: [x*x | x <- 1 2 3] compiles to {[x] x*x}' 1 2 3. Guards compile to filter-each expressions. This ensures efficient execution via μ's bump allocator with automatic scratch-reset for memory efficiency.

Plot & visualisation keywords

In the CLI, plot verbs save SVG files to the current directory (filename derived from the chart title, or a timestamp if untitled) and print the saved path. In the WASM playground, they render to an inline canvas.

The hist keyword computes bin counts without plotting:

hist[n; vals]       -- divide vals into n equal-width buckets; returns count list
hist[4; 0.0 0.5 1.0 1.5]  -- → 1 1 1 1

Layered chart composition

The chart verb composes multiple layer descriptors into a single chart with shared axes, auto-ranging, and palette colors. Layer constructors return tagged lists that chart interprets at render time.

Named math keywords

Math keywords are first-class functions — they live in the environment like any other name. They work element-wise over lists and can be used with adverbs, assigned to variables, or passed as arguments.

Math keywords bind to a single adjacent atom — the same as a monadic verb. sqrt x * y evaluates as (sqrt x) * y. When the argument is a compound expression, use parentheses: sqrt(a*a + b*b). neg is a verb alias for monadic - with identical atom-binding: neg x * y = (-x) * y.

Because math keywords are first-class, they work directly with adverbs and assignment:

sin' 1 2 3            -- → 0.8414… 0.9092… 0.1411…  (each)
f:sin; f' 1 2 3       -- assign and use via each
sin(1 2 3)            -- parenthesised list: same result

Reference cells

Reference cells provide mutable state — a container that holds a value which can be read and updated. They enable imperative patterns like counters, accumulators, and shared mutable state.

References print as ref[value] showing their current contents. They are first-class values and can be stored in lists, passed to functions, etc.

counter:{[n]
  r:(ref 0);
  {mutate[r; {x+1}]}' !n;   -- increment n times
  get r                     -- return final count
}
counter 5  -- → 5

Control flow

while is the only looping construct. It evaluates a condition expression repeatedly, running the body statements as long as the condition is truthy. It returns the value of the last body statement evaluated, or nothing if the body never executes.

while[condition; stmt1; stmt2; ...]

while modifies its local bindings in place. Variables updated in the body (e.g. cnt above) are visible to subsequent iterations and after the loop. For purely functional iteration prefer n f/ seed (iterate-fold).

Global variables

A dot-prefix on a name (.name) reads from or writes to a shared global namespace that persists across all closures and is never captured by a snapshot. This mirrors K-style globals and is useful for mutable shared state that must be visible inside deeply nested lambdas.

.x: 42             -- write global x
.x                 -- read global x → 42
.x: .x + 1        -- update global x → 43

The key distinction from local assignment is capture semantics:

• Local (x:val) — the optimizer snapshots the value into closures at definition time; mutations after definition are not seen by already-defined lambdas.
• Global (.x:val) — always read live; every call to a closure that reads .x sees the current global value.

.base:100
snap:{.base+x}     -- closes over nothing; reads .base live
.base:999
snap 1             -- → 1000  (sees updated .base)

Global assignment inside a lambda writes back to the global namespace, not a local copy:

inc_global:{.counter:.counter+1}
.counter:0
inc_global[]; inc_global[]; .counter   -- → 2

Literals

Assignment & sequencing

  x: 42              -- assign 42 to x
  f: {x+1}           -- assign lambda to f
  sum:+/             -- verb alias: sum is +/ fold
  a:1; b:2; a+b      -- semicolon sequences expressions; result is last

REPL commands

Example: Black-Scholes Monte Carlo

Box-Muller transform and Monte Carlo pricing of a European call option. Demonstrates random number generation, antithetic variates, and vectorised arithmetic. Uses explicit named-arg lambdas to avoid the implicit-x/y/z wrapping rule; avoids naming intermediate variables x, y, or z (single-char implicit arg names) at the top level.

\S 7

// Box-Muller: produce n standard normal variates
bm:{[n] sqrt(-2*log(1.0-?n)) * cos(2*acos(-1)*?n)}

// European call: s0=spot, k=strike, r=rate, sig=vol, t=maturity, n=paths
mcCall:{[s0;k;r;sig;t;n] half:_(n%2);zz:bm half;zz:zz,-zz;drift:(r-0.5*sig*sig)*t;st:s0*(exp(drift))*(exp(sig*sqrt(t)*zz));exp(-r*t)*mean(0|st-k)}

mcCall 100 100 0.05 0.2 1.0 100000
// → ~10.45  (closed-form Black-Scholes: 10.4506)

Notes on μ syntax:

• ?n generates n uniform floats (monadic ?); \S 7 seeds the RNG.
• Math keywords bind to a single atom: sqrt(-2*log …) — the -2*log… is the atom inside (). Without parens, sqrt -2.0 would try to take the sqrt of the literal -2.0.
• acos(-1)*x now correctly evaluates as (acos(-1))*x = π·x. Keywords bind to one atom, not the full right expression.
• zz:zz,-zz appends the negated antithetic variates using monadic -; amend-join (zz,:…) is not supported.
• mean (from stdlib/stats.mu) computes the arithmetic mean; avg is an alias defined in the same file.
• 0|st-k clips the payoff at zero using dyadic | (element-wise max).

Example: Asian Option Monte Carlo

Arithmetic-average Asian call option priced by path simulation. Uses iter to accumulate payoffs one path at a time (avoids pool exhaustion for large n), and sums (cumulative-sum scan, from stdlib/stdlib.mu) to build the price path from log-returns.

\S 7

// Box-Muller: produce n standard normal variates
bm:{[n] sqrt(-2*log(1.0-?n)) * cos(2*acos(-1)*?n)}

// Asian call: s0=spot, k=strike, r=rate, sig=vol, t=maturity, m=steps, n=paths
// Arithmetic average of m in-period prices forms the payoff.
mcAsian:{[s0;k;r;sig;t;m;n] exp(-r*t)*((n {[acc] acc+(0|(mean(s0*exp(sums ((r-0.5*sig*sig)*(t%m))+(sig*sqrt(t%m))*bm m)))-k)}/ 0.0)%n)}

mcAsian 100 100 0.05 0.2 1.0 12 10000
// → ~6.13  (arithmetic-average Asian call; less than European ~10.45 because averaging dampens volatility)

Notes on mcAsian:

• sums (alias for +\ scan) builds cumulative log-returns; exp then converts to price levels. Use sums rather than +\varname — the backslash is intercepted by the REPL tokenizer when immediately followed by an identifier.
• n f/ seed applies f exactly n times to seed, returning the final accumulated value. Each call generates one independent path; intermediate pool allocations are reused across iterations.
• The anonymous inner lambda {[acc] acc+…} closes over s0, k, sig, r, t, m, and bm from the outer scope.
• Increasing m (monitoring steps) improves accuracy but increases pool usage; keep n·m ≲ 120 000 to stay within the 4 M value-pool limit.