Variables and bindings

Three binding forms: immutable let, mutable var, and constant const. All support type annotations and destructuring.

let, var, const

scratch.xs

let x = 42          -- immutable: cannot reassign
var y = "hello"     -- mutable: can reassign with =
const MAX = 100     -- same as let at runtime, signals intent

y = "world"         -- ok
println(x)
println(y)
println(MAX)

Reassigning a let binding is a runtime error. const is identical to let at runtime; the distinction is for the reader.

scratch.xs

var count = 0
count += 1
count += 1
println(count)       -- 2

Compound assignment (+=, -=, *=, etc.) requires var.

Type annotations

Annotations are optional. Add them where you want the type checker to enforce correctness.

scratch.xs

let count: int = 42
var name: str = "XS"
const PI: f64 = 3.14159

println(count)
println(name)
println(PI)

Without annotations, code runs fine and the checker stays silent. With annotations, the checker catches mismatches before execution:

let x: int = "oops"
-- error[T0001]: type mismatch: expected 'int', got 'str'

Destructuring

Unpack arrays, tuples, and structs in a single binding:

scratch.xs

-- array destructuring (exact length match required)
let [a, b, c] = [1, 2, 3]
println(a)           -- 1

-- tuple destructuring
let (x, y) = (10, 20)
println(x)           -- 10

-- nested tuple
let (p, (q, r)) = (1, (2, 3))
println(r)           -- 3

scratch.xs

-- struct destructuring
struct Point { x, y }
let p = Point { x: 100, y: 200 }
let Point { x: px, y: py } = p
println(px)          -- 100
println(py)          -- 200

Deleting variables

del removes a name from the current scope. Accessing it afterward throws a runtime error.

scratch.xs

var x = 42
println(x)           -- 42
del x

try {
  println(x)
} catch e {
  println("x is gone")
}

Edit this page on GitHub ->