rose-ash/lib/lua/runtime.sx

(define lua-truthy? (fn (v) (and (not (= v nil)) (not (= v false)))))

(define
  lua-to-number
  (fn
    (v)
    (cond
      ((= (type-of v) "number") v)
      ((= (type-of v) "string")
        (let ((n (parse-number (trim v)))) (if (= n nil) nil n)))
      (else nil))))

(define
  lua-to-string
  (fn
    (v)
    (cond
      ((= v nil) "nil")
      ((= v true) "true")
      ((= v false) "false")
      ((= (type-of v) "number") (str v))
      ((= (type-of v) "string") v)
      (else (str v)))))

(define
  lua-num-op
  (fn
    (op a b)
    (let
      ((na (lua-to-number a)) (nb (lua-to-number b)))
      (begin
        (when
          (or (= na nil) (= nb nil))
          (error (str "lua: arith on non-number: " a " " op " " b)))
        (cond
          ((= op "+") (+ na nb))
          ((= op "-") (- na nb))
          ((= op "*") (* na nb))
          ((= op "/") (/ na nb))
          ((= op "%") (- na (* nb (floor (/ na nb)))))
          ((= op "^") (pow na nb))
          (else (error (str "lua: unknown arith op " op))))))))

(define
  lua-get-mm
  (fn
    (v name)
    (cond
      ((not (= (type-of v) "dict")) nil)
      (else
        (let
          ((mt (get v "__meta")))
          (cond
            ((= mt nil) nil)
            ((not (= (type-of mt) "dict")) nil)
            ((has-key? mt name) (get mt name))
            (else nil)))))))

(define
  lua-arith
  (fn
    (mm op a b)
    (cond
      ((and (= (type-of a) "number") (= (type-of b) "number"))
        (lua-num-op op a b))
      ((and
         (or (= (type-of a) "number") (= (type-of a) "string"))
         (or (= (type-of b) "number") (= (type-of b) "string"))
         (not (= (lua-to-number a) nil))
         (not (= (lua-to-number b) nil)))
        (lua-num-op op a b))
      (else
        (let
          ((m (lua-get-mm a mm)))
          (cond
            ((not (= m nil)) (lua-first (m a b)))
            (else
              (let
                ((m2 (lua-get-mm b mm)))
                (if
                  (not (= m2 nil))
                  (lua-first (m2 a b))
                  (error (str "lua: arith on " (type-of a) " " op " " (type-of b))))))))))))

(define lua-add (fn (a b) (lua-arith "__add" "+" a b)))

(define lua-sub (fn (a b) (lua-arith "__sub" "-" a b)))

(define lua-mul (fn (a b) (lua-arith "__mul" "*" a b)))

(define lua-div (fn (a b) (lua-arith "__div" "/" a b)))

(define lua-mod (fn (a b) (lua-arith "__mod" "%" a b)))

(define lua-pow (fn (a b) (lua-arith "__pow" "^" a b)))

(define
  lua-neg
  (fn
    (a)
    (cond
      ((= (type-of a) "number") (- 0 a))
      (else
        (let
          ((na (lua-to-number a)))
          (cond
            ((not (= na nil)) (- 0 na))
            (else
              (let
                ((m (lua-get-mm a "__unm")))
                (if
                  (not (= m nil))
                  (lua-first (m a))
                  (error (str "lua: neg on non-number: " (type-of a))))))))))))

(define
  lua-concat-coerce
  (fn
    (v)
    (cond
      ((= (type-of v) "string") v)
      ((= (type-of v) "number") (str v))
      (else (error (str "lua: cannot concat " v))))))

(define
  lua-concat
  (fn
    (a b)
    (cond
      ((and
         (or (= (type-of a) "string") (= (type-of a) "number"))
         (or (= (type-of b) "string") (= (type-of b) "number")))
        (str (lua-concat-coerce a) (lua-concat-coerce b)))
      (else
        (let
          ((m (lua-get-mm a "__concat")))
          (cond
            ((not (= m nil)) (lua-first (m a b)))
            (else
              (let
                ((m2 (lua-get-mm b "__concat")))
                (if
                  (not (= m2 nil))
                  (lua-first (m2 a b))
                  (error (str "lua: concat on " (type-of a) " and " (type-of b))))))))))))

(define
  lua-eq
  (fn
    (a b)
    (cond
      ((and (= a nil) (= b nil)) true)
      ((or (= a nil) (= b nil)) false)
      ((and (= (type-of a) (type-of b)) (= a b)) true)
      ((and (= (type-of a) "dict") (= (type-of b) "dict"))
        (let
          ((m (lua-get-mm a "__eq")))
          (cond
            ((not (= m nil))
              (let ((r (lua-first (m a b)))) (and (not (= r nil)) (not (= r false)))))
            (else false))))
      (else false))))

(define lua-neq (fn (a b) (not (lua-eq a b))))

(define
  lua-lt
  (fn
    (a b)
    (cond
      ((and (= (type-of a) "number") (= (type-of b) "number")) (< a b))
      ((and (= (type-of a) "string") (= (type-of b) "string")) (< a b))
      (else
        (let
          ((m (lua-get-mm a "__lt")))
          (cond
            ((not (= m nil))
              (let ((r (lua-first (m a b)))) (and (not (= r nil)) (not (= r false)))))
            (else
              (let
                ((m2 (lua-get-mm b "__lt")))
                (cond
                  ((not (= m2 nil))
                    (let ((r (lua-first (m2 a b)))) (and (not (= r nil)) (not (= r false)))))
                  (else (error "lua: attempt to compare incompatible types")))))))))))

(define
  lua-le
  (fn
    (a b)
    (cond
      ((and (= (type-of a) "number") (= (type-of b) "number")) (<= a b))
      ((and (= (type-of a) "string") (= (type-of b) "string"))
        (or (< a b) (= a b)))
      (else
        (let
          ((m (lua-get-mm a "__le")))
          (cond
            ((not (= m nil))
              (let ((r (lua-first (m a b)))) (and (not (= r nil)) (not (= r false)))))
            (else
              (let
                ((m2 (lua-get-mm b "__le")))
                (cond
                  ((not (= m2 nil))
                    (let ((r (lua-first (m2 a b)))) (and (not (= r nil)) (not (= r false)))))
                  (else (not (lua-lt b a))))))))))))

(define lua-gt (fn (a b) (lua-lt b a)))

(define lua-ge (fn (a b) (lua-le b a)))

(define
  lua-len
  (fn
    (a)
    (cond
      ((= (type-of a) "string") (len a))
      ((= (type-of a) "list") (len a))
      ((= (type-of a) "dict")
        (let
          ((m (lua-get-mm a "__len")))
          (cond
            ((not (= m nil)) (lua-first (m a)))
            (else
              (let
                ((n 0))
                (begin
                  (define
                    count-loop
                    (fn
                      (i)
                      (if
                        (has-key? a (str i))
                        (begin (set! n i) (count-loop (+ i 1)))
                        n)))
                  (count-loop 1)))))))
      (else (error (str "lua: len on non-len type: " (type-of a)))))))

(define
  lua-for-continue?
  (fn (i stop step) (if (> step 0) (<= i stop) (>= i stop))))

(define
  lua-make-table
  (fn
    (&rest fields)
    (let
      ((t {}) (array-idx 1))
      (begin
        (define
          process
          (fn
            (fs)
            (when
              (> (len fs) 0)
              (begin
                (let
                  ((f (first fs)))
                  (cond
                    ((= (first f) "pos")
                      (let ((v (nth f 1)))
                        (cond
                          ((and (lua-multi? v) (= (len fs) 1))
                            (begin
                              (define
                                spread-loop
                                (fn (i)
                                  (when (< i (len v))
                                    (begin
                                      (set! t (assoc t (str array-idx) (nth v i)))
                                      (set! array-idx (+ array-idx 1))
                                      (spread-loop (+ i 1))))))
                              (spread-loop 1)))
                          (else
                            (let ((val (if (lua-multi? v) (lua-first v) v)))
                              (begin
                                (set! t (assoc t (str array-idx) val))
                                (set! array-idx (+ array-idx 1))))))))
                    ((= (first f) "kv")
                      (let
                        ((k (nth f 1)) (v (nth f 2)))
                        (set! t (assoc t (str k) v))))))
                (process (rest fs))))))
        (process fields)
        t))))

(define
  lua-get
  (fn
    (t k)
    (cond
      ((= t nil) nil)
      ((not (= (type-of t) "dict")) nil)
      (else
        (let
          ((key (str k)))
          (cond
            ((has-key? t key) (get t key))
            (else
              (let
                ((m (lua-get-mm t "__index")))
                (cond
                  ((= m nil) nil)
                  ((= (type-of m) "dict") (lua-get m k))
                  (else (lua-first (m t k))))))))))))

(define
  lua-set!
  (fn
    (t k v)
    (let
      ((key (str k)))
      (cond
        ((has-key? t key) (dict-set! t key v))
        (else
          (let
            ((m (lua-get-mm t "__newindex")))
            (cond
              ((= m nil) (dict-set! t key v))
              ((= (type-of m) "dict") (lua-set! m k v))
              (else (begin (m t k v) nil)))))))))

(define
  lua-multi?
  (fn
    (v)
    (and
      (= (type-of v) "list")
      (> (len v) 0)
      (= (first v) (quote lua-multi)))))

(define
  lua-first
  (fn
    (v)
    (cond
      ((lua-multi? v) (if (> (len v) 1) (nth v 1) nil))
      (else v))))

(define
  lua-nth-ret
  (fn
    (v i)
    (cond
      ((lua-multi? v)
        (let ((idx (+ i 1))) (if (< idx (len v)) (nth v idx) nil)))
      (else (if (= i 0) v nil)))))

(define
  lua-pack-build
  (fn
    (vals i)
    (cond
      ((>= i (len vals)) (list))
      ((= i (- (len vals) 1))
        (let
          ((last (nth vals i)))
          (if (lua-multi? last) (rest last) (list last))))
      (else (cons (nth vals i) (lua-pack-build vals (+ i 1)))))))

(define
  lua-pack-return
  (fn
    (vals)
    (cond
      ((= (len vals) 0) (list (quote lua-multi)))
      (else (cons (quote lua-multi) (lua-pack-build vals 0))))))

(define lua-setmetatable (fn (t mt) (begin (dict-set! t "__meta" mt) t)))

(define
  lua-getmetatable
  (fn
    (t)
    (cond
      ((not (= (type-of t) "dict")) nil)
      ((has-key? t "__meta") (get t "__meta"))
      (else nil))))

(define setmetatable lua-setmetatable)
(define getmetatable lua-getmetatable)

(define
  lua-type
  (fn
    (v)
    (cond
      ((= v nil) "nil")
      ((= (type-of v) "number") "number")
      ((= (type-of v) "string") "string")
      ((= v true) "boolean")
      ((= v false) "boolean")
      ((= (type-of v) "dict") "table")
      ((or (= (type-of v) "function") (= (type-of v) "lambda")) "function")
      (else (type-of v)))))

(define type lua-type)

(define sx-apply-ref apply)

(define
  lua-spread-last-multi
  (fn (rargs)
    (cond
      ((= (len rargs) 0) rargs)
      (else
        (let ((last-idx (- (len rargs) 1)))
          (let ((last (nth rargs last-idx)))
            (cond
              ((lua-multi? last)
                (let ((init (lua-pack-build rargs 0)))
                  (append
                    (if (> last-idx 0) (lua-init-before rargs 0 last-idx) (list))
                    (rest last))))
              (else rargs))))))))

(define
  lua-init-before
  (fn (rargs i limit)
    (if (>= i limit)
        (list)
        (cons (nth rargs i) (lua-init-before rargs (+ i 1) limit)))))

(define
  lua-apply
  (fn
    (f rargs-in)
    (let
      ((rargs (lua-spread-last-multi rargs-in)))
      (let
        ((n (len rargs)))
        (cond
          ((= n 0) (f))
          ((= n 1) (f (nth rargs 0)))
          ((= n 2) (f (nth rargs 0) (nth rargs 1)))
          ((= n 3) (f (nth rargs 0) (nth rargs 1) (nth rargs 2)))
          ((= n 4) (f (nth rargs 0) (nth rargs 1) (nth rargs 2) (nth rargs 3)))
          ((= n 5) (f (nth rargs 0) (nth rargs 1) (nth rargs 2) (nth rargs 3) (nth rargs 4)))
          ((= n 6) (f (nth rargs 0) (nth rargs 1) (nth rargs 2) (nth rargs 3) (nth rargs 4) (nth rargs 5)))
          ((= n 7) (f (nth rargs 0) (nth rargs 1) (nth rargs 2) (nth rargs 3) (nth rargs 4) (nth rargs 5) (nth rargs 6)))
          ((= n 8) (f (nth rargs 0) (nth rargs 1) (nth rargs 2) (nth rargs 3) (nth rargs 4) (nth rargs 5) (nth rargs 6) (nth rargs 7)))
          (else (sx-apply-ref f rargs)))))))

(define
  lua-call
  (fn
    (&rest args)
    (let
      ((f (first args)) (rargs (rest args)))
      (cond
        ((or (= (type-of f) "function") (= (type-of f) "lambda"))
          (lua-apply f rargs))
        ((= (type-of f) "dict")
          (let
            ((m (lua-get-mm f "__call")))
            (cond
              ((= m nil) (error "lua: attempt to call non-function"))
              (else (lua-apply m (cons f rargs))))))
        (else (error "lua: attempt to call non-function"))))))

(define lua-error (fn (&rest args) (raise (first args))))

(define error lua-error)

(define
  pcall
  (fn
    (&rest args)
    (let
      ((f (first args)) (rargs (rest args)))
      (guard
        (e (true (list (quote lua-multi) false e)))
        (let
          ((r (lua-apply f rargs)))
          (cond
            ((lua-multi? r) (cons (quote lua-multi) (cons true (rest r))))
            (else (list (quote lua-multi) true r))))))))

(define
  xpcall
  (fn
    (f msgh)
    (guard
      (e (true (list (quote lua-multi) false (lua-first (lua-apply msgh (list e))))))
      (let
        ((r (lua-apply f (list))))
        (cond
          ((lua-multi? r) (cons (quote lua-multi) (cons true (rest r))))
          (else (list (quote lua-multi) true r)))))))

(define
  lua-ipairs-iter
  (fn
    (t i)
    (let
      ((nk (+ i 1)))
      (let
        ((v (get t (str nk))))
        (if (= v nil) nil (list (quote lua-multi) nk v))))))

(define
  lua-ipairs
  (fn
    (t)
    (list (quote lua-multi) lua-ipairs-iter t 0)))

(define ipairs lua-ipairs)

(define
  lua-next-skip-meta
  (fn
    (ks)
    (cond
      ((= (len ks) 0) (list))
      ((= (first ks) "__meta") (lua-next-skip-meta (rest ks)))
      (else ks))))

(define
  lua-next-after
  (fn
    (ks prev-key)
    (cond
      ((= (len ks) 0) (list))
      ((= (first ks) (str prev-key)) (lua-next-skip-meta (rest ks)))
      (else (lua-next-after (rest ks) prev-key)))))

(define
  lua-key-to-value
  (fn
    (k)
    (cond
      ((= k "true") true)
      ((= k "false") false)
      (else
        (let
          ((n (lua-to-number k))) (if (= n nil) k n))))))

(define
  lua-next
  (fn
    (&rest args)
    (let
      ((t (first args))
        (prev (if (> (len (rest args)) 0) (first (rest args)) nil)))
      (let
        ((all-keys (keys t)))
        (let
          ((ks (if (= prev nil) (lua-next-skip-meta all-keys) (lua-next-after all-keys prev))))
          (cond
            ((= (len ks) 0) nil)
            (else
              (let
                ((k (first ks)))
                (list (quote lua-multi) (lua-key-to-value k) (get t k))))))))))

(define next lua-next)

(define
  lua-pairs
  (fn
    (t)
    (list (quote lua-multi) lua-next t nil)))

(define pairs lua-pairs)

(define
  lua-arg
  (fn
    (args i)
    (if (< i (len args)) (nth args i) nil)))

;; ── Coroutines (call/cc based) ────────────────────────────────
(define __current-co nil)

(define
  lua-coroutine-create
  (fn
    (f)
    (let ((co {}))
      (begin
        (dict-set! co "__co" true)
        (dict-set! co "status" "suspended")
        (dict-set! co "body" f)
        (dict-set! co "resume-k" nil)
        (dict-set! co "caller-k" nil)
        co))))

(define
  lua-coroutine-status
  (fn
    (co)
    (if (and (= (type-of co) "dict") (has-key? co "__co"))
        (get co "status")
        (error "lua: not a coroutine"))))

(define
  lua-co-wrap-result
  (fn (r)
    (cond
      ((lua-multi? r) (cons (quote lua-multi) (cons true (rest r))))
      (else (list (quote lua-multi) true r)))))

(define
  lua-co-first-call
  (fn (co rvals prev)
    (let ((r (lua-apply (get co "body") rvals)))
      (begin
        (dict-set! co "status" "dead")
        (set! __current-co prev)
        ((get co "caller-k") (lua-co-wrap-result r))))))

(define
  lua-co-continue-call
  (fn (co rvals)
    (let ((rk (get co "resume-k")))
      (begin
        (dict-set! co "resume-k" nil)
        (rk (if (> (len rvals) 0) (first rvals) nil))))))

(define
  lua-coroutine-resume
  (fn
    (&rest args)
    (let ((co (first args)) (rvals (rest args)))
      (cond
        ((not (and (= (type-of co) "dict") (has-key? co "__co")))
          (list (quote lua-multi) false "not a coroutine"))
        ((= (get co "status") "dead")
          (list (quote lua-multi) false "cannot resume dead coroutine"))
        ((= (get co "status") "running")
          (list (quote lua-multi) false "cannot resume running coroutine"))
        (else
          (call/cc
            (fn (k)
              (let ((prev __current-co))
                (begin
                  (dict-set! co "caller-k" k)
                  (dict-set! co "status" "running")
                  (set! __current-co co)
                  (guard
                    (e (true
                         (begin
                           (dict-set! co "status" "dead")
                           (set! __current-co prev)
                           (list (quote lua-multi) false e))))
                    (cond
                      ((= (get co "resume-k") nil) (lua-co-first-call co rvals prev))
                      (else (lua-co-continue-call co rvals)))))))))))))

(define
  lua-coroutine-yield
  (fn
    (&rest yvals)
    (cond
      ((= __current-co nil) (error "lua: attempt to yield from outside a coroutine"))
      (else
        (call/cc
          (fn (k)
            (let ((co __current-co))
              (begin
                (dict-set! co "resume-k" k)
                (dict-set! co "status" "suspended")
                (set! __current-co nil)
                ((get co "caller-k") (cons (quote lua-multi) (cons true yvals)))))))))))

(define
  lua-co-wrap-caller
  (fn (co args)
    (let ((r (sx-apply-ref lua-coroutine-resume (cons co args))))
      (cond
        ((and (lua-multi? r) (> (len r) 1) (= (nth r 1) true))
          (cond
            ((<= (len r) 2) nil)
            ((= (len r) 3) (nth r 2))
            (else (cons (quote lua-multi) (rest (rest r))))))
        ((and (lua-multi? r) (> (len r) 1))
          (error (if (> (len r) 2) (nth r 2) "coroutine error")))
        (else nil)))))

(define
  lua-coroutine-wrap
  (fn (f)
    (let ((co (lua-coroutine-create f)))
      (fn (&rest args) (lua-co-wrap-caller co args)))))

(define coroutine {})

(dict-set! coroutine "create" lua-coroutine-create)
(dict-set! coroutine "resume" lua-coroutine-resume)
(dict-set! coroutine "yield" lua-coroutine-yield)
(dict-set! coroutine "status" lua-coroutine-status)
(dict-set! coroutine "wrap" lua-coroutine-wrap)

;; ── string library ────────────────────────────────────────────
(define string {})

(define __ascii-32-126 " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~")

(define
  lua-string-len
  (fn (s) (len s)))

(define
  lua-string-upper
  (fn (s) (upcase s)))

(define
  lua-string-lower
  (fn (s) (downcase s)))

(define
  lua-string-rep
  (fn (s n)
    (cond
      ((<= n 0) "")
      ((= n 1) s)
      (else (str s (lua-string-rep s (- n 1)))))))

(define
  lua-string-sub
  (fn (&rest args)
    (let ((s (first args))
          (slen (len (first args)))
          (i (nth args 1))
          (j (if (> (len args) 2) (nth args 2) -1)))
      (let ((ni (cond
                  ((< i 0) (+ slen i 1))
                  ((= i 0) 1)
                  (else i)))
            (nj (cond
                  ((< j 0) (+ slen j 1))
                  ((> j slen) slen)
                  (else j))))
        (let ((ci (if (< ni 1) 1 ni))
              (cj (if (> nj slen) slen nj)))
          (cond
            ((> ci cj) "")
            (else (substring s (- ci 1) cj))))))))

(define
  lua-string-byte
  (fn (&rest args)
    (let ((s (first args))
          (i (if (> (len args) 1) (nth args 1) 1)))
      (cond
        ((or (< i 1) (> i (len s))) nil)
        (else (char-code (char-at s (- i 1))))))))

(define
  lua-char-one
  (fn (n)
    (cond
      ((= n 9) "\t")
      ((= n 10) "\n")
      ((= n 13) "\r")
      ((and (>= n 32) (<= n 126)) (char-at __ascii-32-126 (- n 32)))
      (else (error (str "lua: string.char out of range: " n))))))

(define
  lua-string-char
  (fn (&rest args)
    (cond
      ((= (len args) 0) "")
      (else
        (let ((out ""))
          (begin
            (define
              loop
              (fn (i)
                (when (< i (len args))
                  (begin
                    (set! out (str out (lua-char-one (nth args i))))
                    (loop (+ i 1))))))
            (loop 0)
            out))))))

;; Literal-only string.find: returns (start, end) 1-indexed or nil.
(define
  lua-string-find
  (fn (&rest args)
    (let ((s (first args))
          (pat (nth args 1))
          (init (if (> (len args) 2) (nth args 2) 1)))
      (let ((start-i (cond
                       ((< init 0) (+ (len s) init 1))
                       ((= init 0) 1)
                       (else init))))
        (let ((sub (if (<= start-i 1) s (substring s (- start-i 1) (len s)))))
          (let ((idx (index-of sub pat)))
            (cond
              ((< idx 0) nil)
              (else
                (list
                  (quote lua-multi)
                  (+ start-i idx)
                  (+ start-i idx (len pat) -1))))))))))

;; Literal-only string.match: returns matched substring or nil (no captures since no pattern).
(define
  lua-string-match
  (fn (&rest args)
    (let ((s (first args)) (pat (nth args 1)))
      (let ((idx (index-of s pat)))
        (cond
          ((< idx 0) nil)
          (else pat))))))

;; Literal-only string.gmatch: iterator producing each literal match of pat.
(define
  lua-string-gmatch
  (fn (s pat)
    (let ((pos 0))
      (fn (&rest __)
        (cond
          ((> pos (len s)) nil)
          (else
            (let ((rest-str (if (= pos 0) s (substring s pos (len s)))))
              (let ((idx (index-of rest-str pat)))
                (cond
                  ((< idx 0) (begin (set! pos (+ (len s) 1)) nil))
                  (else
                    (begin
                      (set! pos (+ pos idx (len pat)))
                      pat)))))))))))

;; Literal-only string.gsub: replace all occurrences of pat with repl (string only for now).
(define
  lua-string-gsub
  (fn (&rest args)
    (let ((s (first args))
          (pat (nth args 1))
          (repl (nth args 2))
          (max-n (if (> (len args) 3) (nth args 3) -1)))
      (cond
        ((= (len pat) 0) (list (quote lua-multi) s 0))
        (else
          (let ((out "") (pos 0) (count 0) (done false))
            (begin
              (define
                loop
                (fn ()
                  (when (and (not done) (<= pos (len s)))
                    (let ((rest-str (if (= pos 0) s (substring s pos (len s)))))
                      (let ((idx (index-of rest-str pat)))
                        (cond
                          ((< idx 0)
                            (begin
                              (set! out (str out rest-str))
                              (set! done true)))
                          ((and (>= max-n 0) (>= count max-n))
                            (begin
                              (set! out (str out rest-str))
                              (set! done true)))
                          (else
                            (let ((before (substring rest-str 0 idx)))
                              (begin
                                (set! out (str out before (if (= (type-of repl) "string") repl (str repl))))
                                (set! pos (+ pos idx (len pat)))
                                (set! count (+ count 1))
                                (loop))))))))))
              (loop)
              (list (quote lua-multi) out count))))))))

;; Basic string.format: %s %d %f (%%.Nf ignored), %%.
(define
  lua-format-int
  (fn (n)
    (cond
      ((= (type-of n) "number") (str (floor n)))
      (else (str n)))))

(define
  lua-string-format
  (fn (&rest args)
    (let ((fmt (first args)) (vals (rest args)))
      (let ((out "") (i 0) (vi 0))
        (begin
          (define
            loop
            (fn ()
              (when (< i (len fmt))
                (let ((c (char-at fmt i)))
                  (cond
                    ((and (= c "%") (< (+ i 1) (len fmt)))
                      (let ((spec (char-at fmt (+ i 1))))
                        (cond
                          ((= spec "%")
                            (begin (set! out (str out "%")) (set! i (+ i 2)) (loop)))
                          ((= spec "s")
                            (begin
                              (set! out (str out (lua-concat-coerce (nth vals vi))))
                              (set! vi (+ vi 1)) (set! i (+ i 2)) (loop)))
                          ((= spec "d")
                            (begin
                              (set! out (str out (lua-format-int (nth vals vi))))
                              (set! vi (+ vi 1)) (set! i (+ i 2)) (loop)))
                          ((= spec "f")
                            (begin
                              (set! out (str out (str (nth vals vi))))
                              (set! vi (+ vi 1)) (set! i (+ i 2)) (loop)))
                          (else
                            (begin (set! out (str out c)) (set! i (+ i 1)) (loop))))))
                    (else
                      (begin (set! out (str out c)) (set! i (+ i 1)) (loop))))))))
          (loop)
          out)))))

(dict-set! string "len" lua-string-len)
(dict-set! string "upper" lua-string-upper)
(dict-set! string "lower" lua-string-lower)
(dict-set! string "rep" lua-string-rep)
(dict-set! string "sub" lua-string-sub)
(dict-set! string "byte" lua-string-byte)
(dict-set! string "char" lua-string-char)
(dict-set! string "find" lua-string-find)
(dict-set! string "match" lua-string-match)
(dict-set! string "gmatch" lua-string-gmatch)
(dict-set! string "gsub" lua-string-gsub)
(dict-set! string "format" lua-string-format)
(define
  lua-string-reverse
  (fn (s)
    (let ((out ""))
      (begin
        (define
          rloop
          (fn (i)
            (when (>= i 0)
              (begin
                (set! out (str out (char-at s i)))
                (rloop (- i 1))))))
        (rloop (- (len s) 1))
        out))))
(dict-set! string "reverse" lua-string-reverse)

;; ── math library ──────────────────────────────────────────────
(define math {})

(define lua-math-pi 3.141592653589793)
(define lua-math-huge (/ 1.0 0.0))

(define lua-math-abs (fn (x) (abs x)))
(define lua-math-ceil (fn (x) (ceil x)))
(define lua-math-floor (fn (x) (floor x)))
(define lua-math-sqrt (fn (x) (sqrt x)))
(define lua-math-exp (fn (x) (exp x)))
(define lua-math-sin (fn (x) (sin x)))
(define lua-math-cos (fn (x) (cos x)))
(define lua-math-tan (fn (x) (tan x)))
(define lua-math-asin (fn (x) (asin x)))
(define lua-math-acos (fn (x) (acos x)))
(define lua-math-atan (fn (x) (atan x)))
(define lua-math-atan2 (fn (y x) (atan2 y x)))
(define lua-math-pow (fn (a b) (pow a b)))

(define lua-math-log
  (fn (&rest args)
    (cond
      ((= (len args) 1) (log (first args)))
      (else (/ (log (first args)) (log (nth args 1)))))))

(define lua-math-log10
  (fn (x) (/ (log x) (log 10))))

(define lua-math-deg (fn (x) (* x (/ 180 lua-math-pi))))
(define lua-math-rad (fn (x) (* x (/ lua-math-pi 180))))

(define lua-math-min
  (fn (&rest args)
    (cond
      ((= (len args) 0) (error "lua: min: no values"))
      ((= (len args) 1) (first args))
      (else
        (let ((m (first args)))
          (begin
            (define
              loop
              (fn (i)
                (when (< i (len args))
                  (begin
                    (when (< (nth args i) m) (set! m (nth args i)))
                    (loop (+ i 1))))))
            (loop 1)
            m))))))

(define lua-math-max
  (fn (&rest args)
    (cond
      ((= (len args) 0) (error "lua: max: no values"))
      ((= (len args) 1) (first args))
      (else
        (let ((m (first args)))
          (begin
            (define
              loop
              (fn (i)
                (when (< i (len args))
                  (begin
                    (when (> (nth args i) m) (set! m (nth args i)))
                    (loop (+ i 1))))))
            (loop 1)
            m))))))

(define lua-math-fmod
  (fn (a b) (- a (* b (if (> b 0) (floor (/ a b)) (ceil (/ a b)))))))

(define lua-math-modf
  (fn (x)
    (let ((i (if (>= x 0) (floor x) (ceil x))))
      (list (quote lua-multi) i (- x i)))))

(define __rand-scale 1048576)
(define lua-math-random
  (fn (&rest args)
    (cond
      ((= (len args) 0)
        (/ (random-int 0 (- __rand-scale 1)) (* 1.0 __rand-scale)))
      ((= (len args) 1) (random-int 1 (first args)))
      (else (random-int (first args) (nth args 1))))))

(define lua-math-randomseed (fn (s) nil))

(dict-set! math "pi" lua-math-pi)
(dict-set! math "huge" lua-math-huge)
(dict-set! math "abs" lua-math-abs)
(dict-set! math "ceil" lua-math-ceil)
(dict-set! math "floor" lua-math-floor)
(dict-set! math "sqrt" lua-math-sqrt)
(dict-set! math "exp" lua-math-exp)
(dict-set! math "log" lua-math-log)
(dict-set! math "log10" lua-math-log10)
(dict-set! math "pow" lua-math-pow)
(dict-set! math "sin" lua-math-sin)
(dict-set! math "cos" lua-math-cos)
(dict-set! math "tan" lua-math-tan)
(dict-set! math "asin" lua-math-asin)
(dict-set! math "acos" lua-math-acos)
(dict-set! math "atan" lua-math-atan)
(dict-set! math "atan2" lua-math-atan2)
(dict-set! math "deg" lua-math-deg)
(dict-set! math "rad" lua-math-rad)
(dict-set! math "min" lua-math-min)
(dict-set! math "max" lua-math-max)
(dict-set! math "fmod" lua-math-fmod)
(dict-set! math "modf" lua-math-modf)
(dict-set! math "random" lua-math-random)
(dict-set! math "randomseed" lua-math-randomseed)

;; ── table library ─────────────────────────────────────────────
(define table {})

(define
  lua-table-insert
  (fn (&rest args)
    (cond
      ((= (len args) 2)
        (let ((t (first args)) (v (nth args 1)))
          (let ((n (lua-len t)))
            (dict-set! t (str (+ n 1)) v))))
      ((= (len args) 3)
        (let ((t (first args)) (pos (nth args 1)) (v (nth args 2)))
          (let ((n (lua-len t)))
            (begin
              (define
                tbl-shift-up
                (fn (i)
                  (when (>= i pos)
                    (begin
                      (dict-set! t (str (+ i 1)) (get t (str i)))
                      (tbl-shift-up (- i 1))))))
              (tbl-shift-up n)
              (dict-set! t (str pos) v)))))
      (else (error "lua: table.insert: wrong args")))))

(define
  lua-table-remove
  (fn (&rest args)
    (let ((t (first args)))
      (let ((n (lua-len t)))
        (let ((pos (if (> (len args) 1) (nth args 1) n)))
          (cond
            ((<= n 0) nil)
            (else
              (let ((v (get t (str pos))))
                (begin
                  (define
                    tbl-shift-down
                    (fn (i)
                      (when (< i n)
                        (begin
                          (dict-set! t (str i) (get t (str (+ i 1))))
                          (tbl-shift-down (+ i 1))))))
                  (tbl-shift-down pos)
                  (dict-set! t (str n) nil)
                  v)))))))))

(define
  lua-table-concat
  (fn (&rest args)
    (let ((t (first args))
          (sep (if (> (len args) 1) (nth args 1) ""))
          (i (if (> (len args) 2) (nth args 2) 1))
          (j (if (> (len args) 3) (nth args 3) (lua-len (first args)))))
      (cond
        ((> i j) "")
        (else
          (let ((out (lua-concat-coerce (get t (str i)))))
            (begin
              (define
                loop
                (fn (k)
                  (when (<= k j)
                    (begin
                      (set! out (str out sep (lua-concat-coerce (get t (str k)))))
                      (loop (+ k 1))))))
              (loop (+ i 1))
              out)))))))

;; Simple insertion sort for tables
(define
  lua-table-sort
  (fn (&rest args)
    (let ((t (first args))
          (comp (if (> (len args) 1) (nth args 1) nil)))
      (let ((n (lua-len t)))
        (begin
          (define
            lt?
            (fn (a b)
              (cond
                ((= comp nil) (lua-lt a b))
                (else (lua-truthy? (lua-call comp a b))))))
          (define
            insert-sorted
            (fn (i)
              (when (> i 1)
                (let ((v (get t (str i))) (prev (get t (str (- i 1)))))
                  (when (lt? v prev)
                    (begin
                      (dict-set! t (str i) prev)
                      (dict-set! t (str (- i 1)) v)
                      (insert-sorted (- i 1))))))))
          (define
            outer
            (fn (i)
              (when (<= i n)
                (begin
                  (insert-sorted i)
                  (outer (+ i 1))))))
          (outer 2)
          nil)))))

(define
  lua-unpack
  (fn (&rest args)
    (let ((t (first args))
          (i (if (> (len args) 1) (nth args 1) 1))
          (j (if (> (len args) 2) (nth args 2) (lua-len (first args)))))
      (cond
        ((> i j) nil)
        (else
          (let ((out (list (quote lua-multi))))
            (begin
              (define
                loop
                (fn (k)
                  (when (<= k j)
                    (begin
                      (set! out (append out (list (get t (str k)))))
                      (loop (+ k 1))))))
              (loop i)
              out)))))))

(define
  lua-table-maxn
  (fn (t) (lua-len t)))

(dict-set! table "insert" lua-table-insert)
(dict-set! table "remove" lua-table-remove)
(dict-set! table "concat" lua-table-concat)
(dict-set! table "sort" lua-table-sort)
(dict-set! table "unpack" lua-unpack)
(dict-set! table "maxn" lua-table-maxn)
(dict-set! table "getn" lua-len)
(dict-set! table "setn" (fn (t n) nil))
(define
  lua-table-foreach
  (fn (t f)
    (let ((ks (keys t)))
      (begin
        (define
          tfl
          (fn (i)
            (when (< i (len ks))
              (let ((k (nth ks i)))
                (cond
                  ((= k "__meta") (tfl (+ i 1)))
                  (else
                    (let ((r (lua-call f (lua-key-to-value k) (get t k))))
                      (cond
                        ((lua-truthy? r) r)
                        (else (tfl (+ i 1))))))))))) 
        (tfl 0)
        nil))))
(dict-set! table "foreach" lua-table-foreach)
(define
  lua-table-foreachi
  (fn (t f)
    (let ((n (lua-len t)))
      (begin
        (define
          tfi
          (fn (i)
            (when (<= i n)
              (let ((r (lua-call f i (get t (str i)))))
                (cond
                  ((lua-truthy? r) r)
                  (else (tfi (+ i 1))))))))
        (tfi 1)
        nil))))
(dict-set! table "foreachi" lua-table-foreachi)

(define unpack lua-unpack)

;; ── io library (minimal stub — buffered; no real stdio) ───────
(define io {})
(define __io-buffer "")

(define
  lua-io-write
  (fn (&rest args)
    (begin
      (define
        loop
        (fn (i)
          (when (< i (len args))
            (begin
              (set! __io-buffer (str __io-buffer (lua-concat-coerce (nth args i))))
              (loop (+ i 1))))))
      (loop 0)
      io)))

(define
  lua-io-read
  (fn (&rest args) nil))

(define
  lua-io-open
  (fn (&rest args) nil))

(define
  lua-io-lines
  (fn (&rest args) (fn (&rest __) nil)))

(define
  lua-io-close
  (fn (&rest args) true))

(define
  lua-io-flush
  (fn (&rest args) nil))

(define
  lua-io-buffer
  (fn ()
    (let ((out __io-buffer))
      (begin
        (set! __io-buffer "")
        out))))

;; print(a, b, c) — args joined by tab, trailing newline
(define
  lua-print
  (fn (&rest args)
    (begin
      (define
        loop
        (fn (i)
          (when (< i (len args))
            (begin
              (when (> i 0) (set! __io-buffer (str __io-buffer "\t")))
              (set! __io-buffer (str __io-buffer (lua-to-display (nth args i))))
              (loop (+ i 1))))))
      (loop 0)
      (set! __io-buffer (str __io-buffer "\n"))
      nil)))

(define
  lua-to-display
  (fn (v)
    (cond
      ((= v nil) "nil")
      ((= v true) "true")
      ((= v false) "false")
      ((= (type-of v) "string") v)
      ((= (type-of v) "number") (str v))
      ((= (type-of v) "dict") (str "table"))
      ((or (= (type-of v) "function") (= (type-of v) "lambda")) "function")
      (else (str v)))))

(define
  lua-tostring
  (fn (v)
    (cond
      ((= (type-of v) "dict")
        (let ((m (lua-get-mm v "__tostring")))
          (cond
            ((not (= m nil)) (lua-first (m v)))
            (else (lua-to-display v)))))
      (else (lua-to-display v)))))

(define
  lua-tonumber
  (fn (&rest args)
    (let ((v (first args))
          (base (if (> (len args) 1) (nth args 1) nil)))
      (cond
        ((= (type-of v) "number") v)
        ((= (type-of v) "string") (lua-to-number v))
        (else nil)))))

(dict-set! io "write" lua-io-write)
(dict-set! io "read" lua-io-read)
(dict-set! io "open" lua-io-open)
(dict-set! io "lines" lua-io-lines)
(dict-set! io "close" lua-io-close)
(dict-set! io "flush" lua-io-flush)
(dict-set! io "__buffer" lua-io-buffer)

(define print lua-print)
(define tostring lua-tostring)
(define tonumber lua-tonumber)

;; ── os library (minimal stub — no real clock/filesystem) ──────
(define os {})
(define __os-counter 0)

(define
  lua-os-time
  (fn (&rest args)
    (begin
      (set! __os-counter (+ __os-counter 1))
      __os-counter)))

(define
  lua-os-clock
  (fn ()
    (/ __os-counter 1000)))

(define
  lua-os-difftime
  (fn (t2 t1) (- t2 t1)))

(define
  lua-os-date
  (fn (&rest args)
    (let ((fmt (if (> (len args) 0) (first args) "%c")))
      (cond
        ((= fmt "*t")
          (let ((d {}))
            (begin
              (dict-set! d "year" 1970)
              (dict-set! d "month" 1)
              (dict-set! d "day" 1)
              (dict-set! d "hour" 0)
              (dict-set! d "min" 0)
              (dict-set! d "sec" 0)
              (dict-set! d "wday" 5)
              (dict-set! d "yday" 1)
              (dict-set! d "isdst" false)
              d)))
        (else "1970-01-01 00:00:00")))))

(define
  lua-os-getenv
  (fn (name) nil))

(define
  lua-os-exit
  (fn (&rest args) (error "lua: os.exit called")))

(define
  lua-os-remove
  (fn (name)
    (list (quote lua-multi) nil "os.remove not supported")))

(define
  lua-os-rename
  (fn (a b)
    (list (quote lua-multi) nil "os.rename not supported")))

(define
  lua-os-tmpname
  (fn () "/tmp/lua_stub"))

(define
  lua-os-execute
  (fn (&rest args) 0))

(dict-set! os "time" lua-os-time)
(dict-set! os "clock" lua-os-clock)
(dict-set! os "difftime" lua-os-difftime)
(dict-set! os "date" lua-os-date)
(dict-set! os "getenv" lua-os-getenv)
(dict-set! os "exit" lua-os-exit)
(dict-set! os "remove" lua-os-remove)
(dict-set! os "rename" lua-os-rename)
(dict-set! os "tmpname" lua-os-tmpname)
(dict-set! os "execute" lua-os-execute)

;; ── package / require ─────────────────────────────────────────
(define package {})
(define __package-loaded {})
(define __package-preload {})

(dict-set! package "loaded" __package-loaded)
(dict-set! package "preload" __package-preload)
(dict-set! package "path" "?;?.lua")

(define
  lua-require
  (fn (name)
    (cond
      ((has-key? __package-loaded name) (get __package-loaded name))
      ((has-key? __package-preload name)
        (let ((loader (get __package-preload name)))
          (let ((m (lua-call loader name)))
            (let ((result (if (= m nil) true m)))
              (begin
                (dict-set! __package-loaded name result)
                result)))))
      (else (error (str "lua: module '" name "' not found"))))))

(define require lua-require)

;; ── raw operations + loadstring ───────────────────────────────
(define
  lua-rawget
  (fn (t k)
    (cond
      ((not (= (type-of t) "dict")) nil)
      ((has-key? t (str k)) (get t (str k)))
      (else nil))))

(define
  lua-rawset
  (fn (t k v)
    (begin (dict-set! t (str k) v) t)))

(define
  lua-rawequal
  (fn (a b)
    (cond
      ((and (= a nil) (= b nil)) true)
      ((or (= a nil) (= b nil)) false)
      ((and (= (type-of a) (type-of b)) (= a b)) true)
      (else false))))

(define
  lua-rawlen
  (fn (v)
    (cond
      ((= (type-of v) "string") (len v))
      ((= (type-of v) "dict")
        (let ((n 0))
          (begin
            (define
              rl-count
              (fn (i)
                (if (has-key? v (str i))
                    (begin (set! n i) (rl-count (+ i 1)))
                    n)))
            (rl-count 1)
            n)))
      (else 0))))

(define rawget lua-rawget)
(define rawset lua-rawset)
(define rawequal lua-rawequal)
(define rawlen lua-rawlen)

;; loadstring(src) returns a function that, when called, evaluates src.
(define
  lua-loadstring
  (fn (src)
    (fn (&rest args) (lua-eval-ast src))))

(define loadstring lua-loadstring)
(define load lua-loadstring)

;; select(n, ...) — Lua 5.1 built-in. select("#", ...) is arg count; select(i, ...) returns args from i on.
(define
  lua-select
  (fn (&rest args)
    (let ((n (first args)) (rest-args (rest args)))
      (cond
        ((= n "#") (len rest-args))
        ((= (type-of n) "number")
          (let ((i (- n 1)))
            (cond
              ((< i 0) (error "lua: bad argument to select"))
              ((>= i (len rest-args)) nil)
              (else
                (let ((out (list (quote lua-multi))))
                  (begin
                    (define
                      sel-loop
                      (fn (j)
                        (when (< j (len rest-args))
                          (begin
                            (set! out (append out (list (nth rest-args j))))
                            (sel-loop (+ j 1))))))
                    (sel-loop i)
                    out))))))
        (else (error "lua: bad argument to select"))))))

(define select lua-select)

;; assert(v, msg) — errors with msg if v is falsy.
(define
  lua-assert
  (fn (&rest args)
    (let ((v (first args)))
      (cond
        ((lua-truthy? v)
          (cond
            ((= (len args) 1) v)
            (else (cons (quote lua-multi) args))))
        (else
          (error (if (> (len args) 1) (nth args 1) "assertion failed!")))))))

(define assert lua-assert)

(define _G {})
(define _VERSION "Lua 5.1")

(define
  lua-varargs
  (fn (args skip)
    (cons (quote lua-multi) (lua-varargs-tail args skip))))

(define
  lua-varargs-tail
  (fn (args i)
    (if (>= i (len args))
        (list)
        (cons (nth args i) (lua-varargs-tail args (+ i 1))))))

;; preload standard libs in package.loaded
(dict-set! __package-loaded "string" string)
(dict-set! __package-loaded "math" math)
(dict-set! __package-loaded "table" table)
(dict-set! __package-loaded "io" io)
(dict-set! __package-loaded "os" os)
(dict-set! __package-loaded "coroutine" coroutine)
(dict-set! __package-loaded "package" package)
(dict-set! __package-loaded "_G" _G)

(define arg {})

;; preload debug stub
(define debug {})
(dict-set! debug "traceback" (fn (&rest args) (if (> (len args) 0) (first args) "")))
(dict-set! debug "getinfo" (fn (&rest args) {}))
(dict-set! debug "sethook" (fn (&rest args) nil))
(dict-set! debug "gethook" (fn () nil))
(dict-set! debug "getlocal" (fn (&rest args) nil))
(dict-set! debug "setlocal" (fn (&rest args) nil))
(dict-set! debug "getupvalue" (fn (&rest args) nil))
(dict-set! debug "setupvalue" (fn (&rest args) nil))
(dict-set! __package-loaded "debug" debug)

;; collectgarbage stubs + env stubs
(define
  lua-collectgarbage
  (fn (&rest args)
    (cond
      ((= (len args) 0) 0)
      ((= (first args) "count") 0)
      ((= (first args) "collect") 0)
      (else 0))))

(define collectgarbage lua-collectgarbage)

;; setfenv/getfenv — Lua 5.1 env manipulation. Stubs.
(define setfenv (fn (&rest args) (if (> (len args) 0) (first args) nil)))
(define getfenv (fn (&rest args) _G))

;; T — debug/testC placeholder for tests that check it conditionally
(define T nil)