The HQL Programming Language

;; This is an HQL comment using Lisp-style semicolons
(fn add [a b]
  (+ a b))

// Compiled JavaScript
function add(a, b) {
  return a + b;
}

(print "Hello, World!")

$ hlvm run hello.hql
Hello, World!

$ hlvm run -e '(print "Hello, World!")'
Hello, World!

;; fahrenheit.hql -- print Fahrenheit-Celsius table
(for [fahr 0 300 20]
  (let celsius (* (- fahr 32) (/ 5.0 9.0)))
  (print fahr "\t" celsius))

$ hlvm repl

hlvm> (+ 1 2 3)
6

hlvm> (* 7 8)
56

hlvm> (print "Hello from the REPL!")
Hello from the REPL!

hlvm> (fn square [x] (* x x))

hlvm> (square 9)
81

hlvm> (map square [1 2 3 4 5])
(1 4 9 16 25)

$ hlvm run program.hql

$ hlvm compile program.hql

$ hlvm compile program.hql --release

$ hlvm run -e '(+ 40 2)'
42

(fn greet [name]
  (str "Hello, " name "!"))

(print (greet "World"))     ;; Hello, World!
(print (greet "Alice"))     ;; Hello, Alice!

(fn add [a b]
  (+ a b))

(print (add 3 4))    ;; 7

(map (fn [x] (* x x)) [1 2 3 4 5])
;; => (1 4 9 16 25)

(map (=> (* $0 $0)) [1 2 3 4 5])
;; => (1 4 9 16 25)

[1 2 3 4 5]
["apple" "banana" "cherry"]
[true false nil]

[1, 2, 3]    ;; same as [1 2 3]

{name: "Alice" age: 30 city: "Seoul"}

{"name": "Alice", "age": 30, "city": "Seoul"}

#[1 2 3 4 5]         ;; set of numbers
#["red" "green" "blue"]  ;; set of strings

// Single-line comment (JavaScript style)

/* Multi-line comment
   spanning several lines */

;; Lisp-style comment (idiomatic in HQL)

(+ 1 2)    ;; this adds one and two
(+ 1 2)    // this also adds one and two

my-function         ;; kebab-case (preferred for functions/variables)
my-long-variable    ;; readable with hyphens
empty?              ;; predicate (returns boolean)
set!                ;; mutating operation
*dynamic-var*       ;; earmuff convention for dynamic variables

MyClass
BankAccount
HttpResponse

_internal-helper
_private-state

fn let var const def if cond when unless do
loop recur for for-of for-await-of while repeat
class new async await return throw try catch finally
import export macro match switch case default
=> & _ nil true false this
label break continue yield yield*
fn* async-fn* getter setter static
type deftype interface abstract-class namespace
const-enum declare fn-overload

42              ;; integer
3.14159         ;; floating point
-17             ;; negative
1e10            ;; scientific notation
0xFF            ;; hexadecimal
0o77            ;; octal
0b1010          ;; binary
123n            ;; BigInt (arbitrary precision)

"hello"             ;; double-quoted string
"line1\nline2"      ;; escape sequences work
"tab\there"         ;; tab character
"quote: \""         ;; escaped double quote

`Hello, ${name}!`
`The sum is ${(+ a b)}.`
`Multi-line
template literal`

true
false

nil       ;; equivalent to JavaScript's null

(let name "World")
(let greeting `Hello, ${name}!`)
(print greeting)    ;; Hello, World!

;; Expressions inside template literals
(let x 10)
(let y 20)
(print `${x} + ${y} = ${(+ x y)}`)    ;; 10 + 20 = 30

(+ 1 2)        ;; => 3        addition
(- 10 3)       ;; => 7        subtraction
(* 4 5)        ;; => 20       multiplication
(/ 15 3)       ;; => 5        division
(% 17 5)       ;; => 2        modulo (remainder)
(** 2 10)      ;; => 1024     exponentiation

(+ 1 2 3 4)    ;; => 10       chains left-to-right: ((1+2)+3)+4
(* 2 3 4)      ;; => 24       ((2*3)*4)
(- 10 3 2)     ;; => 5        ((10-3)-2)

(+)     ;; => 0
(*)     ;; => 1

(+ 5)   ;; => 5     (unary plus)
(- 5)   ;; => -5    (negation)

(apply + [1 2 3 4 5])    ;; => 15

(=== 1 1)       ;; => true    strict equality (preferred)
(!== 1 2)       ;; => true    strict inequality
(< 3 5)         ;; => true    less than
(> 10 5)        ;; => true    greater than
(<= 5 5)        ;; => true    less than or equal
(>= 10 3)       ;; => true    greater than or equal

(== 1 "1")      ;; => true    loose equality (type coercion)
(!= 1 "2")      ;; => true    loose inequality

(= x 10)        ;; assignment: x = 10
(=== x 10)      ;; comparison: x === 10

(and true true)     ;; => true
(and true false)    ;; => false
(or false true)     ;; => true
(or false false)    ;; => false
(not true)          ;; => false
(not false)         ;; => true

(&& true false)     ;; => false
(|| false true)     ;; => true
(! true)            ;; => false

(and "hello" 42)        ;; => 42 (both truthy, returns last)
(and nil "hello")       ;; => nil (first is falsy, returns it)
(or nil "default")      ;; => "default" (first is falsy, tries second)
(or "found" "default")  ;; => "found" (first is truthy, returns it)

(& 0xFF 0x0F)    ;; => 15     bitwise AND
(| 0xF0 0x0F)    ;; => 255    bitwise OR
(^ 0xFF 0x0F)    ;; => 240    bitwise XOR
(~ 0)            ;; => -1     bitwise NOT
(<< 1 8)         ;; => 256    left shift
(>> -256 4)      ;; => -16    signed right shift
(>>> -1 24)      ;; => 255    unsigned right shift

(let x 10)
(= x 20)        ;; x is now 20

;; Compound assignment operators
(+= x 5)        ;; x = x + 5
(-= x 3)        ;; x = x - 3
(*= x 2)        ;; x = x * 2
(/= x 4)        ;; x = x / 4
(%= x 3)        ;; x = x % 3
(**= x 2)       ;; x = x ** 2

(??= x 10)      ;; x = 10 only if x is null/undefined
(||= name "default")  ;; name = "default" only if name is falsy
(&&= x (getValue))    ;; x = getValue() only if x is truthy

(?? name "Anonymous")        ;; name if not null/undefined, else "Anonymous"
(?? config.timeout 5000)     ;; config.timeout if set, else 5000

user?.name              ;; undefined if user is null, otherwise user.name
user?.address?.city     ;; safe nested access
(.?getName user)        ;; optional method call: user?.getName()

(typeof x)              ;; => "number", "string", "object", etc.
(instanceof obj Date)   ;; => true if obj is a Date
(in "name" obj)         ;; => true if obj has property "name"
(delete obj.temp)       ;; removes property from object
(void expr)             ;; evaluates expr, returns undefined

;; In JavaScript: 2 + 3 * 4 = 14 (multiplication first)
;; In HQL, you must be explicit:
(+ 2 (* 3 4))     ;; => 14
(* (+ 2 3) 4)     ;; => 20

(reduce + 0 [1 2 3 4 5])     ;; => 15
(reduce * 1 [1 2 3 4 5])     ;; => 120
(map (=> (+ $0 1)) [1 2 3])  ;; => (2 3 4)

(let x 10)
(print x)       ;; 10
(= x 20)          ;; reassignment is allowed
(print x)       ;; 20

;; Parenthesized binding pairs
(let (x 10 y 20)
  (+ x y))        ;; => 30

;; Clojure-style vector bindings
(let [x 10 y 20]
  (+ x y))        ;; => 30

(let x 10)    ;; compiles to: let x = 10;

(const PI 3.14159)
(def TAU (* 2 PI))

;; (= PI 3.0)    ;; ERROR: cannot reassign const

(const config {host: "localhost" port: 8080})
;; config.host = "other"    ;; ERROR: cannot mutate frozen object

(const numbers [1 2 3])
;; (numbers.push 4)         ;; ERROR: cannot mutate frozen array

(var count 0)
(= count (+ count 1))
(print count)     ;; 1

(var (x 10 y 20)
  (= x 100)
  (+ x y))          ;; => 120

(let [a b c] [1 2 3])
(print a)    ;; 1
(print b)    ;; 2
(print c)    ;; 3

(let [first & rest] [1 2 3 4 5])
(print first)    ;; 1
(print rest)     ;; [2 3 4 5]

(let [a _ c] [1 2 3])
(print a)    ;; 1
(print c)    ;; 3

(let person {name: "Alice" age: 30})
(let {name age} person)
(print name)    ;; Alice
(print age)     ;; 30

(let [x (= 10)] [])      ;; x defaults to 10 (array is empty)
(let [a (= 1) b (= 2)] [42])  ;; a = 42, b = 2 (default)

(let [[a [b c]]] [[1 [2 3]]])
(print a)    ;; 1
(print b)    ;; 2
(print c)    ;; 3

(let x "outer")

(do
  (let x "inner")
  (print x))       ;; "inner"

(print x)           ;; "outer"

(fn make-counter []
  (var count 0)
  (fn []
    (= count (+ count 1))
    count))

(let counter (make-counter))
(counter)    ;; => 1
(counter)    ;; => 2
(counter)    ;; => 3

(let (x 10 y 20) (+ x y))

;; Compiles to:
;; (() => { let x = 10; let y = 20; return x + y; })()

(if condition
  then-expr
  else-expr)

(if (> x 0)
  "positive"
  "non-positive")

;; Use the result directly
(let label (if (> score 50) "pass" "fail"))
(print label)

// Compiled JavaScript
const label = score > 50 ? "pass" : "fail";

(if (> x 0)
  (print "positive"))     ;; nothing happens if x <= 0

(? (> age 18) "adult" "minor")

(cond
  ((< x 0) "negative")
  ((=== x 0) "zero")
  ((> x 0) "positive")
  (else "unknown"))

(fn classify-temperature [temp]
  (cond
    ((< temp 0) "freezing")
    ((< temp 10) "cold")
    ((< temp 20) "cool")
    ((< temp 30) "warm")
    (else "hot")))

(classify-temperature 25)    ;; => "warm"

(when (> x 0)
  (print "x is positive")
  (process x))

(unless (=== denominator 0)
  (/ numerator denominator))

(when-let [result (findUser id)]
  (print "Found user:" result.name)
  (processUser result))

(let result (findUser id))
(when result
  (print "Found user:" result.name)
  (processUser result))

(if-let [user (findUser id)]
  (greet user)
  (print "User not found"))

(when-not (isEmpty collection)
  (process collection))

(if-not (isEmpty items)
  (first items)
  "no items")

(switch status
  (case "active" (run))
  (case "waiting" (wait))
  (case "stopped" (cleanup))
  (default (error "Unknown status")))

(switch grade
  (case "A" :fallthrough)
  (case "B" (print "Good"))
  (default (print "Other")))

(case day
  "Monday" "Start of week"
  "Friday" "Almost weekend"
  "Default day")                ;; last value without a test is default

(do
  (print "step 1")
  (print "step 2")
  (+ 1 2))               ;; => 3

(if (> x 0)
  (do
    (print "positive")
    (process x))
  (do
    (print "non-positive")
    (handleError x)))

(match value
  (case pattern1 result1)
  (case pattern2 result2)
  (default fallback))

(match x
  (case 1 "one")
  (case 2 "two")
  (case 3 "three")
  (default "something else"))

(match response.status
  (case 200 "OK")
  (case 404 "Not Found")
  (case 500 "Server Error")
  (default "Unknown"))

(match x
  (case 0 "zero")
  (case _ "not zero"))

(match x
  (case 0 "zero")
  (case n (str "got: " n)))     ;; n is bound to x's value

(match point
  (case [0, 0] "origin")
  (case [x, 0] (str "on x-axis at " x))
  (case [0, y] (str "on y-axis at " y))
  (case [x, y] (str "at (" x ", " y ")")))

(match items
  (case [] "empty")
  (case [only] (str "just " only))
  (case [first, & rest] (str first " and " (count rest) " more")))

(match user
  (case {name: n, age: a} (str n " is " a " years old"))
  (default "Unknown user"))

(match status-code
  (case (| 200 201 204) "success")
  (case (| 400 401 403 422) "client error")
  (case (| 500 502 503) "server error")
  (default "unknown"))

(match n
  (case x (if (> x 0)) "positive")
  (case x (if (< x 0)) "negative")
  (default "zero"))

(match user
  (case {name: n, age: a} (if (>= a 18))
    (str n " is an adult"))
  (case {name: n, age: a}
    (str n " is a minor")))

(fn add [a b]
  (+ a b))

(add 3 4)    ;; => 7

(fn describe [name age]
  (let title (if (>= age 18) "Mr./Ms." "Young"))
  (str title " " name ", age " age))

(describe "Alice" 30)    ;; => "Mr./Ms. Alice, age 30"

(map (fn [x] (* x x)) [1 2 3 4])
;; => (1 4 9 16)

(filter (fn [x] (> x 3)) [1 2 3 4 5])
;; => (4 5)

(reduce (fn [acc x] (+ acc x)) 0 [1 2 3 4 5])
;; => 15

;; Implicit parameters: $0, $1, $2...
(map (=> (* $0 2)) [1 2 3])        ;; => (2 4 6)
(filter (=> (> $0 3)) [1 2 3 4 5]) ;; => (4 5)
(reduce (=> (+ $0 $1)) 0 [1 2 3])  ;; => 6

;; Property access
(map (=> $0.name) users)            ;; extract name from each user

;; Explicit parameters
(map (=> [x] (* x x)) [1 2 3])     ;; => (1 4 9)
((=> [x y] (+ x y)) 5 7)           ;; => 12

(fn greet
  ([] "Hello!")
  ([name] (str "Hello, " name "!"))
  ([first last] (str "Hello, " first " " last "!")))

(greet)                ;; => "Hello!"
(greet "Alice")        ;; => "Hello, Alice!"
(greet "Alice" "Smith") ;; => "Hello, Alice Smith!"

;; Async multi-arity
(async fn fetch-data
  ([url] (await (fetch-data url {})))
  ([url opts] (await (js/fetch url opts))))

;; Generator multi-arity
(fn* range-gen
  ([end] (yield* (range-gen 0 end)))
  ([start end]
    (var i start)
    (while (< i end)
      (yield i)
      (= i (+ i 1)))))

(fn calculate [a b op]
  (cond
    ((=== op "add") (+ a b))
    ((=== op "sub") (- a b))
    ((=== op "mul") (* a b))
    (else (/ a b))))

(fn connect {host: "localhost" port: 8080 ssl: false}
  (let protocol (if ssl "https" "http"))
  (str protocol "://" host ":" port))

(connect)                              ;; => "http://localhost:8080"
(connect {port: 3000})                 ;; => "http://localhost:3000"
(connect {host: "api.com" ssl: true})  ;; => "https://api.com:8080"

(fn sum [& nums]
  (reduce + 0 nums))

(sum 1 2 3 4 5)    ;; => 15

(fn log [level & messages]
  (print level ":" messages))

(log "INFO" "server" "started" "on" "port" 8080)

(fn greet [name = "World"]
  (str "Hello, " name "!"))

(greet)          ;; => "Hello, World!"
(greet "Alice")  ;; => "Hello, Alice!"

(fn repeat-str [s = "x" n = 3]
  (let result "")
  (for [i 0 n]
    (= result (str result s)))
  result)

(repeat-str)           ;; => "xxx"
(repeat-str "ab")      ;; => "ababab"
(repeat-str "hi" 2)    ;; => "hihi"

;; Array destructuring
(fn swap [[a b]]
  [b a])

(swap [1 2])    ;; => [2 1]

;; Object destructuring
(fn greet-user [{name age}]
  (str name " is " age))

(greet-user {name: "Alice" age: 30})    ;; => "Alice is 30"

;; Nested destructuring
(fn process [[a [b c]]]
  (+ a b c))

(process [1 [2 3]])    ;; => 6

;; Parameter types (NO SPACE after colon)
(fn add [a:number b:number] :number
  (+ a b))

;; Union types
(fn handle [value:string|number] :void
  (print value))

;; Generic type parameters
(fn identity<T> [x:T] :T
  x)

;; Return type with arrow syntax
(fn parse [s:string] -> number
  (parseInt s 10))

(defn add [a b]
  (+ a b))

;; identical to:
(fn add [a b]
  (+ a b))

(fx add [a b]
  (+ a b))          ;; OK: pure computation

(fx impure [x]
  (print x)       ;; ERROR: print is impure (I/O side effect)
  x)

(fx map-pure [f:pure items]
  (map f items))

(map-pure (fx [x] (* x 2)) [1 2 3])    ;; OK
(map-pure (fn [x] (print x)) [1 2 3]) ;; ERROR: impure callback

;; Sum numbers from 0 to n
(loop [i 0 sum 0]
  (if (> i 10)
    sum
    (recur (+ i 1) (+ sum i))))
;; => 55

(loop [n 5 acc 1]
  (if (<= n 1)
    acc
    (recur (- n 1) (* acc n))))
;; => 120

let n = 5, acc = 1;
while (true) {
  if (n <= 1) return acc;
  [n, acc] = [n - 1, n * acc];
}

(fn factorial [n acc]
  (if (<= n 1)
    acc
    (factorial (- n 1) (* n acc))))

(fn is-even [n]
  (if (=== n 0) true (is-odd (- n 1))))

(fn is-odd [n]
  (if (=== n 0) false (is-even (- n 1))))

(is-even 10000)    ;; => true (no stack overflow)

(var count 0)
(while (< count 5)
  (print count)
  (= count (+ count 1)))
;; prints 0 1 2 3 4

;; One argument: 0 to n-1
(for [i 3]
  (print i))
;; prints 0, 1, 2

;; Two arguments: start to end-1
(for [i 5 8]
  (print i))
;; prints 5, 6, 7

;; Three arguments: start to end-1 by step
(for [i 0 10 2]
  (print i))
;; prints 0, 2, 4, 6, 8

(for-of [item ["apple" "banana" "cherry"]]
  (print item))

(for-of [char "hello"]
  (print char))

(for-of [n (range 0 5)]
  (print n))

(repeat 5
  (print "hello"))
;; prints "hello" 5 times

(for [i 5]
  (print "iteration" i))

(label outer
  (for [i 0 10]
    (for [j 0 10]
      (when (=== (* i j) 42)
        (print "Found:" i j)
        (break outer)))))

(for [i 0 10]
  (when (=== (% i 2) 0)
    (continue))            ;; skip even numbers
  (when (> i 7)
    (break))               ;; stop at 7
  (print i))
;; prints 1, 3, 5, 7

;; Literal syntax
[1 2 3 4 5]
["hello" "world"]
[true 42 "mixed" nil]

;; Constructor form
(vector 1 2 3)

;; Nested
[[1 2] [3 4] [5 6]]

[1, 2, 3]    ;; same as [1 2 3]

(let v [10 20 30 40 50])

(get v 0)        ;; => 10
(get v 2)        ;; => 30
(get v 10 "x")   ;; => "x" (default when out of bounds)

(first v)        ;; => 10
(rest v)         ;; => (20 30 40 50)  (lazy sequence)
(nth v 3)        ;; => 40
(last v)         ;; => 50
(count v)        ;; => 5

(conj [1 2 3] 4)       ;; => [1 2 3 4]
(concat [1 2] [3 4])   ;; => (1 2 3 4) (lazy sequence)
(vec (range 5))         ;; => [0 1 2 3 4] (realize to vector)

;; Lisp-style (preferred)
{name: "Alice" age: 30 city: "Seoul"}

;; JSON-style
{"name": "Alice", "age": 30, "city": "Seoul"}

;; Constructor form
(hash-map "name" "Alice" "age" 30)

;; Nested
{user: {name: "Alice" address: {city: "Seoul" zip: "06100"}}}

(let person {name: "Alice" age: 30})

(get person "name")       ;; => "Alice"
(get person "missing")    ;; => undefined
(get person "missing" 0)  ;; => 0 (with default)

person.name               ;; => "Alice" (dot notation)
person.age                ;; => 30

;; assoc adds or updates keys
(assoc person "job" "Engineer")
;; => {name: "Alice", age: 30, job: "Engineer"}

;; dissoc removes keys
(dissoc person "age")
;; => {name: "Alice"}

;; Extracting keys and values
(keys person)    ;; => ["name", "age"]
(vals person)    ;; => ["Alice", 30]

(let defaults {host: "localhost" port: 8080 debug: false})
(let overrides {port: 3000 debug: true})
(merge defaults overrides)
;; => {host: "localhost", port: 3000, debug: true}

;; Literal syntax
#[1 2 3 4 5]
#["red" "green" "blue"]

;; Constructor form
(hash-set 1 2 3)

;; Duplicates are automatically removed
#[1 1 2 2 3 3]    ;; => #[1 2 3]

(let colors #["red" "green" "blue"])

;; Membership test
(colors.has "red")       ;; => true
(colors.has "yellow")    ;; => false

;; Set operations via standard library
(let a #[1 2 3 4])
(let b #[3 4 5 6])
;; Use filter/some for intersection-like operations
(filter (=> (b.has $0)) (vec a))    ;; => (3 4)

(vector 1 2 3)              ;; => [1 2 3]
(hash-map "a" 1 "b" 2)      ;; => {a: 1, b: 2}
(hash-set 1 2 3)             ;; => #[1 2 3]

;; get works on vectors, maps, and sets
(get [10 20 30] 1)           ;; => 20
(get {a: 1 b: 2} "a")       ;; => 1
(get #[1 2 3] 2)             ;; => 2

;; first/rest work on any sequence
(first [1 2 3])              ;; => 1
(first {a: 1 b: 2})         ;; => ["a" 1] (first entry)
(rest [1 2 3])               ;; => (2 3)

;; nth for indexed access
(nth [10 20 30] 2)           ;; => 30

;; Array spread
(let a [1 2 3])
(let b [0 ...a 4])          ;; => [0 1 2 3 4]

;; Object spread
(let base {x: 1 y: 2})
(let extended {...base z: 3})  ;; => {x: 1, y: 2, z: 3}

;; Combining arrays
(let combined [...arr1 ...arr2])

;; Override with spread
(let updated {...config port: 9090})

(first [1 2 3])        ;; => 1          the first element
(rest [1 2 3])         ;; => (2 3)      everything except the first
(cons 0 [1 2 3])       ;; => (0 1 2 3)  construct a new sequence

(fn my-map [f coll]
  (lazy-seq
    (when-let [s (seq coll)]
      (cons (f (first s)) (my-map f (rest s))))))

(fn my-filter [pred coll]
  (lazy-seq
    (when-let [s (seq coll)]
      (if (pred (first s))
        (cons (first s) (my-filter pred (rest s)))
        (my-filter pred (rest s))))))

(seq [1 2 3])         ;; => sequence of 1, 2, 3
(seq [])              ;; => nil (empty)
(seq "hello")         ;; => sequence of "h", "e", "l", "l", "o"
(seq {a: 1 b: 2})    ;; => sequence of entries
(seq nil)             ;; => nil

(when-let [s (seq coll)]
  ;; s is the non-empty sequence
  (process (first s))
  (recurse (rest s)))

(lazy-seq
  (cons 1 (lazy-seq
    (cons 2 (lazy-seq
      (cons 3 nil))))))
;; => (1 2 3) -- but each element computed only when needed

;; Without laziness, this would be infinite:
(take 5 (map (=> (* $0 $0)) (range)))
;; => (0 1 4 9 16)

;; Only 5 elements are actually computed

(def expensive-result
  (delay
    (print "Computing...")
    (* 42 42)))

;; Nothing printed yet

(force expensive-result)
;; prints "Computing..."
;; => 1764

(force expensive-result)
;; nothing printed (cached)
;; => 1764

(map inc [1 2 3])              ;; => (2 3 4)
(map (=> (* $0 2)) [1 2 3])    ;; => (2 4 6)
(map str [1 2 3])              ;; => ("1" "2" "3")

(filter even? [1 2 3 4 5 6])     ;; => (2 4 6)
(filter (=> (> $0 3)) [1 2 3 4 5]) ;; => (4 5)

(reduce + 0 [1 2 3 4 5])      ;; => 15
(reduce * 1 [1 2 3 4 5])      ;; => 120
(reduce str "" ["a" "b" "c"]) ;; => "abc"

(reduce
  (fn [acc x] (assoc acc x (* x x)))
  {}
  [1 2 3 4])
;; => {1: 1, 2: 4, 3: 9, 4: 16}

;; take: first n elements
(take 3 [1 2 3 4 5])          ;; => (1 2 3)
(take 3 (range))               ;; => (0 1 2) -- from infinite sequence!

;; drop: skip n elements
(drop 2 [1 2 3 4 5])          ;; => (3 4 5)

;; concat: join sequences
(concat [1 2] [3 4] [5 6])    ;; => (1 2 3 4 5 6)

;; flatten: remove nesting
(flatten [[1 2] [3 [4 5]]])   ;; => (1 2 3 4 5)

(take 5 (drop 100 (range)))
;; => (100 101 102 103 104)
;; Only computes 105 values, not infinity

;; range with no arguments: 0, 1, 2, 3, ...
(take 5 (range))             ;; => (0 1 2 3 4)

;; repeat: infinite repetition
(take 4 (repeat "hello"))    ;; => ("hello" "hello" "hello" "hello")

;; cycle: infinite cycling
(take 7 (cycle [1 2 3]))     ;; => (1 2 3 1 2 3 1)

;; iterate: apply function repeatedly
(take 5 (iterate inc 0))     ;; => (0 1 2 3 4)
(take 8 (iterate (=> (* $0 2)) 1)) ;; => (1 2 4 8 16 32 64 128)

;; Fibonacci sequence
(fn fibs []
  (let [fib (fn [a b]
              (lazy-seq (cons a (fib b (+ a b)))))]
    (fib 0 1)))

(take 10 (fibs))
;; => (0 1 1 2 3 5 8 13 21 34)

;; Powers of two
(take 10 (iterate (=> (* $0 2)) 1))
;; => (1 2 4 8 16 32 64 128 256 512)

;; Without transducers: creates intermediate lazy sequences
(->> [1 2 3 4 5 6 7 8 9 10]
     (map inc)
     (filter even?)
     (take 3))
;; => (2 4 6)

;; With transducers: no intermediate allocations
(transduce
  (comp (map inc) (filter even?) (take 3))
  conj
  []
  [1 2 3 4 5 6 7 8 9 10])
;; => [2 4 6]

;; Transducers are reusable
(def xform (comp (map inc) (filter even?)))

(transduce xform + 0 [1 2 3 4 5])       ;; => 12 (sum of 2, 4, 6)
(transduce xform conj [] [1 2 3 4 5])    ;; => [2 4 6]

;; Find the top 3 most expensive items under $100
(->> inventory
     (filter (=> (< $0.price 100)))
     (sort-by (=> $0.price))
     (reverse)
     (take 3)
     (map (=> $0.name)))

(class Person
  (var name)
  (var age)

  (constructor [name age]
    (do
      (= this.name name)
      (= this.age age)))

  (fn greet []
    (+ "Hello, " this.name)))

class Person {
  name;
  age;
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  greet() {
    return "Hello, " + this.name;
  }
}

(class Config
  (var host "localhost")    ;; mutable field with default
  (var port 8080)           ;; mutable field with default
  (const protocol "https")  ;; immutable field with default

  (constructor [host port]
    (do
      (= this.host host)
      (= this.port port))))

(class Calculator
  (var value 0)

  (fn add [n]
    (= this.value (+ this.value n))
    this)

  (fn subtract [n]
    (= this.value (- this.value n))
    this)

  (fn result []
    this.value))

(let calc (new Calculator))
(calc.add 10)
(calc.subtract 3)
(calc.result)  ;; => 7

(class Counter
  (static var count 0)

  (static fn increment []
    (= Counter.count (+ Counter.count 1)))

  (static fn getCount []
    Counter.count))

(Counter.increment)
(Counter.increment)
(Counter.getCount)  ;; => 2

(class Circle
  (var _radius 0)

  (constructor [r]
    (= this._radius r))

  (getter radius []
    this._radius)

  (setter radius [value]
    (if (< value 0)
      (throw (new Error "Radius must be non-negative"))
      (= this._radius value))))

(let c (new Circle 5))
c.radius          ;; => 5 (calls getter)
(= c.radius 10)   ;; calls setter

(class BankAccount
  (#balance 0)

  (constructor [initial]
    (= this.#balance initial))

  (fn deposit [amount]
    (= this.#balance (+ this.#balance amount)))

  (fn getBalance []
    this.#balance))

(let acct (new BankAccount 100))
(acct.deposit 50)
(acct.getBalance)  ;; => 150
;; acct.#balance   ;; Error: private field

(class Animal
  (constructor [name]
    (= this.name name))

  (fn describe []
    (+ "Animal: " this.name)))

(class Dog extends Animal
  (constructor [name breed]
    (super name)
    (= this.breed breed))

  (fn bark []
    "Woof!"))

(let d (new Dog "Rex" "Shepherd"))
(d.describe)  ;; => "Animal: Rex"
(d.bark)      ;; => "Woof!"

(abstract-class Shape
  (fn area [] 0))  ;; default implementation

(class Rectangle extends Shape
  (constructor [w h]
    (= this.width w)
    (= this.height h))

  (fn area []
    (* this.width this.height)))

(import [map filter reduce] from "@hlvm/stdlib")

(import [readFile as read, writeFile as write] from "node:fs")

(import path from "node:path")
;; Compiles to: import * as path from "node:path";

(import "reflect-metadata")
;; Compiles to: import "reflect-metadata";

(let module (await (import-dynamic "./heavy-module.hql")))
(module.process data)

;; With a variable path
(let path (+ "./plugins/" pluginName))
(let plugin (await (import-dynamic path)))

(export (fn add [a b] (+ a b)))
(export (const PI 3.14159))
(export (class Point (constructor [x y] (= this.x x) (= this.y y))))

(fn add [a b] (+ a b))
(fn subtract [a b] (- a b))
(export [add subtract])
(export [add as sum])  ;; with alias

(export default (fn [x] (* x x)))

;; try + catch
(let result
  (try
    (parse-json input)
    (catch e
      (do
        (log.error "Parse failed:" e)
        "default"))))

;; try + finally (cleanup without error handling)
(try
  (open-resource)
  (process-data)
  (finally
    (close-resource)))

;; try + catch + finally
(try
  (let conn (open-connection))
  (query conn "SELECT *")
  (catch e
    (log.error "Query failed:" e)
    null)
  (finally
    (close-connection)))

(let safe-value (try
  (dangerous-operation)
  (catch e "fallback")))

const safeValue = (() => {
  try {
    return dangerousOperation();
  } catch (e) {
    return "fallback";
  }
})();

(try
  (risky-operation)
  (catch              ;; no parameter
    (fallback-value)))

(try
  (await (fetch-data url))
  (catch e
    (await (log-error e))))

(fn* producer [items]
  (try
    (for-of [item items]
      (yield item))
    (catch e
      (yield "error"))))

(throw (new Error "Something went wrong"))
(throw "string error")
(throw e)  ;; rethrow a caught error

(let config
  (try
    (parse-json (read-file "config.json"))
    (catch e
      {port: 3000 host: "localhost"})))

(fn validate [input]
  (when (not input)
    (throw (new Error "Input required")))
  (when (< input.length 3)
    (throw (new Error "Input too short")))
  input)

(try
  (let config (try
    (parse-json (read-file "config.json"))
    (catch e
      (log.warn "Config parse failed, trying backup")
      (parse-json (read-file "config.backup.json")))))
  (start-server config)
  (catch e
    (log.error "Fatal: cannot start server" e)
    (process.exit 1)))

(throw (new TypeError "Expected a string"))
(throw (new RangeError "Index out of bounds"))
(throw (new ReferenceError "Variable not defined"))
(throw (new SyntaxError "Unexpected token"))
(throw (new URIError "Malformed URI"))

(class AppError extends Error
  (constructor [message code]
    (super message)
    (= this.code code)
    (= this.name "AppError")))

(class NotFoundError extends AppError
  (constructor [resource]
    (super (+ resource " not found") 404)))

(try
  (throw (new NotFoundError "User"))
  (catch e
    (when (instanceof e NotFoundError)
      (respond {status: e.code message: e.message}))))

;; Default value on failure
(let port (try (parseInt env.PORT) (catch e 3000)))

;; Conditional error handling
(let result
  (try
    (do-work)
    (catch e
      (cond
        ((instanceof e TypeError)  (handle-type-error e))
        ((instanceof e RangeError) (handle-range-error e))
        (else (throw e))))))  ;; rethrow unknown errors

(async fn fetch-data [url]
  (let response (await (js/fetch url)))
  (let data (await (.json response)))
  data)

;; Anonymous async function
(let fetcher (async fn [url]
  (await (js/fetch url))))

;; Async with map parameters
(async fn connect {host: "localhost" port: 8080}
  (await (establish-connection host port)))

(let data (await (fetch-data "https://api.example.com")))

(fn* range-gen [start end]
  (var i start)
  (while (< i end)
    (yield i)
    (= i (+ i 1))))

;; Using the generator
(for-of [n (range-gen 1 5)]
  (print n))
;; Prints: 1 2 3 4

(fn* simple []
  (yield 1)
  (yield 2)
  (yield))    ;; yields undefined

(fn* combined []
  (yield* [1 2 3])           ;; yield from array
  (yield* (range-gen 4 7)))  ;; yield from generator
;; Produces: 1 2 3 4 5 6

(async fn* fetch-pages [urls]
  (for-of [url urls]
    (let response (await (js/fetch url)))
    (yield (await (.json response)))))

(for-await-of [page (fetch-pages urls)]
  (process-page page))

for await (const page of fetchPages(urls)) {
  processPage(page);
}

;; Wait for all promises to resolve
(let results (await (Promise.all [
  (fetch-user id)
  (fetch-posts id)
  (fetch-settings id)])))

;; Race -- first to resolve wins
(let fastest (await (Promise.race [
  (fetch-from-cache key)
  (fetch-from-db key)])))

;; allSettled -- wait for all, regardless of success/failure
(let outcomes (await (Promise.allSettled [
  (risky-operation-1)
  (risky-operation-2)])))

;; any -- first to succeed (ignores rejections)
(let first-success (await (Promise.any [
  (try-server-a)
  (try-server-b)
  (try-server-c)])))

(async fn process-pipeline [data]
  (let step1 (await (validate data)))
  (let step2 (await (transform step1)))
  (let step3 (await (save step2)))
  step3)

(async fn load-dashboard [userId]
  (let [user posts settings]
    (await (Promise.all [
      (fetch-user userId)
      (fetch-posts userId)
      (fetch-settings userId)])))
  {user: user posts: posts settings: settings})

(async fn retry [operation maxRetries]
  (var attempt 0)
  (loop []
    (try
      (await (operation))
      (catch e
        (= attempt (+ attempt 1))
        (if (>= attempt maxRetries)
          (throw e)
          (do
            (await (new Promise (fn [resolve]
              (js/setTimeout resolve (* 1000 (** 2 attempt))))))
            (recur)))))))

(macro my-if [test then else]
  `(cond
     (~test ~then)
     (else ~else)))

(macro my-log [level & messages]
  `(js/console.log ~level ~@messages))

(quote (+ 1 2))     ;; => ["+" 1 2]
(quote foo)          ;; => "foo"

`(+ 1 ~x)           ;; x is evaluated, rest is quoted
`(list ~@items)      ;; items is evaluated and spliced in

(-> 5
    (+ 3)      ;; (+ 5 3) => 8
    (* 2)      ;; (* 8 2) => 16
    (- 1))     ;; (- 16 1) => 15

(->> [1 2 3 4 5]
     (filter isEven)      ;; (filter isEven [1 2 3 4 5])
     (map (=> (* $0 10)))  ;; (map ... result)
     (reduce + 0))         ;; (reduce + 0 result)

(as-> [1 2 3] $
  (map inc $)       ;; $ is [1 2 3]
  (filter isEven $) ;; $ is (2 3 4)
  (reduce + 0 $))   ;; $ is (2 4)

(doto (new Map)
  (.set "a" 1)
  (.set "b" 2)
  (.set "c" 3))
;; Returns the Map with all three entries

(isNull x)      ;; (=== x null)
(isNumber x)    ;; (=== (typeof x) "number")
(isString x)    ;; (=== (typeof x) "string")
(isBoolean x)   ;; (=== (typeof x) "boolean")
(isFunction x)  ;; (=== (typeof x) "function")
(isArray x)     ;; (Array.isArray x)
(isObject x)    ;; complex check (not null, not array, typeof "object")

(macro swap [a b]
  (let [tmp (gensym "tmp")]
    `(let (~tmp ~a)
       (= ~a ~b)
       (= ~b ~tmp))))

(macro swap [a b]
  `(let (tmp# ~a)
     (= ~a ~b)
     (= ~b tmp#)))
;; Both tmp# occurrences resolve to the same unique symbol

(macro safe-swap [a b]
  (with-gensyms [tmp]
    `(let (~tmp ~a) (= ~a ~b) (= ~b ~tmp))))

(unless condition body...)
;; should behave like
(if condition nil (do body...))

(macro unless [test & body]
  `(if ~test nil (do ~@body)))

(macro dbg [expr]
  (let [name (if (symbol? expr) (name expr) "expr")]
    `(let (result# ~expr)
       (js/console.log ~(+ name " =>") result#)
       result#)))

;; CORRECT
(fn add [a:number b:number] :number
  (+ a b))

;; WRONG -- space breaks parsing!
(fn add [a: number b: number]
  (+ a b))

(let x:number 10)
(const name:string "hello")
(var count:number 0)

(fn add [a b] :number (+ a b))     ;; colon after params
(fn add [a b] -> number (+ a b))   ;; arrow after params
(fn add:number [a b] (+ a b))      ;; on the function name

(type ID number)
;; => type ID = number;

(type StringOrNumber (| string number))
;; => type StringOrNumber = string | number;

(deftype Complex "Record<string, number>")

(type Result (| "success" "error" "pending"))
;; => type Result = "success" | "error" | "pending";

(type Primitive (| string number boolean))
;; => type Primitive = string | number | boolean;

(type AdminUser (& User AdminPermissions))
;; => type AdminUser = User & AdminPermissions;

(type IsString<T> (if-extends T string true false))
;; => type IsString<T> = T extends string ? true : false;

(type UnwrapPromise<T> (if-extends T (Promise (infer U)) U T))
;; => type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;

(type MyReadonly<T> (mapped K (keyof T) (indexed T K)))
;; => type MyReadonly<T> = { [K in keyof T]: T[K] };

(type Point (tuple number number))
;; => type Point = [number, number];

(type Numbers (array number))
;; => type Numbers = number[];

;; With rest elements
(type Args (tuple string (rest (array number))))
;; => type Args = [string, ...number[]];

(type PersonKeys (keyof Person))
;; => type PersonKeys = keyof Person;

(type NameType (indexed Person "name"))
;; => type NameType = Person["name"];

(type ConfigType (typeof config))
;; => type ConfigType = typeof config;

(type ElementType<T> (if-extends T (array (infer E)) E never))

(type ImmutablePoint (readonly Point))
;; => type ImmutablePoint = readonly Point;

(type PartialPerson (Partial Person))
;; => type PartialPerson = Partial<Person>;

(type PickedUser (Pick User (| "name" "email")))
;; => type PickedUser = Pick<User, "name" | "email">;

(type StringRecord (Record string number))
;; => type StringRecord = Record<string, number>;

(fn identity<T> [x:T] :T
  x)
;; => function identity<T>(x: T): T { return x; }

(fn pair<T,U> [a:T b:U]
  [a b])

(type Container<T> T)
;; => type Container<T> = T;

(fn sum [numbers:[number]]    ;; Array type: number[]
  (reduce + 0 numbers))

(let scores:[string: number] {})  ;; Dictionary: Record<string, number>

(interface User "{ id: string; name: string }")
;; => interface User { id: string; name: string }

(interface Box<T> "{ value: T; getValue(): T }")

;; With extends
(interface Employee extends Person "{ salary: number }")
(interface Manager extends Person Serializable "{ department: string }")

(namespace Utils [
  (deftype ID "string")
])
;; => namespace Utils { type ID = string; }

(namespace Models [
  (interface User "{ id: string; name: string }")
])

(enum Color Red Green Blue)
;; => enum Color { Red, Green, Blue }

(const-enum Direction [North South East West])
;; => const enum Direction { North, South, East, West }

;; With explicit values
(const-enum Status [(OK 200) (NotFound 404) (Error 500)])
;; => const enum Status { OK = 200, NotFound = 404, Error = 500 }

(const-enum Color [(Red "red") (Green "green") (Blue "blue")])
;; => const enum Color { Red = "red", Green = "green", Blue = "blue" }

(fn-overload process "x: string" :string)
(fn-overload process "x: number" :number)
;; => function process(x: string): string;
;;    function process(x: number): number;

(declare function "greet(name: string): string")
(declare var "globalCounter: number")
(declare const "PI: 3.14159")
(declare module "my-module")

(deftype EventName "`on${string}`")
(deftype "KeyValue<K extends string, V>" "{ key: K; value: V }")
(deftype "Mutable<T>" "{ -readonly [K in keyof T]: T[K] }")

(js/console.log "Hello")           ;; console.log("Hello")
(let pi js/Math.PI)                ;; Math.PI
(let doc js/document)              ;; document
(js/JSON.stringify data)           ;; JSON.stringify(data)
(js/setTimeout callback 1000)      ;; setTimeout(callback, 1000)

(text .trim .toUpperCase)
;; => text.trim().toUpperCase()

(arr .filter (fn [x] (> x 3)) .map (fn [x] (* x 2)))
;; => arr.filter(x => x > 3).map(x => x * 2)

(text.trim.toUpperCase)
(arr.filter (fn [x] (> x 3)))

(str .split "," .map parseInt .filter (fn [x] (> x 0)))

arr.length              ;; arr.length
user.name               ;; user.name
data.users.0.name       ;; data.users[0].name

(. obj prop)            ;; obj.prop

user?.name                        ;; user?.name
data?.user?.address?.city         ;; data?.user?.address?.city

;; Method calls
(obj?.greet "World")              ;; obj?.greet("World")

;; In spaced dot notation
(obj .?method arg1)               ;; obj?.method(arg1)

;; Combined with nullish coalescing
(?? user?.name "unknown")         ;; user?.name ?? "unknown"

;; Property access
(js-get obj "property")           ;; obj.property (or obj["property"])
(js-get arr 0)                    ;; arr[0]

;; Property mutation
(js-set obj "key" value)          ;; obj.key = value

;; Method invocation
(js-call obj "method" arg1 arg2)  ;; obj.method(arg1, arg2)
(js-call Array "from" [1 2 3])    ;; Array.from([1, 2, 3])

;; Constructor (args in list)
(js-new Date (2023 11 25))        ;; new Date(2023, 11, 25)

(new Date 2023 11 25)             ;; new Date(2023, 11, 25)
(new Map)                         ;; new Map()
(new Error "Something failed")    ;; new Error("Something failed")
(new Array 5)                     ;; new Array(5)

(let name "World")
(let greeting `Hello, ${name}!`)
;; => "Hello, World!"

(let multiline `
  First line
  Second line with ${(+ 1 2)} value
  Third line`)

;; Spread in function call
(fn log-all [& args]
  (js/console.log ...args))

;; Spread in array literal
(let combined [...arr1 ...arr2])

;; Spread in object literal
(let merged {...defaults ...overrides})

(let el (js/document.querySelector "#app"))
(= el.textContent "Hello from HQL")
(el .addEventListener "click"
  (fn [event]
    (event.preventDefault)
    (process-click event)))

(import [z] from "npm:zod")

(let UserSchema
  (z.object {
    name: (z.string)
    age: (z.number .min 0 .max 150)
    email: (z.string .email)}))

(let result (UserSchema.safeParse input))
(if result.success
  (process result.data)
  (handle-errors result.error))

;; Parse
(let data (js/JSON.parse jsonString))

;; Stringify with formatting
(let pretty (js/JSON.stringify data null 2))

;; Deep clone via JSON round-trip
(let clone (js/JSON.parse (js/JSON.stringify original)))

(fx add [a:number b:number]
  (+ a b))

(fx square [x]
  (* x x))

;; Pure functions can call other pure functions
(fx sum-of-squares [a b]
  (+ (square a) (square b)))

;; ERROR: Calling impure functions
(fx bad1 [x]
  (js/console.log x)    ;; I/O is impure
  x)

;; ERROR: Mutation
(fx bad2 [arr]
  (arr.push 42)          ;; mutates the array
  arr)

;; ERROR: Generators
(fx bad3 []
  (yield 1))             ;; generators are impure

;; ERROR: Calling unknown/impure functions
(fx bad4 [x]
  (fetch x))             ;; network I/O is impure

(fx map-pure [f:pure items]
  (map f items))

(map-pure (fx [x] (* x 2)) [1 2 3])    ;; OK
(map-pure (fn [x] (print x)) [1 2 3])  ;; ERROR: fn is not pure

(fx compute [x]
  (Math.floor (* x 100)))       ;; Math.floor is pure

(fx serialize [data]
  (js/JSON.stringify data))     ;; JSON.stringify is pure

(fx check-array [x]
  (Array.isArray x))            ;; Array.isArray is pure

;; ERROR: Math.random is impure
(fx bad-random []
  (Math.random))

;; ERROR: console methods are impure
(fx bad-log [x]
  (js/console.log x))

(fx make-pattern [str]
  (new RegExp str))              ;; RegExp constructor is pure

(fx make-error [msg]
  (new Error msg))               ;; Error constructor is pure

(fx make-date [y m d]
  (new Date y m d))              ;; Date constructor is pure

;; ERROR: WebSocket constructor has side effects
(fx bad-socket [url]
  (new WebSocket url))

;; ERROR: Worker constructor has side effects
(fx bad-worker [script]
  (new Worker script))

(fx add [x y] (+ x y))

function add(x, y) {
  return x + y;
}

(first [1 2 3])          ;; => 1
(first "hello")          ;; => "h"
(first [])               ;; => undefined

(rest [1 2 3])           ;; => (2 3)  -- lazy
(rest [1])               ;; => ()
(rest [])                ;; => ()

(cons 0 [1 2 3])         ;; => (0 1 2 3)  -- lazy

(seq [1 2 3])            ;; => (1 2 3)
(seq [])                 ;; => nil

(next [1 2 3])           ;; => (2 3)
(next [1])               ;; => nil  -- unlike rest which returns ()

;; Taking and dropping
(take 3 [1 2 3 4 5])    ;; => (1 2 3)  -- lazy
(drop 2 [1 2 3 4 5])    ;; => (3 4 5)  -- lazy

;; Transformations
(map (fn [x] (* x 2)) [1 2 3])     ;; => (2 4 6)  -- lazy
(filter isEven [1 2 3 4])           ;; => (2 4)  -- lazy
(reduce + 0 [1 2 3 4])              ;; => 10

;; Combining
(concat [1 2] [3 4])    ;; => (1 2 3 4)  -- lazy
(flatten [[1 2] [3 4]]) ;; => (1 2 3 4)  -- one level deep, lazy
(distinct [1 2 2 3 1])  ;; => (1 2 3)  -- lazy

;; Counting and access
(count [1 2 3])          ;; => 3  -- O(1) for arrays
(last [1 2 3])           ;; => 3  -- O(1) for arrays
(nth [10 20 30] 1)       ;; => 20
(second [1 2 3])         ;; => 2

(mapIndexed (fn [i x] [i x]) ["a" "b" "c"])
;; => ([0 "a"] [1 "b"] [2 "c"])

(keepIndexed (fn [i x] (if (isEven i) x nil)) ["a" "b" "c" "d"])
;; => ("a" "c")

(mapcat (fn [x] [x x]) [1 2 3])
;; => (1 1 2 2 3 3)

(keep (fn [x] (if (> x 0) x nil)) [-1 0 1 2])
;; => (1 2)

(comp (fn [x] (* x 2)) (fn [x] (+ x 1)))  ;; compose right-to-left
(partial + 10)                               ;; partially apply
(apply + [1 2 3 4])                          ;; => 10

;; Numeric ranges
(range 5)                ;; => (0 1 2 3 4)
(range 2 5)              ;; => (2 3 4)
(range 0 10 2)           ;; => (0 2 4 6 8)

;; Infinite sequences (always use take!)
(take 5 (repeat 42))             ;; => (42 42 42 42 42)
(take 5 (cycle [1 2 3]))         ;; => (1 2 3 1 2)
(take 5 (iterate inc 0))         ;; => (0 1 2 3 4)
(take 3 (repeatedly Math.random)) ;; => (0.12 0.45 0.78)

;; Custom lazy sequence
(fn fib []
  (lazy-seq
    (let [helper (fn [a b]
                   (cons a (lazy-seq (helper b (+ a b)))))]
      (helper 0 1))))

(take 8 (fib))  ;; => (0 1 1 2 3 5 8 13)

;; Create a delayed computation
(let d (delay (do
  (print "Computing...")
  (* 42 42))))

;; Not yet computed
(realized d)  ;; => false

;; Force evaluation -- computes and caches
(force d)     ;; prints "Computing...", => 1764

;; Second force returns cached value
(force d)     ;; => 1764 (no recomputation)
(realized d)  ;; => true

;; Convert to vector (eager array)
(vec (range 5))              ;; => [0 1 2 3 4]
(vec (filter isEven (range 10))) ;; => [0 2 4 6 8]

;; Convert to set (removes duplicates)
(set [1 2 2 3 1])            ;; => Set {1, 2, 3}

;; Build a collection from a transducer
(into [] (filter isEven) [1 2 3 4 5])  ;; => [2 4]
(into {} (map (fn [x] [x (* x x)])) [1 2 3])
;; => {1: 1, 2: 4, 3: 9}

;; Realize a lazy sequence into an array
(doall (map inc [1 2 3]))    ;; => [2 3 4]

;; Fixed-size chunks
(partition 2 [1 2 3 4 5 6])      ;; => ((1 2) (3 4) (5 6))
(partition 3 [1 2 3 4 5])        ;; => ((1 2 3))  -- incomplete chunk dropped

;; Partition by predicate change
(partitionBy isEven [1 3 2 4 5])
;; => ((1 3) (2 4) (5))

;; Interleave two sequences
(interleave [1 2 3] ["a" "b" "c"])
;; => (1 "a" 2 "b" 3 "c")

;; Insert separator between elements
(interpose ", " ["a" "b" "c"])
;; => ("a" ", " "b" ", " "c")

;; Zip two sequences into a map
(zipmap ["name" "age" "city"] ["Alice" 30 "NYC"])
;; => {name: "Alice", age: 30, city: "NYC"}

;; Collection predicates
(isEmpty [])             ;; => true
(some isEven [1 3 5])    ;; => nil
(some isEven [1 2 3])    ;; => 2 (first truthy result)
(every isEven [2 4 6])   ;; => true
(notAny isEven [1 3 5])  ;; => true
(notEvery isEven [2 3])  ;; => true

;; Nil checking
(isSome 0)               ;; => true (not nil)
(isSome nil)             ;; => false
(isNil null)             ;; => true

;; Numeric predicates
(isEven 4)               ;; => true
(isOdd 3)                ;; => true
(isZero 0)               ;; => true
(isPositive 5)           ;; => true
(isNegative -3)          ;; => true

;; Type predicates (macros)
(isNumber 42)            ;; => true
(isString "hi")          ;; => true
(isBoolean true)         ;; => true
(isFunction +)           ;; => true
(isArray [1 2])          ;; => true

(+ 1 2 3 4 5)           ;; => 15
(- 10 3)                 ;; => 7
(* 2 3 4)                ;; => 24
(/ 100 5)                ;; => 20

(inc 5)                  ;; => 6  (macro: (+ x 1))
(dec 5)                  ;; => 4  (macro: (- x 1))

;; First-class operator usage
(reduce + 0 [1 2 3])    ;; => 6
(reduce * 1 [1 2 3 4])  ;; => 24
(map inc [1 2 3])        ;; => (2 3 4)

;; Stdlib also provides named function wrappers for operators:
;; add, sub, mul, div, mod, abs, lt, gt, lte, gte, deepEq
(reduce add 0 [1 2 3])  ;; => 6  (equivalent to reduce +)
(abs -5)                 ;; => 5
(deepEq [1 [2 3]] [1 [2 3]])  ;; => true

(keys {a: 1 b: 2})                      ;; => ["a" "b"]
(vals {a: 1 b: 2})                      ;; => [1 2]
(get {a: 1 b: 2} "a")                   ;; => 1
(get {a: 1} "c" "default")              ;; => "default"

(assoc {a: 1} "b" 2)                    ;; => {a: 1, b: 2}
(dissoc {a: 1 b: 2} "b")               ;; => {a: 1}
(merge {a: 1} {b: 2} {c: 3})           ;; => {a: 1, b: 2, c: 3}

;; Nested operations
(getIn {a: {b: {c: 42}}} ["a" "b" "c"]) ;; => 42
(assocIn {} ["a" "b"] 1)                ;; => {a: {b: 1}}
(updateIn {a: {b: 1}} ["a" "b"] inc)    ;; => {a: {b: 2}}

;; update -- apply function to value at key
(update {a: 1 b: 2} "a" inc)            ;; => {a: 2, b: 2}

;; zipmap -- create map from keys and values
(zipmap ["a" "b"] [1 2])                ;; => {a: 1, b: 2}

(sort [3 1 4 1 5])                       ;; => [1 1 3 4 5]
(sortBy (fn [x] (- x)) [3 1 4])         ;; => [4 3 1]

(groupBy isEven [1 2 3 4 5])
;; => {true: [2 4], false: [1 3 5]}

;; Basic transducer composition
(let xf (comp
           (filter isEven)
           (map (fn [x] (* x 10)))))

(transduce xf + 0 [1 2 3 4 5])
;; => 60  (2*10 + 4*10)

(into [] xf [1 2 3 4 5])
;; => [20 40]

(transduce
  (fn [rf]
    (fn
      ([] (rf))
      ([result] (rf result))
      ([result input]
        (if (> input 3)
          (reduced result)
          (rf result input)))))
  + 0 [1 2 3 4 5])
;; => 6  (1 + 2 + 3, stops at 4)

(+ 2 (* 3 4))  ;; 2 + (3 * 4) = 14, explicit
(* (+ 2 3) 4)  ;; (2 + 3) * 4 = 20, explicit

hlvm run program.hql
hlvm run src/main.hql --verbose

hlvm compile program.hql              # outputs to stdout
hlvm compile program.hql -o output.js  # outputs to file
hlvm compile program.hql --ts          # TypeScript output

hlvm repl

hlvm init my-project
cd my-project
hlvm run src/main.hql

hlvm upgrade

;; Start with values
+ 1 2 3

;; Wrap the operator (Ctrl+Y at +)
(+) 1 2 3

;; Slurp all arguments (Ctrl+] three times)
(+ 1 2 3)    ;; Done!

program        ::= form*

form           ::= atom | list | vector | hash-map | set-literal | quoted-form

atom           ::= symbol | number | string | boolean | nil | keyword | bigint

symbol         ::= identifier ('.' identifier)* ('?' | '!')?
                  | operator
                  | 'js/' identifier ('.' identifier)*

number         ::= integer | float
integer        ::= '-'? digit+
float          ::= '-'? digit+ '.' digit+
bigint         ::= digit+ 'n'

string         ::= '"' char* '"'
                  | '`' (char | '${' form '}')* '`'

boolean        ::= 'true' | 'false'
nil            ::= 'null' | 'undefined' | 'nil'

list           ::= '(' form* ')'
vector         ::= '[' form* ']'
hash-map       ::= '{' (form ':' form ','?)* '}'
set-literal    ::= '#[' form* ']'

quoted-form    ::= "'" form           ;; quote
                 | '`' form           ;; quasiquote
                 | '~' form           ;; unquote
                 | '~@' form          ;; unquote-splicing

operator       ::= '+' | '-' | '*' | '/' | '%' | '**'
                 | '<' | '>' | '<=' | '>=' | '===' | '==' | '!==' | '!='
                 | '&&' | '||' | '!' | '??' | '?'
                 | '&' | '|' | '^' | '~' | '<<' | '>>' | '>>>'
                 | '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '**='
                 | '&=' | '|=' | '^=' | '<<=' | '>>=' | '>>>='
                 | '??=' | '&&=' | '||='

comment        ::= '//' char-until-eol
                 | ';' char-until-eol
                 | ';;' char-until-eol

binding-form   ::= '(' ('let' | 'const' | 'var' | 'def') pattern value ')'

pattern        ::= symbol
                 | '[' pattern* ('&' symbol)? ']'
                 | '{' (symbol ':' pattern)* '}'

fn-form        ::= '(' 'fn' name? params body+ ')'
                 | '(' 'fn' name? clause+ ')'

params         ::= '[' (param-elem)* ']'
                 | '{' (key ':' value ','?)* '}'

param-elem     ::= symbol (':' type)?
                 | symbol '=' default-value
                 | '&' symbol
                 | '[' param-elem* ']'

clause         ::= '(' params body+ ')'

type-annotation ::= symbol ':' type-expr
type-expr       ::= simple-type | generic-type | inline-union
                   | inline-nullable | inline-array
                   | inline-object | inline-tuple | inline-function