Declarations

A declaration introduces a symbol into the current scope. Epsil has two declaration keywords:

• let declares a mutable symbol.
• const declares an immutable symbol.

let x = 5
const c = 6.28

A type annotation also implies a declaration, even without a keyword:

x: real = 5

is a declaration of x with type real, exactly as if it had been written let x: real = 5. The keyword is only mandatory for an untyped declaration — that's what distinguishes a declaration from a plain reassignment (see below).

Destructuring declarations

A let or const may bind the components of a tuple in one statement:

divmod(a, b) = (Floor(a / b), a % b)
let (q, r) = divmod(17, 5)
(q, r)
// ➔ (3, 2)

The pattern is a parenthesized list of at least two elements, each a bare symbol, a _ (which skips that position), or a nested tuple pattern:

let ((a, b), _, c) = ((1, 2), 99, 5)
a + b + c
// ➔ 8

The pattern is irrefutable in form — no literals, pins, or guards (use match for conditional destructuring). The value is evaluated once; it must be a tuple of the same shape, otherwise the declaration yields an incompatible-type error value and binds nothing. With const, every bound name is a constant. An initializer is required, and a type annotation is not accepted on a pattern. Duplicate names anywhere in one pattern are a diagnostic.

Destructuring assignment

The same pattern may appear on the left of an assignment, to write bindings that already exist instead of declaring new ones:

let a = 1
let b = 2
(a, b) := (b, a)
(a, b)
// ➔ (2, 1)

The right side is evaluated once, in full, before any target is written, so a swap means what it reads — (a, b) := (b, a) exchanges the two values rather than assigning b to both. The same holds for a rotation ((a, b, c) := (c, a, b)) and for the pair-carrying loop step that is the usual reason to want this:

let a = 0
let b = 1
for k in 1..10 {
  (a, b) := (b, a + b)
}
a
// ➔ 55

The pattern grammar is exactly the one above — at least two elements, each a bare symbol, a _ skipping that position, or a nested tuple pattern — and a shape mismatch is the same incompatible-type error value, which writes nothing: the whole pattern is matched before any target is written, so a mismatch nested under a position that would have bound leaves that one alone too.

The differences from a destructuring let are the ones assignment always has: the targets keep their identity and their declared type (a value that does not fit a target's type is an error value), and assigning to a const fails. Those two failures are found only by attempting the write, so unlike a shape mismatch they are not atomic — targets earlier in the pattern have already been written and stay written.

The assignment operator must be spelled :=. A statement-leading (a, b) = … is a comparison, not an assignment — a parenthesized left side is not a binding target, so the bare = reads as Equal. Because that is almost always a typo for the destructuring assignment, it is diagnosed.

Declaring a type

A third declaration keyword, type, introduces a type name rather than a symbol — and, with it, a constructor of the same name:

type point = tuple<x: number, y: number>
type alias pair = tuple<number, number>
let p = point(1, 2)
let a: pair = (1, 2)

type declares a new, distinct type; type alias declares another name for an existing one, and takes a type-parameter clause if it needs one (type alias Pair<T> = tuple<T, T>). Unlike let and const, type is not a reserved word — only these statement shapes claim it. See Declaring a type for the whole story.

Reassignment vs. declaration

A bare x = 5 — no let/const keyword, no type annotation — is not declaration syntax: it is an assignment:

x = 5

Assigning to a name that was never declared does establish it, but let is the explicit and idiomatic way to introduce a mutable binding.

Reassigning a symbol that was declared const produces an error value, not a parse error or a thrown exception:

const c = 1
c = 2

c = 2 still parses as a perfectly ordinary assignment; the failure happens at evaluation time, and its result is an error value.

A declaration with no initializer declares the name without giving it a value:

let x: real
let y

Without an annotation, the type is inferred from the initializer — let x = 5 declares x as an integer.

Constness is a property of the binding, not of the type, and it is enforced by the runtime rather than by a separate Epsil-side check. See Declarations for the underlying representation.

Scoping

Declarations live in the current scope. A program (a notebook cell or a chain of cells sharing one engine scope) declares at the top level; a block introduced by if/else/while/for, or a function body, pushes its own lexical scope, so a let/const inside a block does not leak into the enclosing scope.

let and const are the binding keywords. There is currently no compound assignment (+=); destructuring declarations (let (x, y) = t) and destructuring assignments ((x, y) := t) are described above.