; Standard lisp style syntax, but each line is assumed to be wrapped in parens
print "Hello World"

; Loop 10 times with i changing from 0 to 9
; Indent means to continue parent list, but each line is own sub-list
for [i 10]
  print i

; Loop over a list of names
for [name names]
  print name

; Nested loops using | syntax
; | means to assume everything afterwards is indented
for [y 10] | for [x 10]
  print x y

; Lines starting with @ are not wrapped as lists
let fib | λ [n]
  if (n ≤ 2) 1
    @ ([fib (n - 1)] + [fib (n - 2)])

; Object syntax
obj
  @ name "Tim"
  @ age 33

; Object set, get
get person "name"
@ person.name
set person "name" "Tim"

; Sample program: maze generator
; Sample output for 3x3 maze

; ██████████████
; ██      ██  ██
; ██  ██████  ██
; ██          ██
; ██  ██  ██████
; ██  ██      ██
; ██████████████

let width 30
let height 30
let size (width × height)

; Cells letine the maze
let cells | map [i size] | table
  ; parent is initially null
  @ parent nil
  ; right and down walls are initially filled
  @ right true
  @ down true

; Define the sequence of index and right/left
let ww (width - 1)
let hh (height - 1)

; Create a list of actions to perform in shuffled order
let sequence | shuffle | concat
  map [i size] | if ((i % width) < ww) | table
    @ cell (cells get i)
    @ direction "right"
  map [i size] | if ((i ÷ width) < hh) | table
    @ cell (cells get i)
    @ direction "down"

; Find the root of a set cell -> cell
let find-root | λ [cell] | if cell.parent
  find-root cell.parent
  @ cell

for [item sequence]
  let direction item.direction
  let root | find-root (cells . i)
  let horizontal | ? (item . 0)

  let other | find-root (cells . (i + [? (item . 0) 1 width)))
  (if (≠ (. root 0) (. other 0))
    (. root 1 other)
    (. (. walls i) (? (. item 0) 0 1) false)
  )
)

let w (width × 2)
let h (height × 2)
join "\n" | map [y (h + 1)]
  join "" | map [x (w + 1)]
    ¿ "  " "██" | or
      ; Four outer edges are always true
      = x 0
      = y 0
      = x w
      = y h
      ; Inner cells are more complicated
      ? (y % 2)
        ? (x % 2)
           ; cell middle
          false
          ; cell right
          (. (. walls (+ (÷ (- x 1) 2) (× (÷ y 2) width))) 0)
        )
        (? (% x 2)
          ; cell down
          (. (. walls (+ (÷ x 2) (× (÷ (- y 1) 2) width))) 1)
          ; cell corner
          true
        )
      )
    ))
  ))
))