From 235428628aed38e15b71ee93964b52437abdee97 Mon Sep 17 00:00:00 2001 From: giles Date: Thu, 5 Mar 2026 09:31:40 +0000 Subject: [PATCH 1/3] Add reference SX evaluator written in s-expressions MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Meta-circular evaluator: the SX language specifying its own semantics. A thin bootstrap compiler per target (JS, Python, Rust) reads these .sx files and emits a native evaluator. Files: - eval.sx: Core evaluator — type dispatch, special forms, TCO trampoline, lambda/component/macro invocation, higher-order forms - primitives.sx: Declarative specification of ~80 built-in pure functions - render.sx: Three rendering modes (DOM, HTML string, SX wire format) - parser.sx: Tokenizer, parser, and serializer specification Platform-specific concerns (DOM ops, async I/O, HTML emission) are declared as interfaces that each target implements. Co-Authored-By: Claude Opus 4.6 --- shared/sx/ref/eval.sx | 731 ++++++++++++++++++++++++++++++++++++ shared/sx/ref/parser.sx | 319 ++++++++++++++++ shared/sx/ref/primitives.sx | 428 +++++++++++++++++++++ shared/sx/ref/render.sx | 333 ++++++++++++++++ 4 files changed, 1811 insertions(+) create mode 100644 shared/sx/ref/eval.sx create mode 100644 shared/sx/ref/parser.sx create mode 100644 shared/sx/ref/primitives.sx create mode 100644 shared/sx/ref/render.sx diff --git a/shared/sx/ref/eval.sx b/shared/sx/ref/eval.sx new file mode 100644 index 0000000..018a621 --- /dev/null +++ b/shared/sx/ref/eval.sx @@ -0,0 +1,731 @@ +;; ========================================================================== +;; eval.sx — Reference SX evaluator written in SX +;; +;; This is the canonical specification of SX evaluation semantics. +;; A thin bootstrap compiler per target reads this file and emits +;; a native evaluator (JavaScript, Python, Rust, etc.). +;; +;; The evaluator is written in a restricted subset of SX: +;; - defcomp, define, defmacro, lambda/fn +;; - if, when, cond, case, let, do, and, or +;; - map, filter, reduce, some, every? +;; - Primitives: list ops, string ops, arithmetic, predicates +;; - quote, quasiquote/unquote/splice-unquote +;; - Pattern matching via (case (type-of expr) ...) +;; +;; Platform-specific concerns (DOM rendering, async I/O, HTML emission) +;; are declared as interfaces — each target provides its own adapter. +;; ========================================================================== + + +;; -------------------------------------------------------------------------- +;; 1. Types +;; -------------------------------------------------------------------------- +;; +;; The evaluator operates on these value types: +;; +;; number — integer or float +;; string — double-quoted text +;; boolean — true / false +;; nil — singleton null +;; symbol — unquoted identifier (e.g. div, ~card, map) +;; keyword — colon-prefixed key (e.g. :class, :id) +;; list — ordered sequence (also used as code) +;; dict — string-keyed hash map +;; lambda — closure: {params, body, closure-env, name?} +;; macro — AST transformer: {params, rest-param, body, closure-env} +;; component — UI component: {name, params, has-children, body, closure-env} +;; thunk — deferred eval for TCO: {expr, env} +;; +;; Each target must provide: +;; (type-of x) → one of the strings above +;; (make-lambda ...) → platform Lambda value +;; (make-component ..) → platform Component value +;; (make-macro ...) → platform Macro value +;; (make-thunk ...) → platform Thunk value +;; +;; These are declared in platform.sx and implemented per target. +;; -------------------------------------------------------------------------- + + +;; -------------------------------------------------------------------------- +;; 2. Trampoline — tail-call optimization +;; -------------------------------------------------------------------------- + +(define trampoline + (fn (val) + ;; Iteratively resolve thunks until we get an actual value. + ;; Each target implements thunk? and thunk-expr/thunk-env. + (let ((result val)) + (do + ;; Loop while result is a thunk + ;; Note: this is pseudo-iteration — bootstrap compilers convert + ;; this tail-recursive form to a while loop. + (if (thunk? result) + (trampoline (eval-expr (thunk-expr result) (thunk-env result))) + result))))) + + +;; -------------------------------------------------------------------------- +;; 3. Core evaluator +;; -------------------------------------------------------------------------- + +(define eval-expr + (fn (expr env) + (case (type-of expr) + + ;; --- literals pass through --- + "number" expr + "string" expr + "boolean" expr + "nil" nil + + ;; --- symbol lookup --- + "symbol" + (let ((name (symbol-name expr))) + (cond + (env-has? env name) (env-get env name) + (primitive? name) (get-primitive name) + (= name "true") true + (= name "false") false + (= name "nil") nil + :else (error (str "Undefined symbol: " name)))) + + ;; --- keyword → its string name --- + "keyword" (keyword-name expr) + + ;; --- dict literal --- + "dict" + (map-dict (fn (k v) (list k (trampoline (eval-expr v env)))) expr) + + ;; --- list = call or special form --- + "list" + (if (empty? expr) + (list) + (eval-list expr env)) + + ;; --- anything else passes through --- + :else expr))) + + +;; -------------------------------------------------------------------------- +;; 4. List evaluation — dispatch on head +;; -------------------------------------------------------------------------- + +(define eval-list + (fn (expr env) + (let ((head (first expr)) + (args (rest expr))) + + ;; If head isn't a symbol, lambda, or list → treat as data list + (if (not (or (= (type-of head) "symbol") + (= (type-of head) "lambda") + (= (type-of head) "list"))) + (map (fn (x) (trampoline (eval-expr x env))) expr) + + ;; Head is a symbol — check special forms, then function call + (if (= (type-of head) "symbol") + (let ((name (symbol-name head))) + (cond + ;; Special forms + (= name "if") (sf-if args env) + (= name "when") (sf-when args env) + (= name "cond") (sf-cond args env) + (= name "case") (sf-case args env) + (= name "and") (sf-and args env) + (= name "or") (sf-or args env) + (= name "let") (sf-let args env) + (= name "let*") (sf-let args env) + (= name "lambda") (sf-lambda args env) + (= name "fn") (sf-lambda args env) + (= name "define") (sf-define args env) + (= name "defcomp") (sf-defcomp args env) + (= name "defmacro") (sf-defmacro args env) + (= name "begin") (sf-begin args env) + (= name "do") (sf-begin args env) + (= name "quote") (sf-quote args env) + (= name "quasiquote") (sf-quasiquote args env) + (= name "->") (sf-thread-first args env) + (= name "set!") (sf-set! args env) + + ;; Higher-order forms + (= name "map") (ho-map args env) + (= name "map-indexed") (ho-map-indexed args env) + (= name "filter") (ho-filter args env) + (= name "reduce") (ho-reduce args env) + (= name "some") (ho-some args env) + (= name "every?") (ho-every args env) + (= name "for-each") (ho-for-each args env) + + ;; Macro expansion + (and (env-has? env name) (macro? (env-get env name))) + (let ((mac (env-get env name))) + (make-thunk (expand-macro mac args env) env)) + + ;; Fall through to function call + :else (eval-call head args env))) + + ;; Head is lambda or list — evaluate as function call + (eval-call head args env)))))) + + +;; -------------------------------------------------------------------------- +;; 5. Function / lambda / component call +;; -------------------------------------------------------------------------- + +(define eval-call + (fn (head args env) + (let ((f (trampoline (eval-expr head env))) + (evaluated-args (map (fn (a) (trampoline (eval-expr a env))) args))) + (cond + ;; Native callable (primitive function) + (and (callable? f) (not (lambda? f)) (not (component? f))) + (apply f evaluated-args) + + ;; Lambda + (lambda? f) + (call-lambda f evaluated-args env) + + ;; Component + (component? f) + (call-component f args env) + + :else (error (str "Not callable: " (inspect f))))))) + + +(define call-lambda + (fn (f args caller-env) + (let ((params (lambda-params f)) + (local (env-merge (lambda-closure f) caller-env))) + (if (!= (len args) (len params)) + (error (str (or (lambda-name f) "lambda") + " expects " (len params) " args, got " (len args))) + (do + ;; Bind params + (for-each + (fn (pair) (env-set! local (first pair) (nth pair 1))) + (zip params args)) + ;; Return thunk for TCO + (make-thunk (lambda-body f) local)))))) + + +(define call-component + (fn (comp raw-args env) + ;; Parse keyword args and children from unevaluated arg list + (let ((parsed (parse-keyword-args raw-args env)) + (kwargs (first parsed)) + (children (nth parsed 1)) + (local (env-merge (component-closure comp) env))) + ;; Bind keyword params + (for-each + (fn (p) (env-set! local p (or (dict-get kwargs p) nil))) + (component-params comp)) + ;; Bind children if component accepts them + (when (component-has-children? comp) + (env-set! local "children" children)) + ;; Return thunk — body evaluated in local env + (make-thunk (component-body comp) local)))) + + +(define parse-keyword-args + (fn (raw-args env) + ;; Walk args: keyword + next-val → kwargs dict, else → children list + (let ((kwargs (dict)) + (children (list)) + (i 0)) + ;; Iterative parse — bootstrap converts to while loop + (reduce + (fn (state arg) + (let ((idx (get state "i")) + (skip (get state "skip"))) + (if skip + ;; This arg was consumed as a keyword value + (assoc state "skip" false "i" (inc idx)) + (if (and (= (type-of arg) "keyword") + (< (inc idx) (len raw-args))) + ;; Keyword: evaluate next arg and store + (do + (dict-set! kwargs (keyword-name arg) + (trampoline (eval-expr (nth raw-args (inc idx)) env))) + (assoc state "skip" true "i" (inc idx))) + ;; Positional: evaluate and add to children + (do + (append! children (trampoline (eval-expr arg env))) + (assoc state "i" (inc idx))))))) + (dict "i" 0 "skip" false) + raw-args) + (list kwargs children)))) + + +;; -------------------------------------------------------------------------- +;; 6. Special forms +;; -------------------------------------------------------------------------- + +(define sf-if + (fn (args env) + (let ((condition (trampoline (eval-expr (first args) env)))) + (if (and condition (not (nil? condition))) + (make-thunk (nth args 1) env) + (if (> (len args) 2) + (make-thunk (nth args 2) env) + nil))))) + + +(define sf-when + (fn (args env) + (let ((condition (trampoline (eval-expr (first args) env)))) + (if (and condition (not (nil? condition))) + (do + ;; Evaluate all but last for side effects + (for-each + (fn (e) (trampoline (eval-expr e env))) + (slice args 1 (dec (len args)))) + ;; Last is tail position + (make-thunk (last args) env)) + nil)))) + + +(define sf-cond + (fn (args env) + ;; Detect scheme-style: first arg is a 2-element list + (if (and (= (type-of (first args)) "list") + (= (len (first args)) 2)) + ;; Scheme-style: ((test body) ...) + (sf-cond-scheme args env) + ;; Clojure-style: test body test body ... + (sf-cond-clojure args env)))) + +(define sf-cond-scheme + (fn (clauses env) + (if (empty? clauses) + nil + (let ((clause (first clauses)) + (test (first clause)) + (body (nth clause 1))) + (if (or (and (= (type-of test) "symbol") + (or (= (symbol-name test) "else") + (= (symbol-name test) ":else"))) + (and (= (type-of test) "keyword") + (= (keyword-name test) "else"))) + (make-thunk body env) + (if (trampoline (eval-expr test env)) + (make-thunk body env) + (sf-cond-scheme (rest clauses) env))))))) + +(define sf-cond-clojure + (fn (clauses env) + (if (< (len clauses) 2) + nil + (let ((test (first clauses)) + (body (nth clauses 1))) + (if (or (and (= (type-of test) "keyword") (= (keyword-name test) "else")) + (and (= (type-of test) "symbol") + (or (= (symbol-name test) "else") + (= (symbol-name test) ":else")))) + (make-thunk body env) + (if (trampoline (eval-expr test env)) + (make-thunk body env) + (sf-cond-clojure (slice clauses 2) env))))))) + + +(define sf-case + (fn (args env) + (let ((match-val (trampoline (eval-expr (first args) env))) + (clauses (rest args))) + (sf-case-loop match-val clauses env)))) + +(define sf-case-loop + (fn (match-val clauses env) + (if (< (len clauses) 2) + nil + (let ((test (first clauses)) + (body (nth clauses 1))) + (if (or (and (= (type-of test) "keyword") (= (keyword-name test) "else")) + (and (= (type-of test) "symbol") + (or (= (symbol-name test) "else") + (= (symbol-name test) ":else")))) + (make-thunk body env) + (if (= match-val (trampoline (eval-expr test env))) + (make-thunk body env) + (sf-case-loop match-val (slice clauses 2) env))))))) + + +(define sf-and + (fn (args env) + (if (empty? args) + true + (let ((val (trampoline (eval-expr (first args) env)))) + (if (not val) + val + (if (= (len args) 1) + val + (sf-and (rest args) env))))))) + + +(define sf-or + (fn (args env) + (if (empty? args) + false + (let ((val (trampoline (eval-expr (first args) env)))) + (if val + val + (sf-or (rest args) env)))))) + + +(define sf-let + (fn (args env) + (let ((bindings (first args)) + (body (rest args)) + (local (env-extend env))) + ;; Parse bindings — support both ((name val) ...) and (name val name val ...) + (if (and (= (type-of (first bindings)) "list") + (= (len (first bindings)) 2)) + ;; Scheme-style + (for-each + (fn (binding) + (let ((vname (if (= (type-of (first binding)) "symbol") + (symbol-name (first binding)) + (first binding)))) + (env-set! local vname (trampoline (eval-expr (nth binding 1) local))))) + bindings) + ;; Clojure-style + (let ((i 0)) + (reduce + (fn (acc pair-idx) + (let ((vname (if (= (type-of (nth bindings (* pair-idx 2))) "symbol") + (symbol-name (nth bindings (* pair-idx 2))) + (nth bindings (* pair-idx 2)))) + (val-expr (nth bindings (inc (* pair-idx 2))))) + (env-set! local vname (trampoline (eval-expr val-expr local))))) + nil + (range 0 (/ (len bindings) 2))))) + ;; Evaluate body — last expression in tail position + (for-each + (fn (e) (trampoline (eval-expr e local))) + (slice body 0 (dec (len body)))) + (make-thunk (last body) local)))) + + +(define sf-lambda + (fn (args env) + (let ((params-expr (first args)) + (body (nth args 1)) + (param-names (map (fn (p) + (if (= (type-of p) "symbol") + (symbol-name p) + p)) + params-expr))) + (make-lambda param-names body env)))) + + +(define sf-define + (fn (args env) + (let ((name-sym (first args)) + (value (trampoline (eval-expr (nth args 1) env)))) + (when (and (lambda? value) (nil? (lambda-name value))) + (set-lambda-name! value (symbol-name name-sym))) + (env-set! env (symbol-name name-sym) value) + value))) + + +(define sf-defcomp + (fn (args env) + (let ((name-sym (first args)) + (params-raw (nth args 1)) + (body (nth args 2)) + (comp-name (strip-prefix (symbol-name name-sym) "~")) + (parsed (parse-comp-params params-raw)) + (params (first parsed)) + (has-children (nth parsed 1))) + (let ((comp (make-component comp-name params has-children body env))) + (env-set! env (symbol-name name-sym) comp) + comp)))) + +(define parse-comp-params + (fn (params-expr) + ;; Parse (&key param1 param2 &rest children) → (params has-children) + (let ((params (list)) + (has-children false) + (in-key false)) + (for-each + (fn (p) + (when (= (type-of p) "symbol") + (let ((name (symbol-name p))) + (cond + (= name "&key") (set! in-key true) + (= name "&rest") (set! has-children true) + (and in-key (not has-children)) + (append! params name) + :else + (append! params name))))) + params-expr) + (list params has-children)))) + + +(define sf-defmacro + (fn (args env) + (let ((name-sym (first args)) + (params-raw (nth args 1)) + (body (nth args 2)) + (parsed (parse-macro-params params-raw)) + (params (first parsed)) + (rest-param (nth parsed 1))) + (let ((mac (make-macro params rest-param body env (symbol-name name-sym)))) + (env-set! env (symbol-name name-sym) mac) + mac)))) + +(define parse-macro-params + (fn (params-expr) + ;; Parse (a b &rest rest) → ((a b) rest) + (let ((params (list)) + (rest-param nil)) + (reduce + (fn (state p) + (if (and (= (type-of p) "symbol") (= (symbol-name p) "&rest")) + (assoc state "in-rest" true) + (if (get state "in-rest") + (do (set! rest-param (if (= (type-of p) "symbol") + (symbol-name p) p)) + state) + (do (append! params (if (= (type-of p) "symbol") + (symbol-name p) p)) + state)))) + (dict "in-rest" false) + params-expr) + (list params rest-param)))) + + +(define sf-begin + (fn (args env) + (if (empty? args) + nil + (do + (for-each + (fn (e) (trampoline (eval-expr e env))) + (slice args 0 (dec (len args)))) + (make-thunk (last args) env))))) + + +(define sf-quote + (fn (args env) + (if (empty? args) nil (first args)))) + + +(define sf-quasiquote + (fn (args env) + (qq-expand (first args) env))) + +(define qq-expand + (fn (template env) + (if (not (= (type-of template) "list")) + template + (if (empty? template) + (list) + (let ((head (first template))) + (if (and (= (type-of head) "symbol") (= (symbol-name head) "unquote")) + (trampoline (eval-expr (nth template 1) env)) + ;; Walk children, handling splice-unquote + (reduce + (fn (result item) + (if (and (= (type-of item) "list") + (= (len item) 2) + (= (type-of (first item)) "symbol") + (= (symbol-name (first item)) "splice-unquote")) + (let ((spliced (trampoline (eval-expr (nth item 1) env)))) + (if (= (type-of spliced) "list") + (concat result spliced) + (if (nil? spliced) result (append result spliced)))) + (append result (qq-expand item env)))) + (list) + template))))))) + + +(define sf-thread-first + (fn (args env) + (let ((val (trampoline (eval-expr (first args) env)))) + (reduce + (fn (result form) + (if (= (type-of form) "list") + (let ((f (trampoline (eval-expr (first form) env))) + (rest-args (map (fn (a) (trampoline (eval-expr a env))) + (rest form))) + (all-args (cons result rest-args))) + (cond + (and (callable? f) (not (lambda? f))) + (apply f all-args) + (lambda? f) + (trampoline (call-lambda f all-args env)) + :else (error (str "-> form not callable: " (inspect f))))) + (let ((f (trampoline (eval-expr form env)))) + (cond + (and (callable? f) (not (lambda? f))) + (f result) + (lambda? f) + (trampoline (call-lambda f (list result) env)) + :else (error (str "-> form not callable: " (inspect f))))))) + val + (rest args))))) + + +(define sf-set! + (fn (args env) + (let ((name (symbol-name (first args))) + (value (trampoline (eval-expr (nth args 1) env)))) + (env-set! env name value) + value))) + + +;; -------------------------------------------------------------------------- +;; 6b. Macro expansion +;; -------------------------------------------------------------------------- + +(define expand-macro + (fn (mac raw-args env) + (let ((local (env-merge (macro-closure mac) env))) + ;; Bind positional params (unevaluated) + (for-each + (fn (pair) + (env-set! local (first pair) + (if (< (nth pair 1) (len raw-args)) + (nth raw-args (nth pair 1)) + nil))) + (map-indexed (fn (i p) (list p i)) (macro-params mac))) + ;; Bind &rest param + (when (macro-rest-param mac) + (env-set! local (macro-rest-param mac) + (slice raw-args (len (macro-params mac))))) + ;; Evaluate body → new AST + (trampoline (eval-expr (macro-body mac) local))))) + + +;; -------------------------------------------------------------------------- +;; 7. Higher-order forms +;; -------------------------------------------------------------------------- + +(define ho-map + (fn (args env) + (let ((f (trampoline (eval-expr (first args) env))) + (coll (trampoline (eval-expr (nth args 1) env)))) + (map (fn (item) (trampoline (call-lambda f (list item) env))) coll)))) + +(define ho-map-indexed + (fn (args env) + (let ((f (trampoline (eval-expr (first args) env))) + (coll (trampoline (eval-expr (nth args 1) env)))) + (map-indexed + (fn (i item) (trampoline (call-lambda f (list i item) env))) + coll)))) + +(define ho-filter + (fn (args env) + (let ((f (trampoline (eval-expr (first args) env))) + (coll (trampoline (eval-expr (nth args 1) env)))) + (filter + (fn (item) (trampoline (call-lambda f (list item) env))) + coll)))) + +(define ho-reduce + (fn (args env) + (let ((f (trampoline (eval-expr (first args) env))) + (init (trampoline (eval-expr (nth args 1) env))) + (coll (trampoline (eval-expr (nth args 2) env)))) + (reduce + (fn (acc item) (trampoline (call-lambda f (list acc item) env))) + init + coll)))) + +(define ho-some + (fn (args env) + (let ((f (trampoline (eval-expr (first args) env))) + (coll (trampoline (eval-expr (nth args 1) env)))) + (some + (fn (item) (trampoline (call-lambda f (list item) env))) + coll)))) + +(define ho-every + (fn (args env) + (let ((f (trampoline (eval-expr (first args) env))) + (coll (trampoline (eval-expr (nth args 1) env)))) + (every? + (fn (item) (trampoline (call-lambda f (list item) env))) + coll)))) + + +;; -------------------------------------------------------------------------- +;; 8. Primitives — pure functions available in all targets +;; -------------------------------------------------------------------------- +;; These are the ~80 built-in functions. Each target implements them +;; natively but they MUST have identical semantics. This section serves +;; as the specification — bootstrap compilers use it for reference. +;; +;; Primitives are NOT defined here as SX lambdas (that would be circular). +;; Instead, this is a declarative registry that bootstrap compilers read. +;; -------------------------------------------------------------------------- + +;; See primitives.sx for the full specification. + + +;; -------------------------------------------------------------------------- +;; 9. Platform interface — must be provided by each target +;; -------------------------------------------------------------------------- +;; +;; Type inspection: +;; (type-of x) → "number" | "string" | "boolean" | "nil" +;; | "symbol" | "keyword" | "list" | "dict" +;; | "lambda" | "component" | "macro" | "thunk" +;; (symbol-name sym) → string +;; (keyword-name kw) → string +;; +;; Constructors: +;; (make-lambda params body env) → Lambda +;; (make-component name params has-children body env) → Component +;; (make-macro params rest-param body env name) → Macro +;; (make-thunk expr env) → Thunk +;; +;; Accessors: +;; (lambda-params f) → list of strings +;; (lambda-body f) → expr +;; (lambda-closure f) → env +;; (lambda-name f) → string or nil +;; (set-lambda-name! f n) → void +;; (component-params c) → list of strings +;; (component-body c) → expr +;; (component-closure c) → env +;; (component-has-children? c) → boolean +;; (macro-params m) → list of strings +;; (macro-rest-param m) → string or nil +;; (macro-body m) → expr +;; (macro-closure m) → env +;; (thunk? x) → boolean +;; (thunk-expr t) → expr +;; (thunk-env t) → env +;; +;; Predicates: +;; (callable? x) → boolean (native function or lambda) +;; (lambda? x) → boolean +;; (component? x) → boolean +;; (macro? x) → boolean +;; (primitive? name) → boolean (is name a registered primitive?) +;; (get-primitive name) → function +;; +;; Environment: +;; (env-has? env name) → boolean +;; (env-get env name) → value +;; (env-set! env name val) → void (mutating) +;; (env-extend env) → new env inheriting from env +;; (env-merge base overlay) → new env with overlay on top +;; +;; Mutation helpers (for parse-keyword-args): +;; (dict-set! d key val) → void +;; (dict-get d key) → value or nil +;; (append! lst val) → void (mutating append) +;; +;; Error: +;; (error msg) → raise/throw with message +;; (inspect x) → string representation for debugging +;; +;; Utility: +;; (strip-prefix s prefix) → string with prefix removed (or s unchanged) +;; (apply f args) → call f with args list +;; (zip lists...) → list of tuples +;; -------------------------------------------------------------------------- diff --git a/shared/sx/ref/parser.sx b/shared/sx/ref/parser.sx new file mode 100644 index 0000000..3ed6d17 --- /dev/null +++ b/shared/sx/ref/parser.sx @@ -0,0 +1,319 @@ +;; ========================================================================== +;; parser.sx — Reference SX parser specification +;; +;; Defines how SX source text is tokenized and parsed into AST. +;; The parser is intentionally simple — s-expressions need minimal parsing. +;; +;; Grammar: +;; program → expr* +;; expr → atom | list | quote-sugar +;; list → '(' expr* ')' +;; atom → string | number | keyword | symbol | boolean | nil +;; string → '"' (char | escape)* '"' +;; number → '-'? digit+ ('.' digit+)? ([eE] [+-]? digit+)? +;; keyword → ':' ident +;; symbol → ident +;; boolean → 'true' | 'false' +;; nil → 'nil' +;; ident → [a-zA-Z_~*+\-><=/!?&] [a-zA-Z0-9_~*+\-><=/!?.:&]* +;; comment → ';' to end of line (discarded) +;; +;; Quote sugar (optional — not used in current SX): +;; '(expr) → (quote expr) +;; `(expr) → (quasiquote expr) +;; ~(expr) → (unquote expr) +;; ~@(expr) → (splice-unquote expr) +;; ========================================================================== + + +;; -------------------------------------------------------------------------- +;; Tokenizer +;; -------------------------------------------------------------------------- +;; Produces a flat stream of tokens from source text. +;; Each token is a (type value line col) tuple. + +(define tokenize + (fn (source) + (let ((pos 0) + (line 1) + (col 1) + (tokens (list)) + (len-src (len source))) + ;; Main loop — bootstrap compilers convert to while + (define scan-next + (fn () + (when (< pos len-src) + (let ((ch (nth source pos))) + (cond + ;; Whitespace — skip + (whitespace? ch) + (do (advance-pos!) (scan-next)) + + ;; Comment — skip to end of line + (= ch ";") + (do (skip-to-eol!) (scan-next)) + + ;; String + (= ch "\"") + (do (append! tokens (scan-string)) (scan-next)) + + ;; Open paren + (= ch "(") + (do (append! tokens (list "lparen" "(" line col)) + (advance-pos!) + (scan-next)) + + ;; Close paren + (= ch ")") + (do (append! tokens (list "rparen" ")" line col)) + (advance-pos!) + (scan-next)) + + ;; Open bracket (list sugar) + (= ch "[") + (do (append! tokens (list "lbracket" "[" line col)) + (advance-pos!) + (scan-next)) + + ;; Close bracket + (= ch "]") + (do (append! tokens (list "rbracket" "]" line col)) + (advance-pos!) + (scan-next)) + + ;; Keyword + (= ch ":") + (do (append! tokens (scan-keyword)) (scan-next)) + + ;; Number (or negative number) + (or (digit? ch) + (and (= ch "-") (< (inc pos) len-src) + (digit? (nth source (inc pos))))) + (do (append! tokens (scan-number)) (scan-next)) + + ;; Symbol + (ident-start? ch) + (do (append! tokens (scan-symbol)) (scan-next)) + + ;; Unknown — skip + :else + (do (advance-pos!) (scan-next))))))) + (scan-next) + tokens))) + + +;; -------------------------------------------------------------------------- +;; Token scanners (pseudo-code — each target implements natively) +;; -------------------------------------------------------------------------- + +(define scan-string + (fn () + ;; Scan from opening " to closing ", handling escape sequences. + ;; Returns ("string" value line col). + ;; Escape sequences: \" \\ \n \t \r + (let ((start-line line) + (start-col col) + (result "")) + (advance-pos!) ;; skip opening " + (define scan-str-loop + (fn () + (if (>= pos (len source)) + (error "Unterminated string") + (let ((ch (nth source pos))) + (cond + (= ch "\"") + (do (advance-pos!) nil) ;; done + (= ch "\\") + (do (advance-pos!) + (let ((esc (nth source pos))) + (set! result (str result + (case esc + "n" "\n" + "t" "\t" + "r" "\r" + :else esc))) + (advance-pos!) + (scan-str-loop))) + :else + (do (set! result (str result ch)) + (advance-pos!) + (scan-str-loop))))))) + (scan-str-loop) + (list "string" result start-line start-col)))) + + +(define scan-keyword + (fn () + ;; Scan :identifier + (let ((start-line line) (start-col col)) + (advance-pos!) ;; skip : + (let ((name (scan-ident-chars))) + (list "keyword" name start-line start-col))))) + + +(define scan-number + (fn () + ;; Scan integer or float literal + (let ((start-line line) (start-col col) (buf "")) + (when (= (nth source pos) "-") + (set! buf "-") + (advance-pos!)) + ;; Integer part + (define scan-digits + (fn () + (when (and (< pos (len source)) (digit? (nth source pos))) + (set! buf (str buf (nth source pos))) + (advance-pos!) + (scan-digits)))) + (scan-digits) + ;; Decimal part + (when (and (< pos (len source)) (= (nth source pos) ".")) + (set! buf (str buf ".")) + (advance-pos!) + (scan-digits)) + ;; Exponent + (when (and (< pos (len source)) + (or (= (nth source pos) "e") (= (nth source pos) "E"))) + (set! buf (str buf (nth source pos))) + (advance-pos!) + (when (and (< pos (len source)) + (or (= (nth source pos) "+") (= (nth source pos) "-"))) + (set! buf (str buf (nth source pos))) + (advance-pos!)) + (scan-digits)) + (list "number" (parse-number buf) start-line start-col)))) + + +(define scan-symbol + (fn () + ;; Scan identifier, check for true/false/nil + (let ((start-line line) + (start-col col) + (name (scan-ident-chars))) + (cond + (= name "true") (list "boolean" true start-line start-col) + (= name "false") (list "boolean" false start-line start-col) + (= name "nil") (list "nil" nil start-line start-col) + :else (list "symbol" name start-line start-col))))) + + +;; -------------------------------------------------------------------------- +;; Parser — tokens → AST +;; -------------------------------------------------------------------------- + +(define parse + (fn (tokens) + ;; Parse all top-level expressions from token stream. + (let ((pos 0) + (exprs (list))) + (define parse-loop + (fn () + (when (< pos (len tokens)) + (let ((result (parse-expr tokens))) + (append! exprs result) + (parse-loop))))) + (parse-loop) + exprs))) + + +(define parse-expr + (fn (tokens) + ;; Parse a single expression. + (let ((tok (nth tokens pos))) + (case (first tok) ;; token type + "lparen" + (do (set! pos (inc pos)) + (parse-list tokens "rparen")) + + "lbracket" + (do (set! pos (inc pos)) + (parse-list tokens "rbracket")) + + "string" (do (set! pos (inc pos)) (nth tok 1)) + "number" (do (set! pos (inc pos)) (nth tok 1)) + "boolean" (do (set! pos (inc pos)) (nth tok 1)) + "nil" (do (set! pos (inc pos)) nil) + + "keyword" + (do (set! pos (inc pos)) + (make-keyword (nth tok 1))) + + "symbol" + (do (set! pos (inc pos)) + (make-symbol (nth tok 1))) + + :else (error (str "Unexpected token: " (inspect tok))))))) + + +(define parse-list + (fn (tokens close-type) + ;; Parse expressions until close-type token. + (let ((items (list))) + (define parse-list-loop + (fn () + (if (>= pos (len tokens)) + (error "Unterminated list") + (if (= (first (nth tokens pos)) close-type) + (do (set! pos (inc pos)) nil) ;; done + (do (append! items (parse-expr tokens)) + (parse-list-loop)))))) + (parse-list-loop) + items))) + + +;; -------------------------------------------------------------------------- +;; Serializer — AST → SX source text +;; -------------------------------------------------------------------------- + +(define serialize + (fn (val) + (case (type-of val) + "nil" "nil" + "boolean" (if val "true" "false") + "number" (str val) + "string" (str "\"" (escape-string val) "\"") + "symbol" (symbol-name val) + "keyword" (str ":" (keyword-name val)) + "list" (str "(" (join " " (map serialize val)) ")") + "dict" (serialize-dict val) + "sx-expr" (sx-expr-source val) + :else (str val)))) + + +(define serialize-dict + (fn (d) + (str "(dict " + (join " " + (reduce + (fn (acc key) + (concat acc (list (str ":" key) (serialize (dict-get d key))))) + (list) + (keys d))) + ")"))) + + +;; -------------------------------------------------------------------------- +;; Platform parser interface +;; -------------------------------------------------------------------------- +;; +;; Character classification: +;; (whitespace? ch) → boolean +;; (digit? ch) → boolean +;; (ident-start? ch) → boolean (letter, _, ~, *, +, -, etc.) +;; (ident-char? ch) → boolean (ident-start + digits, ., :) +;; +;; Constructors: +;; (make-symbol name) → Symbol value +;; (make-keyword name) → Keyword value +;; (parse-number s) → number (int or float from string) +;; +;; String utilities: +;; (escape-string s) → string with " and \ escaped +;; (sx-expr-source e) → unwrap SxExpr to its source string +;; +;; Cursor state (mutable — each target manages its own way): +;; pos, line, col — current position in source +;; (advance-pos!) → increment pos, update line/col +;; (skip-to-eol!) → advance past end of line +;; (scan-ident-chars) → consume and return identifier string +;; -------------------------------------------------------------------------- diff --git a/shared/sx/ref/primitives.sx b/shared/sx/ref/primitives.sx new file mode 100644 index 0000000..05a9a9e --- /dev/null +++ b/shared/sx/ref/primitives.sx @@ -0,0 +1,428 @@ +;; ========================================================================== +;; primitives.sx — Specification of all SX built-in pure functions +;; +;; Each entry declares: name, parameter signature, and semantics. +;; Bootstrap compilers implement these natively per target. +;; +;; This file is a SPECIFICATION, not executable code. The define-primitive +;; form is a declarative macro that bootstrap compilers consume to generate +;; native primitive registrations. +;; +;; Format: +;; (define-primitive "name" +;; :params (param1 param2 &rest rest) +;; :returns "type" +;; :doc "description" +;; :body (reference-implementation ...)) +;; +;; The :body is optional — when provided, it gives a reference +;; implementation in SX that bootstrap compilers MAY use for testing +;; or as a fallback. Most targets will implement natively for performance. +;; ========================================================================== + + +;; -------------------------------------------------------------------------- +;; Arithmetic +;; -------------------------------------------------------------------------- + +(define-primitive "+" + :params (&rest args) + :returns "number" + :doc "Sum all arguments." + :body (reduce (fn (a b) (native-add a b)) 0 args)) + +(define-primitive "-" + :params (a &rest b) + :returns "number" + :doc "Subtract. Unary: negate. Binary: a - b." + :body (if (empty? b) (native-neg a) (native-sub a (first b)))) + +(define-primitive "*" + :params (&rest args) + :returns "number" + :doc "Multiply all arguments." + :body (reduce (fn (a b) (native-mul a b)) 1 args)) + +(define-primitive "/" + :params (a b) + :returns "number" + :doc "Divide a by b." + :body (native-div a b)) + +(define-primitive "mod" + :params (a b) + :returns "number" + :doc "Modulo a % b." + :body (native-mod a b)) + +(define-primitive "sqrt" + :params (x) + :returns "number" + :doc "Square root.") + +(define-primitive "pow" + :params (x n) + :returns "number" + :doc "x raised to power n.") + +(define-primitive "abs" + :params (x) + :returns "number" + :doc "Absolute value.") + +(define-primitive "floor" + :params (x) + :returns "number" + :doc "Floor to integer.") + +(define-primitive "ceil" + :params (x) + :returns "number" + :doc "Ceiling to integer.") + +(define-primitive "round" + :params (x &rest ndigits) + :returns "number" + :doc "Round to ndigits decimal places (default 0).") + +(define-primitive "min" + :params (&rest args) + :returns "number" + :doc "Minimum. Single list arg or variadic.") + +(define-primitive "max" + :params (&rest args) + :returns "number" + :doc "Maximum. Single list arg or variadic.") + +(define-primitive "clamp" + :params (x lo hi) + :returns "number" + :doc "Clamp x to range [lo, hi]." + :body (max lo (min hi x))) + +(define-primitive "inc" + :params (n) + :returns "number" + :doc "Increment by 1." + :body (+ n 1)) + +(define-primitive "dec" + :params (n) + :returns "number" + :doc "Decrement by 1." + :body (- n 1)) + + +;; -------------------------------------------------------------------------- +;; Comparison +;; -------------------------------------------------------------------------- + +(define-primitive "=" + :params (a b) + :returns "boolean" + :doc "Equality (value equality, not identity).") + +(define-primitive "!=" + :params (a b) + :returns "boolean" + :doc "Inequality." + :body (not (= a b))) + +(define-primitive "<" + :params (a b) + :returns "boolean" + :doc "Less than.") + +(define-primitive ">" + :params (a b) + :returns "boolean" + :doc "Greater than.") + +(define-primitive "<=" + :params (a b) + :returns "boolean" + :doc "Less than or equal.") + +(define-primitive ">=" + :params (a b) + :returns "boolean" + :doc "Greater than or equal.") + + +;; -------------------------------------------------------------------------- +;; Predicates +;; -------------------------------------------------------------------------- + +(define-primitive "odd?" + :params (n) + :returns "boolean" + :doc "True if n is odd." + :body (= (mod n 2) 1)) + +(define-primitive "even?" + :params (n) + :returns "boolean" + :doc "True if n is even." + :body (= (mod n 2) 0)) + +(define-primitive "zero?" + :params (n) + :returns "boolean" + :doc "True if n is zero." + :body (= n 0)) + +(define-primitive "nil?" + :params (x) + :returns "boolean" + :doc "True if x is nil/null/None.") + +(define-primitive "number?" + :params (x) + :returns "boolean" + :doc "True if x is a number (int or float).") + +(define-primitive "string?" + :params (x) + :returns "boolean" + :doc "True if x is a string.") + +(define-primitive "list?" + :params (x) + :returns "boolean" + :doc "True if x is a list/array.") + +(define-primitive "dict?" + :params (x) + :returns "boolean" + :doc "True if x is a dict/map.") + +(define-primitive "empty?" + :params (coll) + :returns "boolean" + :doc "True if coll is nil or has length 0.") + +(define-primitive "contains?" + :params (coll key) + :returns "boolean" + :doc "True if coll contains key. Strings: substring check. Dicts: key check. Lists: membership.") + + +;; -------------------------------------------------------------------------- +;; Logic +;; -------------------------------------------------------------------------- + +(define-primitive "not" + :params (x) + :returns "boolean" + :doc "Logical negation. Note: and/or are special forms (short-circuit).") + + +;; -------------------------------------------------------------------------- +;; Strings +;; -------------------------------------------------------------------------- + +(define-primitive "str" + :params (&rest args) + :returns "string" + :doc "Concatenate all args as strings. nil → empty string, bool → true/false.") + +(define-primitive "concat" + :params (&rest colls) + :returns "list" + :doc "Concatenate multiple lists into one. Skips nil values.") + +(define-primitive "upper" + :params (s) + :returns "string" + :doc "Uppercase string.") + +(define-primitive "lower" + :params (s) + :returns "string" + :doc "Lowercase string.") + +(define-primitive "trim" + :params (s) + :returns "string" + :doc "Strip leading/trailing whitespace.") + +(define-primitive "split" + :params (s &rest sep) + :returns "list" + :doc "Split string by separator (default space).") + +(define-primitive "join" + :params (sep coll) + :returns "string" + :doc "Join collection items with separator string.") + +(define-primitive "replace" + :params (s old new) + :returns "string" + :doc "Replace all occurrences of old with new in s.") + +(define-primitive "slice" + :params (coll start &rest end) + :returns "any" + :doc "Slice a string or list from start to end (exclusive). End is optional.") + +(define-primitive "starts-with?" + :params (s prefix) + :returns "boolean" + :doc "True if string s starts with prefix.") + +(define-primitive "ends-with?" + :params (s suffix) + :returns "boolean" + :doc "True if string s ends with suffix.") + + +;; -------------------------------------------------------------------------- +;; Collections — construction +;; -------------------------------------------------------------------------- + +(define-primitive "list" + :params (&rest args) + :returns "list" + :doc "Create a list from arguments.") + +(define-primitive "dict" + :params (&rest pairs) + :returns "dict" + :doc "Create a dict from key/value pairs: (dict :a 1 :b 2).") + +(define-primitive "range" + :params (start end &rest step) + :returns "list" + :doc "Integer range [start, end) with optional step.") + + +;; -------------------------------------------------------------------------- +;; Collections — access +;; -------------------------------------------------------------------------- + +(define-primitive "get" + :params (coll key &rest default) + :returns "any" + :doc "Get value from dict by key, or list by index. Optional default.") + +(define-primitive "len" + :params (coll) + :returns "number" + :doc "Length of string, list, or dict.") + +(define-primitive "first" + :params (coll) + :returns "any" + :doc "First element, or nil if empty.") + +(define-primitive "last" + :params (coll) + :returns "any" + :doc "Last element, or nil if empty.") + +(define-primitive "rest" + :params (coll) + :returns "list" + :doc "All elements except the first.") + +(define-primitive "nth" + :params (coll n) + :returns "any" + :doc "Element at index n, or nil if out of bounds.") + +(define-primitive "cons" + :params (x coll) + :returns "list" + :doc "Prepend x to coll.") + +(define-primitive "append" + :params (coll x) + :returns "list" + :doc "Append x to end of coll (returns new list).") + +(define-primitive "chunk-every" + :params (coll n) + :returns "list" + :doc "Split coll into sub-lists of size n.") + +(define-primitive "zip-pairs" + :params (coll) + :returns "list" + :doc "Consecutive pairs: (1 2 3 4) → ((1 2) (2 3) (3 4)).") + + +;; -------------------------------------------------------------------------- +;; Collections — dict operations +;; -------------------------------------------------------------------------- + +(define-primitive "keys" + :params (d) + :returns "list" + :doc "List of dict keys.") + +(define-primitive "vals" + :params (d) + :returns "list" + :doc "List of dict values.") + +(define-primitive "merge" + :params (&rest dicts) + :returns "dict" + :doc "Merge dicts left to right. Later keys win. Skips nil.") + +(define-primitive "assoc" + :params (d &rest pairs) + :returns "dict" + :doc "Return new dict with key/value pairs added/overwritten.") + +(define-primitive "dissoc" + :params (d &rest keys) + :returns "dict" + :doc "Return new dict with keys removed.") + +(define-primitive "into" + :params (target coll) + :returns "any" + :doc "Pour coll into target. List target: convert to list. Dict target: convert pairs to dict.") + + +;; -------------------------------------------------------------------------- +;; Format helpers +;; -------------------------------------------------------------------------- + +(define-primitive "format-date" + :params (date-str fmt) + :returns "string" + :doc "Parse ISO date string and format with strftime-style format.") + +(define-primitive "format-decimal" + :params (val &rest places) + :returns "string" + :doc "Format number with fixed decimal places (default 2).") + +(define-primitive "parse-int" + :params (val &rest default) + :returns "number" + :doc "Parse string to integer with optional default on failure.") + + +;; -------------------------------------------------------------------------- +;; Text helpers +;; -------------------------------------------------------------------------- + +(define-primitive "pluralize" + :params (count &rest forms) + :returns "string" + :doc "Pluralize: (pluralize 1) → \"\", (pluralize 2) → \"s\". Or (pluralize n \"item\" \"items\").") + +(define-primitive "escape" + :params (s) + :returns "string" + :doc "HTML-escape a string (&, <, >, \", ').") + +(define-primitive "strip-tags" + :params (s) + :returns "string" + :doc "Remove HTML tags from string.") diff --git a/shared/sx/ref/render.sx b/shared/sx/ref/render.sx new file mode 100644 index 0000000..0e118bd --- /dev/null +++ b/shared/sx/ref/render.sx @@ -0,0 +1,333 @@ +;; ========================================================================== +;; render.sx — Reference rendering specification +;; +;; Defines how evaluated SX expressions become output (DOM nodes, HTML +;; strings, or SX wire format). Each target provides a renderer adapter +;; that implements the platform-specific output operations. +;; +;; Three rendering modes (matching the Python/JS implementations): +;; +;; 1. render-to-dom — produces DOM nodes (browser only) +;; 2. render-to-html — produces HTML string (server) +;; 3. render-to-sx — produces SX wire format (server → client) +;; +;; This file specifies the LOGIC of rendering. Platform-specific +;; operations are declared as interfaces at the bottom. +;; ========================================================================== + + +;; -------------------------------------------------------------------------- +;; HTML tag registry +;; -------------------------------------------------------------------------- +;; Tags known to the renderer. Unknown names are treated as function calls. +;; Void elements self-close (no children). Boolean attrs emit name only. + +(define HTML_TAGS + (list + ;; Document + "html" "head" "body" "title" "meta" "link" "script" "style" "noscript" + ;; Sections + "header" "nav" "main" "section" "article" "aside" "footer" + "h1" "h2" "h3" "h4" "h5" "h6" "hgroup" + ;; Block + "div" "p" "blockquote" "pre" "figure" "figcaption" "address" "details" "summary" + ;; Inline + "a" "span" "em" "strong" "small" "b" "i" "u" "s" "mark" "sub" "sup" + "abbr" "cite" "code" "time" "br" "wbr" "hr" + ;; Lists + "ul" "ol" "li" "dl" "dt" "dd" + ;; Tables + "table" "thead" "tbody" "tfoot" "tr" "th" "td" "caption" "colgroup" "col" + ;; Forms + "form" "input" "textarea" "select" "option" "optgroup" "button" "label" + "fieldset" "legend" "output" "datalist" + ;; Media + "img" "video" "audio" "source" "picture" "canvas" "iframe" + ;; SVG + "svg" "path" "circle" "rect" "line" "polyline" "polygon" "text" + "g" "defs" "use" "clipPath" "mask" "pattern" "linearGradient" + "radialGradient" "stop" "filter" "feGaussianBlur" "feOffset" + "feBlend" "feColorMatrix" "feComposite" "feMerge" "feMergeNode" + "animate" "animateTransform" "foreignObject" + ;; Other + "template" "slot" "dialog" "menu")) + +(define VOID_ELEMENTS + (list "area" "base" "br" "col" "embed" "hr" "img" "input" + "link" "meta" "param" "source" "track" "wbr")) + +(define BOOLEAN_ATTRS + (list "disabled" "checked" "selected" "readonly" "required" "hidden" + "autofocus" "autoplay" "controls" "loop" "muted" "defer" "async" + "novalidate" "formnovalidate" "multiple" "open" "allowfullscreen")) + + +;; -------------------------------------------------------------------------- +;; render-to-html — server-side HTML rendering +;; -------------------------------------------------------------------------- + +(define render-to-html + (fn (expr env) + (let ((result (trampoline (eval-expr expr env)))) + (render-value-to-html result env)))) + +(define render-value-to-html + (fn (val env) + (case (type-of val) + "nil" "" + "string" (escape-html val) + "number" (str val) + "boolean" (if val "true" "false") + "list" (render-list-to-html val env) + "raw-html" (raw-html-content val) + :else (escape-html (str val))))) + +(define render-list-to-html + (fn (expr env) + (if (empty? expr) + "" + (let ((head (first expr))) + (if (not (= (type-of head) "symbol")) + ;; Data list — render each item + (join "" (map (fn (x) (render-value-to-html x env)) expr)) + (let ((name (symbol-name head)) + (args (rest expr))) + (cond + ;; Fragment + (= name "<>") + (join "" (map (fn (x) (render-to-html x env)) args)) + + ;; Raw HTML passthrough + (= name "raw!") + (join "" (map (fn (x) (str (trampoline (eval-expr x env)))) args)) + + ;; HTML tag + (contains? HTML_TAGS name) + (render-html-element name args env) + + ;; Component call (~name) + (starts-with? name "~") + (let ((comp (env-get env name))) + (if (component? comp) + (render-to-html + (trampoline (call-component comp args env)) + env) + (error (str "Unknown component: " name)))) + + ;; Macro expansion + (and (env-has? env name) (macro? (env-get env name))) + (render-to-html + (trampoline + (eval-expr + (expand-macro (env-get env name) args env) + env)) + env) + + ;; Special form / function call — evaluate then render result + :else + (render-value-to-html + (trampoline (eval-expr expr env)) + env)))))))) + + +(define render-html-element + (fn (tag args env) + (let ((parsed (parse-element-args args env)) + (attrs (first parsed)) + (children (nth parsed 1)) + (is-void (contains? VOID_ELEMENTS tag))) + (str "<" tag + (render-attrs attrs) + (if is-void + " />" + (str ">" + (join "" (map (fn (c) (render-to-html c env)) children)) + "")))))) + + +(define parse-element-args + (fn (args env) + ;; Parse (:key val :key2 val2 child1 child2) into (attrs-dict children-list) + (let ((attrs (dict)) + (children (list))) + (reduce + (fn (state arg) + (let ((skip (get state "skip"))) + (if skip + (assoc state "skip" false) + (if (and (= (type-of arg) "keyword") + (< (inc (get state "i")) (len args))) + (let ((val (trampoline (eval-expr (nth args (inc (get state "i"))) env)))) + (dict-set! attrs (keyword-name arg) val) + (assoc state "skip" true "i" (inc (get state "i")))) + (do + (append! children arg) + (assoc state "i" (inc (get state "i")))))))) + (dict "i" 0 "skip" false) + args) + (list attrs children)))) + + +(define render-attrs + (fn (attrs) + (join "" + (map + (fn (key) + (let ((val (dict-get attrs key))) + (cond + ;; Boolean attrs + (and (contains? BOOLEAN_ATTRS key) val) + (str " " key) + (and (contains? BOOLEAN_ATTRS key) (not val)) + "" + ;; Nil values — skip + (nil? val) "" + ;; Normal attr + :else (str " " key "=\"" (escape-attr (str val)) "\"")))) + (keys attrs))))) + + +;; -------------------------------------------------------------------------- +;; render-to-sx — server-side SX wire format (for client rendering) +;; -------------------------------------------------------------------------- +;; This mode serializes the expression as SX source text. +;; Component calls are NOT expanded — they're sent to the client. +;; HTML tags are serialized as-is. Special forms are evaluated. + +(define render-to-sx + (fn (expr env) + (let ((result (aser expr env))) + (serialize result)))) + +(define aser + (fn (expr env) + ;; Evaluate for SX wire format — serialize rendering forms, + ;; evaluate control flow and function calls. + (case (type-of expr) + "number" expr + "string" expr + "boolean" expr + "nil" nil + + "symbol" + (let ((name (symbol-name expr))) + (cond + (env-has? env name) (env-get env name) + (primitive? name) (get-primitive name) + (= name "true") true + (= name "false") false + (= name "nil") nil + :else (error (str "Undefined symbol: " name)))) + + "keyword" (keyword-name expr) + + "list" + (if (empty? expr) + (list) + (aser-list expr env)) + + :else expr))) + + +(define aser-list + (fn (expr env) + (let ((head (first expr)) + (args (rest expr))) + (if (not (= (type-of head) "symbol")) + (map (fn (x) (aser x env)) expr) + (let ((name (symbol-name head))) + (cond + ;; Fragment — serialize children + (= name "<>") + (aser-fragment args env) + + ;; Component call — serialize WITHOUT expanding + (starts-with? name "~") + (aser-call name args env) + + ;; HTML tag — serialize + (contains? HTML_TAGS name) + (aser-call name args env) + + ;; Special/HO forms — evaluate (produces data) + (or (special-form? name) (ho-form? name)) + (aser-special name expr env) + + ;; Macro — expand then aser + (and (env-has? env name) (macro? (env-get env name))) + (aser (expand-macro (env-get env name) args env) env) + + ;; Function call — evaluate fully + :else + (let ((f (trampoline (eval-expr head env))) + (evaled-args (map (fn (a) (trampoline (eval-expr a env))) args))) + (cond + (and (callable? f) (not (lambda? f)) (not (component? f))) + (apply f evaled-args) + (lambda? f) + (trampoline (call-lambda f evaled-args env)) + (component? f) + (aser-call (str "~" (component-name f)) args env) + :else (error (str "Not callable: " (inspect f))))))))))) + + +(define aser-fragment + (fn (children env) + ;; Serialize (<> child1 child2 ...) to sx source string + (let ((parts (filter + (fn (x) (not (nil? x))) + (map (fn (c) (aser c env)) children)))) + (if (empty? parts) + "" + (str "(<> " (join " " (map serialize parts)) ")"))))) + + +(define aser-call + (fn (name args env) + ;; Serialize (name :key val child ...) — evaluate args but keep as sx + (let ((parts (list name))) + (reduce + (fn (state arg) + (let ((skip (get state "skip"))) + (if skip + (assoc state "skip" false) + (if (and (= (type-of arg) "keyword") + (< (inc (get state "i")) (len args))) + (let ((val (aser (nth args (inc (get state "i"))) env))) + (when (not (nil? val)) + (append! parts (str ":" (keyword-name arg))) + (append! parts (serialize val))) + (assoc state "skip" true "i" (inc (get state "i")))) + (let ((val (aser arg env))) + (when (not (nil? val)) + (append! parts (serialize val))) + (assoc state "i" (inc (get state "i")))))))) + (dict "i" 0 "skip" false) + args) + (str "(" (join " " parts) ")")))) + + +;; -------------------------------------------------------------------------- +;; Platform rendering interface +;; -------------------------------------------------------------------------- +;; +;; HTML rendering (server targets): +;; (escape-html s) → HTML-escaped string +;; (escape-attr s) → attribute-value-escaped string +;; (raw-html-content r) → unwrap RawHTML marker to string +;; +;; DOM rendering (browser target): +;; (create-element tag) → DOM Element +;; (create-text-node s) → DOM Text +;; (create-fragment) → DOM DocumentFragment +;; (set-attribute el k v) → void +;; (append-child parent c) → void +;; +;; Serialization: +;; (serialize val) → SX source string representation of val +;; +;; Form classification: +;; (special-form? name) → boolean +;; (ho-form? name) → boolean +;; (aser-special name expr env) → evaluate special/HO form through aser +;; -------------------------------------------------------------------------- From e1ae81f736366b4896a3eced32043cb3be1c9a7d Mon Sep 17 00:00:00 2001 From: giles Date: Thu, 5 Mar 2026 09:58:48 +0000 Subject: [PATCH 2/3] =?UTF-8?q?Add=20bootstrap=20compiler:=20reference=20S?= =?UTF-8?q?X=20spec=20=E2=86=92=20JavaScript?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit bootstrap_js.py reads the reference .sx specification (eval.sx, render.sx) and transpiles the defined evaluator functions into standalone JavaScript. The output sx-ref.js is a fully functional SX evaluator bootstrapped from the s-expression spec, comparable against the hand-written sx.js. Key features: - JSEmitter class transpiles SX AST → JS (fn→function, let→IIFE, cond→ternary, etc.) - Platform interface (types, env ops, primitives) implemented as native JS - Post-transpilation fixup wraps callLambda to handle both Lambda objects and primitives - 93/93 tests passing: arithmetic, strings, control flow, closures, HO forms, components, macros, threading, dict ops, predicates Fixed during development: - Bool before int isinstance check (Python bool is subclass of int) - SX NIL sentinel detection (not Python None) - Cond style detection (determine Scheme vs Clojure once, not per-pair) - Predicate null safety (x != null instead of x && to avoid 0-as-falsy in SX) Co-Authored-By: Claude Opus 4.6 --- shared/static/scripts/sx-ref.js | 949 +++++++++++++++++++++++++++ shared/sx/ref/bootstrap_js.py | 1070 +++++++++++++++++++++++++++++++ 2 files changed, 2019 insertions(+) create mode 100644 shared/static/scripts/sx-ref.js create mode 100644 shared/sx/ref/bootstrap_js.py diff --git a/shared/static/scripts/sx-ref.js b/shared/static/scripts/sx-ref.js new file mode 100644 index 0000000..324f0d9 --- /dev/null +++ b/shared/static/scripts/sx-ref.js @@ -0,0 +1,949 @@ +/** + * sx-ref.js — Generated from reference SX evaluator specification. + * + * Bootstrap-compiled from shared/sx/ref/{eval,render,primitives}.sx + * Compare against hand-written sx.js for correctness verification. + * + * DO NOT EDIT — regenerate with: python bootstrap_js.py + */ +;(function(global) { + "use strict"; + + // ========================================================================= + // Types + // ========================================================================= + + var NIL = Object.freeze({ _nil: true, toString: function() { return "nil"; } }); + + function isNil(x) { return x === NIL || x === null || x === undefined; } + function isSxTruthy(x) { return x !== false && !isNil(x); } + + function Symbol(name) { this.name = name; } + Symbol.prototype.toString = function() { return this.name; }; + Symbol.prototype._sym = true; + + function Keyword(name) { this.name = name; } + Keyword.prototype.toString = function() { return ":" + this.name; }; + Keyword.prototype._kw = true; + + function Lambda(params, body, closure, name) { + this.params = params; + this.body = body; + this.closure = closure || {}; + this.name = name || null; + } + Lambda.prototype._lambda = true; + + function Component(name, params, hasChildren, body, closure) { + this.name = name; + this.params = params; + this.hasChildren = hasChildren; + this.body = body; + this.closure = closure || {}; + } + Component.prototype._component = true; + + function Macro(params, restParam, body, closure, name) { + this.params = params; + this.restParam = restParam; + this.body = body; + this.closure = closure || {}; + this.name = name || null; + } + Macro.prototype._macro = true; + + function Thunk(expr, env) { this.expr = expr; this.env = env; } + Thunk.prototype._thunk = true; + + function RawHTML(html) { this.html = html; } + RawHTML.prototype._raw = true; + + function isSym(x) { return x != null && x._sym === true; } + function isKw(x) { return x != null && x._kw === true; } + + function merge() { + var out = {}; + for (var i = 0; i < arguments.length; i++) { + var d = arguments[i]; + if (d) for (var k in d) out[k] = d[k]; + } + return out; + } + + function sxOr() { + for (var i = 0; i < arguments.length; i++) { + if (isSxTruthy(arguments[i])) return arguments[i]; + } + return arguments.length ? arguments[arguments.length - 1] : false; + } + + // ========================================================================= + // Platform interface — JS implementation + // ========================================================================= + + function typeOf(x) { + if (isNil(x)) return "nil"; + if (typeof x === "number") return "number"; + if (typeof x === "string") return "string"; + if (typeof x === "boolean") return "boolean"; + if (x._sym) return "symbol"; + if (x._kw) return "keyword"; + if (x._thunk) return "thunk"; + if (x._lambda) return "lambda"; + if (x._component) return "component"; + if (x._macro) return "macro"; + if (x._raw) return "raw-html"; + if (Array.isArray(x)) return "list"; + if (typeof x === "object") return "dict"; + return "unknown"; + } + + function symbolName(s) { return s.name; } + function keywordName(k) { return k.name; } + function makeSymbol(n) { return new Symbol(n); } + function makeKeyword(n) { return new Keyword(n); } + + function makeLambda(params, body, env) { return new Lambda(params, body, merge(env)); } + function makeComponent(name, params, hasChildren, body, env) { + return new Component(name, params, hasChildren, body, merge(env)); + } + function makeMacro(params, restParam, body, env, name) { + return new Macro(params, restParam, body, merge(env), name); + } + function makeThunk(expr, env) { return new Thunk(expr, env); } + + function lambdaParams(f) { return f.params; } + function lambdaBody(f) { return f.body; } + function lambdaClosure(f) { return f.closure; } + function lambdaName(f) { return f.name; } + function setLambdaName(f, n) { f.name = n; } + + function componentParams(c) { return c.params; } + function componentBody(c) { return c.body; } + function componentClosure(c) { return c.closure; } + function componentHasChildren(c) { return c.hasChildren; } + function componentName(c) { return c.name; } + + function macroParams(m) { return m.params; } + function macroRestParam(m) { return m.restParam; } + function macroBody(m) { return m.body; } + function macroClosure(m) { return m.closure; } + + function isThunk(x) { return x != null && x._thunk === true; } + function thunkExpr(t) { return t.expr; } + function thunkEnv(t) { return t.env; } + + function isCallable(x) { return typeof x === "function" || (x != null && x._lambda === true); } + function isLambda(x) { return x != null && x._lambda === true; } + function isComponent(x) { return x != null && x._component === true; } + function isMacro(x) { return x != null && x._macro === true; } + + function envHas(env, name) { return name in env; } + function envGet(env, name) { return env[name]; } + function envSet(env, name, val) { env[name] = val; } + function envExtend(env) { return merge(env); } + function envMerge(base, overlay) { return merge(base, overlay); } + + function dictSet(d, k, v) { d[k] = v; } + function dictGet(d, k) { var v = d[k]; return v !== undefined ? v : NIL; } + + function stripPrefix(s, prefix) { + return s.indexOf(prefix) === 0 ? s.slice(prefix.length) : s; + } + + function error(msg) { throw new Error(msg); } + function inspect(x) { return JSON.stringify(x); } + + // ========================================================================= + // Primitives + // ========================================================================= + + var PRIMITIVES = {}; + + // Arithmetic + PRIMITIVES["+"] = function() { var s = 0; for (var i = 0; i < arguments.length; i++) s += arguments[i]; return s; }; + PRIMITIVES["-"] = function(a, b) { return arguments.length === 1 ? -a : a - b; }; + PRIMITIVES["*"] = function() { var s = 1; for (var i = 0; i < arguments.length; i++) s *= arguments[i]; return s; }; + PRIMITIVES["/"] = function(a, b) { return a / b; }; + PRIMITIVES["mod"] = function(a, b) { return a % b; }; + PRIMITIVES["inc"] = function(n) { return n + 1; }; + PRIMITIVES["dec"] = function(n) { return n - 1; }; + PRIMITIVES["abs"] = Math.abs; + PRIMITIVES["floor"] = Math.floor; + PRIMITIVES["ceil"] = Math.ceil; + PRIMITIVES["round"] = Math.round; + PRIMITIVES["min"] = Math.min; + PRIMITIVES["max"] = Math.max; + PRIMITIVES["sqrt"] = Math.sqrt; + PRIMITIVES["pow"] = Math.pow; + PRIMITIVES["clamp"] = function(x, lo, hi) { return Math.max(lo, Math.min(hi, x)); }; + + // Comparison + PRIMITIVES["="] = function(a, b) { return a == b; }; + PRIMITIVES["!="] = function(a, b) { return a != b; }; + PRIMITIVES["<"] = function(a, b) { return a < b; }; + PRIMITIVES[">"] = function(a, b) { return a > b; }; + PRIMITIVES["<="] = function(a, b) { return a <= b; }; + PRIMITIVES[">="] = function(a, b) { return a >= b; }; + + // Logic + PRIMITIVES["not"] = function(x) { return !isSxTruthy(x); }; + + // String + PRIMITIVES["str"] = function() { + var p = []; + for (var i = 0; i < arguments.length; i++) { + var v = arguments[i]; if (isNil(v)) continue; p.push(String(v)); + } + return p.join(""); + }; + PRIMITIVES["upper"] = function(s) { return String(s).toUpperCase(); }; + PRIMITIVES["lower"] = function(s) { return String(s).toLowerCase(); }; + PRIMITIVES["trim"] = function(s) { return String(s).trim(); }; + PRIMITIVES["split"] = function(s, sep) { return String(s).split(sep || " "); }; + PRIMITIVES["join"] = function(sep, coll) { return coll.join(sep); }; + PRIMITIVES["replace"] = function(s, old, nw) { return s.split(old).join(nw); }; + PRIMITIVES["starts-with?"] = function(s, p) { return String(s).indexOf(p) === 0; }; + PRIMITIVES["ends-with?"] = function(s, p) { var str = String(s); return str.indexOf(p, str.length - p.length) !== -1; }; + PRIMITIVES["slice"] = function(c, a, b) { return b !== undefined ? c.slice(a, b) : c.slice(a); }; + PRIMITIVES["concat"] = function() { + var out = []; + for (var i = 0; i < arguments.length; i++) if (arguments[i]) out = out.concat(arguments[i]); + return out; + }; + PRIMITIVES["strip-tags"] = function(s) { return String(s).replace(/<[^>]+>/g, ""); }; + + // Predicates + PRIMITIVES["nil?"] = isNil; + PRIMITIVES["number?"] = function(x) { return typeof x === "number"; }; + PRIMITIVES["string?"] = function(x) { return typeof x === "string"; }; + PRIMITIVES["list?"] = Array.isArray; + PRIMITIVES["dict?"] = function(x) { return x !== null && typeof x === "object" && !Array.isArray(x) && !x._sym && !x._kw; }; + PRIMITIVES["empty?"] = function(c) { return isNil(c) || (Array.isArray(c) ? c.length === 0 : typeof c === "string" ? c.length === 0 : Object.keys(c).length === 0); }; + PRIMITIVES["contains?"] = function(c, k) { + if (typeof c === "string") return c.indexOf(String(k)) !== -1; + if (Array.isArray(c)) return c.indexOf(k) !== -1; + return k in c; + }; + PRIMITIVES["odd?"] = function(n) { return n % 2 !== 0; }; + PRIMITIVES["even?"] = function(n) { return n % 2 === 0; }; + PRIMITIVES["zero?"] = function(n) { return n === 0; }; + + // Collections + PRIMITIVES["list"] = function() { return Array.prototype.slice.call(arguments); }; + PRIMITIVES["dict"] = function() { + var d = {}; + for (var i = 0; i < arguments.length - 1; i += 2) d[arguments[i]] = arguments[i + 1]; + return d; + }; + PRIMITIVES["range"] = function(a, b, step) { + var r = []; step = step || 1; + for (var i = a; step > 0 ? i < b : i > b; i += step) r.push(i); + return r; + }; + PRIMITIVES["get"] = function(c, k, def) { var v = (c && c[k]); return v !== undefined ? v : (def !== undefined ? def : NIL); }; + PRIMITIVES["len"] = function(c) { return Array.isArray(c) ? c.length : typeof c === "string" ? c.length : Object.keys(c).length; }; + PRIMITIVES["first"] = function(c) { return c && c.length > 0 ? c[0] : NIL; }; + PRIMITIVES["last"] = function(c) { return c && c.length > 0 ? c[c.length - 1] : NIL; }; + PRIMITIVES["rest"] = function(c) { return c ? c.slice(1) : []; }; + PRIMITIVES["nth"] = function(c, n) { return c && n >= 0 && n < c.length ? c[n] : NIL; }; + PRIMITIVES["cons"] = function(x, c) { return [x].concat(c || []); }; + PRIMITIVES["append"] = function(c, x) { return (c || []).concat([x]); }; + PRIMITIVES["keys"] = function(d) { return Object.keys(d || {}); }; + PRIMITIVES["vals"] = function(d) { var r = []; for (var k in d) r.push(d[k]); return r; }; + PRIMITIVES["merge"] = function() { + var out = {}; + for (var i = 0; i < arguments.length; i++) { var d = arguments[i]; if (d && !isNil(d)) for (var k in d) out[k] = d[k]; } + return out; + }; + PRIMITIVES["assoc"] = function(d) { + var out = {}; if (d && !isNil(d)) for (var k in d) out[k] = d[k]; + for (var i = 1; i < arguments.length - 1; i += 2) out[arguments[i]] = arguments[i + 1]; + return out; + }; + PRIMITIVES["dissoc"] = function(d) { + var out = {}; for (var k in d) out[k] = d[k]; + for (var i = 1; i < arguments.length; i++) delete out[arguments[i]]; + return out; + }; + PRIMITIVES["chunk-every"] = function(c, n) { + var r = []; for (var i = 0; i < c.length; i += n) r.push(c.slice(i, i + n)); return r; + }; + PRIMITIVES["zip-pairs"] = function(c) { + var r = []; for (var i = 0; i < c.length - 1; i++) r.push([c[i], c[i + 1]]); return r; + }; + PRIMITIVES["into"] = function(target, coll) { + if (Array.isArray(target)) return Array.isArray(coll) ? coll.slice() : Object.entries(coll); + var r = {}; for (var i = 0; i < coll.length; i++) { var p = coll[i]; if (Array.isArray(p) && p.length >= 2) r[p[0]] = p[1]; } + return r; + }; + + // Format + PRIMITIVES["format-decimal"] = function(v, p) { return Number(v).toFixed(p || 2); }; + PRIMITIVES["parse-int"] = function(v, d) { var n = parseInt(v, 10); return isNaN(n) ? (d || 0) : n; }; + PRIMITIVES["pluralize"] = function(n, s, p) { + if (s || (p && p !== "s")) return n == 1 ? (s || "") : (p || "s"); + return n == 1 ? "" : "s"; + }; + PRIMITIVES["escape"] = function(s) { + return String(s).replace(/&/g,"&").replace(//g,">").replace(/"/g,"""); + }; + + function isPrimitive(name) { return name in PRIMITIVES; } + function getPrimitive(name) { return PRIMITIVES[name]; } + + // Higher-order helpers used by the transpiled code + function map(fn, coll) { return coll.map(fn); } + function mapIndexed(fn, coll) { return coll.map(function(item, i) { return fn(i, item); }); } + function filter(fn, coll) { return coll.filter(function(x) { return isSxTruthy(fn(x)); }); } + function reduce(fn, init, coll) { + var acc = init; + for (var i = 0; i < coll.length; i++) acc = fn(acc, coll[i]); + return acc; + } + function some(fn, coll) { + for (var i = 0; i < coll.length; i++) { var r = fn(coll[i]); if (isSxTruthy(r)) return r; } + return NIL; + } + function forEach(fn, coll) { for (var i = 0; i < coll.length; i++) fn(coll[i]); return NIL; } + function mapDict(fn, d) { var r = {}; for (var k in d) r[k] = fn(k, d[k]); return r; } + + // List primitives used directly by transpiled code + var len = PRIMITIVES["len"]; + var first = PRIMITIVES["first"]; + var last = PRIMITIVES["last"]; + var rest = PRIMITIVES["rest"]; + var nth = PRIMITIVES["nth"]; + var cons = PRIMITIVES["cons"]; + var append = PRIMITIVES["append"]; + var isEmpty = PRIMITIVES["empty?"]; + var contains = PRIMITIVES["contains?"]; + var startsWith = PRIMITIVES["starts-with?"]; + var slice = PRIMITIVES["slice"]; + var concat = PRIMITIVES["concat"]; + var str = PRIMITIVES["str"]; + var join = PRIMITIVES["join"]; + var keys = PRIMITIVES["keys"]; + var get = PRIMITIVES["get"]; + var assoc = PRIMITIVES["assoc"]; + var range = PRIMITIVES["range"]; + function zip(a, b) { var r = []; for (var i = 0; i < Math.min(a.length, b.length); i++) r.push([a[i], b[i]]); return r; } + function append_b(arr, x) { arr.push(x); return arr; } + var apply = function(f, args) { return f.apply(null, args); }; + + // HTML rendering helpers + function escapeHtml(s) { + return String(s).replace(/&/g,"&").replace(//g,">").replace(/"/g,"""); + } + function escapeAttr(s) { return escapeHtml(s); } + function rawHtmlContent(r) { return r.html; } + + // Serializer + function serialize(val) { + if (isNil(val)) return "nil"; + if (typeof val === "boolean") return val ? "true" : "false"; + if (typeof val === "number") return String(val); + if (typeof val === "string") return '"' + val.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"'; + if (isSym(val)) return val.name; + if (isKw(val)) return ":" + val.name; + if (Array.isArray(val)) return "(" + val.map(serialize).join(" ") + ")"; + return String(val); + } + + function isSpecialForm(n) { return n in { + "if":1,"when":1,"cond":1,"case":1,"and":1,"or":1,"let":1,"let*":1, + "lambda":1,"fn":1,"define":1,"defcomp":1,"defmacro":1,"begin":1,"do":1, + "quote":1,"quasiquote":1,"->":1,"set!":1 + }; } + function isHoForm(n) { return n in { + "map":1,"map-indexed":1,"filter":1,"reduce":1,"some":1,"every?":1,"for-each":1 + }; } + + // === Transpiled from eval.sx === + + // trampoline + var trampoline = function(val) { return (function() { + var result = val; + return (isSxTruthy(isThunk(result)) ? trampoline(evalExpr(thunkExpr(result), thunkEnv(result))) : result); +})(); }; + + // eval-expr + var evalExpr = function(expr, env) { return (function() { var _m = typeOf(expr); if (_m == "number") return expr; if (_m == "string") return expr; if (_m == "boolean") return expr; if (_m == "nil") return NIL; if (_m == "symbol") return (function() { + var name = symbolName(expr); + return (isSxTruthy(envHas(env, name)) ? envGet(env, name) : (isSxTruthy(isPrimitive(name)) ? getPrimitive(name) : (isSxTruthy((name == "true")) ? true : (isSxTruthy((name == "false")) ? false : (isSxTruthy((name == "nil")) ? NIL : error((String("Undefined symbol: ") + String(name)))))))); +})(); if (_m == "keyword") return keywordName(expr); if (_m == "dict") return mapDict(function(k, v) { return [k, trampoline(evalExpr(v, env))]; }, expr); if (_m == "list") return (isSxTruthy(isEmpty(expr)) ? [] : evalList(expr, env)); return expr; })(); }; + + // eval-list + var evalList = function(expr, env) { return (function() { + var head = first(expr); + var args = rest(expr); + return (isSxTruthy(!sxOr((typeOf(head) == "symbol"), (typeOf(head) == "lambda"), (typeOf(head) == "list"))) ? map(function(x) { return trampoline(evalExpr(x, env)); }, expr) : (isSxTruthy((typeOf(head) == "symbol")) ? (function() { + var name = symbolName(head); + return (isSxTruthy((name == "if")) ? sfIf(args, env) : (isSxTruthy((name == "when")) ? sfWhen(args, env) : (isSxTruthy((name == "cond")) ? sfCond(args, env) : (isSxTruthy((name == "case")) ? sfCase(args, env) : (isSxTruthy((name == "and")) ? sfAnd(args, env) : (isSxTruthy((name == "or")) ? sfOr(args, env) : (isSxTruthy((name == "let")) ? sfLet(args, env) : (isSxTruthy((name == "let*")) ? sfLet(args, env) : (isSxTruthy((name == "lambda")) ? sfLambda(args, env) : (isSxTruthy((name == "fn")) ? sfLambda(args, env) : (isSxTruthy((name == "define")) ? sfDefine(args, env) : (isSxTruthy((name == "defcomp")) ? sfDefcomp(args, env) : (isSxTruthy((name == "defmacro")) ? sfDefmacro(args, env) : (isSxTruthy((name == "begin")) ? sfBegin(args, env) : (isSxTruthy((name == "do")) ? sfBegin(args, env) : (isSxTruthy((name == "quote")) ? sfQuote(args, env) : (isSxTruthy((name == "quasiquote")) ? sfQuasiquote(args, env) : (isSxTruthy((name == "->")) ? sfThreadFirst(args, env) : (isSxTruthy((name == "set!")) ? sfSetBang(args, env) : (isSxTruthy((name == "map")) ? hoMap(args, env) : (isSxTruthy((name == "map-indexed")) ? hoMapIndexed(args, env) : (isSxTruthy((name == "filter")) ? hoFilter(args, env) : (isSxTruthy((name == "reduce")) ? hoReduce(args, env) : (isSxTruthy((name == "some")) ? hoSome(args, env) : (isSxTruthy((name == "every?")) ? hoEvery(args, env) : (isSxTruthy((name == "for-each")) ? hoForEach(args, env) : (isSxTruthy((isSxTruthy(envHas(env, name)) && isMacro(envGet(env, name)))) ? (function() { + var mac = envGet(env, name); + return makeThunk(expandMacro(mac, args, env), env); +})() : evalCall(head, args, env)))))))))))))))))))))))))))); +})() : evalCall(head, args, env))); +})(); }; + + // eval-call + var evalCall = function(head, args, env) { return (function() { + var f = trampoline(evalExpr(head, env)); + var evaluatedArgs = map(function(a) { return trampoline(evalExpr(a, env)); }, args); + return (isSxTruthy((isSxTruthy(isCallable(f)) && isSxTruthy(!isLambda(f)) && !isComponent(f))) ? apply(f, evaluatedArgs) : (isSxTruthy(isLambda(f)) ? callLambda(f, evaluatedArgs, env) : (isSxTruthy(isComponent(f)) ? callComponent(f, args, env) : error((String("Not callable: ") + String(inspect(f))))))); +})(); }; + + // call-lambda + var callLambda = function(f, args, callerEnv) { return (function() { + var params = lambdaParams(f); + var local = envMerge(lambdaClosure(f), callerEnv); + return (isSxTruthy((len(args) != len(params))) ? error((String(sxOr(lambdaName(f), "lambda")) + String(" expects ") + String(len(params)) + String(" args, got ") + String(len(args)))) : (forEach(function(pair) { return envSet(local, first(pair), nth(pair, 1)); }, zip(params, args)), makeThunk(lambdaBody(f), local))); +})(); }; + + // call-component + var callComponent = function(comp, rawArgs, env) { return (function() { + var parsed = parseKeywordArgs(rawArgs, env); + var kwargs = first(parsed); + var children = nth(parsed, 1); + var local = envMerge(componentClosure(comp), env); + { var _c = componentParams(comp); for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; local[p] = sxOr(dictGet(kwargs, p), NIL); } } + if (isSxTruthy(componentHasChildren(comp))) { + local["children"] = children; +} + return makeThunk(componentBody(comp), local); +})(); }; + + // parse-keyword-args + var parseKeywordArgs = function(rawArgs, env) { return (function() { + var kwargs = {}; + var children = []; + var i = 0; + reduce(function(state, arg) { return (function() { + var idx = get(state, "i"); + var skip = get(state, "skip"); + return (isSxTruthy(skip) ? assoc(state, "skip", false, "i", (idx + 1)) : (isSxTruthy((isSxTruthy((typeOf(arg) == "keyword")) && ((idx + 1) < len(rawArgs)))) ? (dictSet(kwargs, keywordName(arg), trampoline(evalExpr(nth(rawArgs, (idx + 1)), env))), assoc(state, "skip", true, "i", (idx + 1))) : (append_b(children, trampoline(evalExpr(arg, env))), assoc(state, "i", (idx + 1))))); +})(); }, {["i"]: 0, ["skip"]: false}, rawArgs); + return [kwargs, children]; +})(); }; + + // sf-if + var sfIf = function(args, env) { return (function() { + var condition = trampoline(evalExpr(first(args), env)); + return (isSxTruthy((isSxTruthy(condition) && !isNil(condition))) ? makeThunk(nth(args, 1), env) : (isSxTruthy((len(args) > 2)) ? makeThunk(nth(args, 2), env) : NIL)); +})(); }; + + // sf-when + var sfWhen = function(args, env) { return (function() { + var condition = trampoline(evalExpr(first(args), env)); + return (isSxTruthy((isSxTruthy(condition) && !isNil(condition))) ? (forEach(function(e) { return trampoline(evalExpr(e, env)); }, slice(args, 1, (len(args) - 1))), makeThunk(last(args), env)) : NIL); +})(); }; + + // sf-cond + var sfCond = function(args, env) { return (isSxTruthy((isSxTruthy((typeOf(first(args)) == "list")) && (len(first(args)) == 2))) ? sfCondScheme(args, env) : sfCondClojure(args, env)); }; + + // sf-cond-scheme + var sfCondScheme = function(clauses, env) { return (isSxTruthy(isEmpty(clauses)) ? NIL : (function() { + var clause = first(clauses); + var test = first(clause); + var body = nth(clause, 1); + return (isSxTruthy(sxOr((isSxTruthy((typeOf(test) == "symbol")) && sxOr((symbolName(test) == "else"), (symbolName(test) == ":else"))), (isSxTruthy((typeOf(test) == "keyword")) && (keywordName(test) == "else")))) ? makeThunk(body, env) : (isSxTruthy(trampoline(evalExpr(test, env))) ? makeThunk(body, env) : sfCondScheme(rest(clauses), env))); +})()); }; + + // sf-cond-clojure + var sfCondClojure = function(clauses, env) { return (isSxTruthy((len(clauses) < 2)) ? NIL : (function() { + var test = first(clauses); + var body = nth(clauses, 1); + return (isSxTruthy(sxOr((isSxTruthy((typeOf(test) == "keyword")) && (keywordName(test) == "else")), (isSxTruthy((typeOf(test) == "symbol")) && sxOr((symbolName(test) == "else"), (symbolName(test) == ":else"))))) ? makeThunk(body, env) : (isSxTruthy(trampoline(evalExpr(test, env))) ? makeThunk(body, env) : sfCondClojure(slice(clauses, 2), env))); +})()); }; + + // sf-case + var sfCase = function(args, env) { return (function() { + var matchVal = trampoline(evalExpr(first(args), env)); + var clauses = rest(args); + return sfCaseLoop(matchVal, clauses, env); +})(); }; + + // sf-case-loop + var sfCaseLoop = function(matchVal, clauses, env) { return (isSxTruthy((len(clauses) < 2)) ? NIL : (function() { + var test = first(clauses); + var body = nth(clauses, 1); + return (isSxTruthy(sxOr((isSxTruthy((typeOf(test) == "keyword")) && (keywordName(test) == "else")), (isSxTruthy((typeOf(test) == "symbol")) && sxOr((symbolName(test) == "else"), (symbolName(test) == ":else"))))) ? makeThunk(body, env) : (isSxTruthy((matchVal == trampoline(evalExpr(test, env)))) ? makeThunk(body, env) : sfCaseLoop(matchVal, slice(clauses, 2), env))); +})()); }; + + // sf-and + var sfAnd = function(args, env) { return (isSxTruthy(isEmpty(args)) ? true : (function() { + var val = trampoline(evalExpr(first(args), env)); + return (isSxTruthy(!val) ? val : (isSxTruthy((len(args) == 1)) ? val : sfAnd(rest(args), env))); +})()); }; + + // sf-or + var sfOr = function(args, env) { return (isSxTruthy(isEmpty(args)) ? false : (function() { + var val = trampoline(evalExpr(first(args), env)); + return (isSxTruthy(val) ? val : sfOr(rest(args), env)); +})()); }; + + // sf-let + var sfLet = function(args, env) { return (function() { + var bindings = first(args); + var body = rest(args); + var local = envExtend(env); + (isSxTruthy((isSxTruthy((typeOf(first(bindings)) == "list")) && (len(first(bindings)) == 2))) ? forEach(function(binding) { return (function() { + var vname = (isSxTruthy((typeOf(first(binding)) == "symbol")) ? symbolName(first(binding)) : first(binding)); + return envSet(local, vname, trampoline(evalExpr(nth(binding, 1), local))); +})(); }, bindings) : (function() { + var i = 0; + return reduce(function(acc, pairIdx) { return (function() { + var vname = (isSxTruthy((typeOf(nth(bindings, (pairIdx * 2))) == "symbol")) ? symbolName(nth(bindings, (pairIdx * 2))) : nth(bindings, (pairIdx * 2))); + var valExpr = nth(bindings, ((pairIdx * 2) + 1)); + return envSet(local, vname, trampoline(evalExpr(valExpr, local))); +})(); }, NIL, range(0, (len(bindings) / 2))); +})()); + { var _c = slice(body, 0, (len(body) - 1)); for (var _i = 0; _i < _c.length; _i++) { var e = _c[_i]; trampoline(evalExpr(e, local)); } } + return makeThunk(last(body), local); +})(); }; + + // sf-lambda + var sfLambda = function(args, env) { return (function() { + var paramsExpr = first(args); + var body = nth(args, 1); + var paramNames = map(function(p) { return (isSxTruthy((typeOf(p) == "symbol")) ? symbolName(p) : p); }, paramsExpr); + return makeLambda(paramNames, body, env); +})(); }; + + // sf-define + var sfDefine = function(args, env) { return (function() { + var nameSym = first(args); + var value = trampoline(evalExpr(nth(args, 1), env)); + if (isSxTruthy((isSxTruthy(isLambda(value)) && isNil(lambdaName(value))))) { + value.name = symbolName(nameSym); +} + env[symbolName(nameSym)] = value; + return value; +})(); }; + + // sf-defcomp + var sfDefcomp = function(args, env) { return (function() { + var nameSym = first(args); + var paramsRaw = nth(args, 1); + var body = nth(args, 2); + var compName = stripPrefix(symbolName(nameSym), "~"); + var parsed = parseCompParams(paramsRaw); + var params = first(parsed); + var hasChildren = nth(parsed, 1); + return (function() { + var comp = makeComponent(compName, params, hasChildren, body, env); + env[symbolName(nameSym)] = comp; + return comp; +})(); +})(); }; + + // parse-comp-params + var parseCompParams = function(paramsExpr) { return (function() { + var params = []; + var hasChildren = false; + var inKey = false; + { var _c = paramsExpr; for (var _i = 0; _i < _c.length; _i++) { var p = _c[_i]; if (isSxTruthy((typeOf(p) == "symbol"))) { + (function() { + var name = symbolName(p); + return (isSxTruthy((name == "&key")) ? (inKey = true) : (isSxTruthy((name == "&rest")) ? (hasChildren = true) : (isSxTruthy((isSxTruthy(inKey) && !hasChildren)) ? append_b(params, name) : append_b(params, name)))); +})(); +} } } + return [params, hasChildren]; +})(); }; + + // sf-defmacro + var sfDefmacro = function(args, env) { return (function() { + var nameSym = first(args); + var paramsRaw = nth(args, 1); + var body = nth(args, 2); + var parsed = parseMacroParams(paramsRaw); + var params = first(parsed); + var restParam = nth(parsed, 1); + return (function() { + var mac = makeMacro(params, restParam, body, env, symbolName(nameSym)); + env[symbolName(nameSym)] = mac; + return mac; +})(); +})(); }; + + // parse-macro-params + var parseMacroParams = function(paramsExpr) { return (function() { + var params = []; + var restParam = NIL; + reduce(function(state, p) { return (isSxTruthy((isSxTruthy((typeOf(p) == "symbol")) && (symbolName(p) == "&rest"))) ? assoc(state, "in-rest", true) : (isSxTruthy(get(state, "in-rest")) ? ((restParam = (isSxTruthy((typeOf(p) == "symbol")) ? symbolName(p) : p)), state) : (append_b(params, (isSxTruthy((typeOf(p) == "symbol")) ? symbolName(p) : p)), state))); }, {["in-rest"]: false}, paramsExpr); + return [params, restParam]; +})(); }; + + // sf-begin + var sfBegin = function(args, env) { return (isSxTruthy(isEmpty(args)) ? NIL : (forEach(function(e) { return trampoline(evalExpr(e, env)); }, slice(args, 0, (len(args) - 1))), makeThunk(last(args), env))); }; + + // sf-quote + var sfQuote = function(args, env) { return (isSxTruthy(isEmpty(args)) ? NIL : first(args)); }; + + // sf-quasiquote + var sfQuasiquote = function(args, env) { return qqExpand(first(args), env); }; + + // qq-expand + var qqExpand = function(template, env) { return (isSxTruthy(!(typeOf(template) == "list")) ? template : (isSxTruthy(isEmpty(template)) ? [] : (function() { + var head = first(template); + return (isSxTruthy((isSxTruthy((typeOf(head) == "symbol")) && (symbolName(head) == "unquote"))) ? trampoline(evalExpr(nth(template, 1), env)) : reduce(function(result, item) { return (isSxTruthy((isSxTruthy((typeOf(item) == "list")) && isSxTruthy((len(item) == 2)) && isSxTruthy((typeOf(first(item)) == "symbol")) && (symbolName(first(item)) == "splice-unquote"))) ? (function() { + var spliced = trampoline(evalExpr(nth(item, 1), env)); + return (isSxTruthy((typeOf(spliced) == "list")) ? concat(result, spliced) : (isSxTruthy(isNil(spliced)) ? result : append(result, spliced))); +})() : append(result, qqExpand(item, env))); }, [], template)); +})())); }; + + // sf-thread-first + var sfThreadFirst = function(args, env) { return (function() { + var val = trampoline(evalExpr(first(args), env)); + return reduce(function(result, form) { return (isSxTruthy((typeOf(form) == "list")) ? (function() { + var f = trampoline(evalExpr(first(form), env)); + var restArgs = map(function(a) { return trampoline(evalExpr(a, env)); }, rest(form)); + var allArgs = cons(result, restArgs); + return (isSxTruthy((isSxTruthy(isCallable(f)) && !isLambda(f))) ? apply(f, allArgs) : (isSxTruthy(isLambda(f)) ? trampoline(callLambda(f, allArgs, env)) : error((String("-> form not callable: ") + String(inspect(f)))))); +})() : (function() { + var f = trampoline(evalExpr(form, env)); + return (isSxTruthy((isSxTruthy(isCallable(f)) && !isLambda(f))) ? f(result) : (isSxTruthy(isLambda(f)) ? trampoline(callLambda(f, [result], env)) : error((String("-> form not callable: ") + String(inspect(f)))))); +})()); }, val, rest(args)); +})(); }; + + // sf-set! + var sfSetBang = function(args, env) { return (function() { + var name = symbolName(first(args)); + var value = trampoline(evalExpr(nth(args, 1), env)); + env[name] = value; + return value; +})(); }; + + // expand-macro + var expandMacro = function(mac, rawArgs, env) { return (function() { + var local = envMerge(macroClosure(mac), env); + { var _c = mapIndexed(function(i, p) { return [p, i]; }, macroParams(mac)); for (var _i = 0; _i < _c.length; _i++) { var pair = _c[_i]; local[first(pair)] = (isSxTruthy((nth(pair, 1) < len(rawArgs))) ? nth(rawArgs, nth(pair, 1)) : NIL); } } + if (isSxTruthy(macroRestParam(mac))) { + local[macroRestParam(mac)] = slice(rawArgs, len(macroParams(mac))); +} + return trampoline(evalExpr(macroBody(mac), local)); +})(); }; + + // ho-map + var hoMap = function(args, env) { return (function() { + var f = trampoline(evalExpr(first(args), env)); + var coll = trampoline(evalExpr(nth(args, 1), env)); + return map(function(item) { return trampoline(callLambda(f, [item], env)); }, coll); +})(); }; + + // ho-map-indexed + var hoMapIndexed = function(args, env) { return (function() { + var f = trampoline(evalExpr(first(args), env)); + var coll = trampoline(evalExpr(nth(args, 1), env)); + return mapIndexed(function(i, item) { return trampoline(callLambda(f, [i, item], env)); }, coll); +})(); }; + + // ho-filter + var hoFilter = function(args, env) { return (function() { + var f = trampoline(evalExpr(first(args), env)); + var coll = trampoline(evalExpr(nth(args, 1), env)); + return filter(function(item) { return trampoline(callLambda(f, [item], env)); }, coll); +})(); }; + + // ho-reduce + var hoReduce = function(args, env) { return (function() { + var f = trampoline(evalExpr(first(args), env)); + var init = trampoline(evalExpr(nth(args, 1), env)); + var coll = trampoline(evalExpr(nth(args, 2), env)); + return reduce(function(acc, item) { return trampoline(callLambda(f, [acc, item], env)); }, init, coll); +})(); }; + + // ho-some + var hoSome = function(args, env) { return (function() { + var f = trampoline(evalExpr(first(args), env)); + var coll = trampoline(evalExpr(nth(args, 1), env)); + return some(function(item) { return trampoline(callLambda(f, [item], env)); }, coll); +})(); }; + + // ho-every + var hoEvery = function(args, env) { return (function() { + var f = trampoline(evalExpr(first(args), env)); + var coll = trampoline(evalExpr(nth(args, 1), env)); + return isEvery(function(item) { return trampoline(callLambda(f, [item], env)); }, coll); +})(); }; + + + // === Transpiled from render.sx === + + // HTML_TAGS + var HTML_TAGS = ["html", "head", "body", "title", "meta", "link", "script", "style", "noscript", "header", "nav", "main", "section", "article", "aside", "footer", "h1", "h2", "h3", "h4", "h5", "h6", "hgroup", "div", "p", "blockquote", "pre", "figure", "figcaption", "address", "details", "summary", "a", "span", "em", "strong", "small", "b", "i", "u", "s", "mark", "sub", "sup", "abbr", "cite", "code", "time", "br", "wbr", "hr", "ul", "ol", "li", "dl", "dt", "dd", "table", "thead", "tbody", "tfoot", "tr", "th", "td", "caption", "colgroup", "col", "form", "input", "textarea", "select", "option", "optgroup", "button", "label", "fieldset", "legend", "output", "datalist", "img", "video", "audio", "source", "picture", "canvas", "iframe", "svg", "path", "circle", "rect", "line", "polyline", "polygon", "text", "g", "defs", "use", "clipPath", "mask", "pattern", "linearGradient", "radialGradient", "stop", "filter", "feGaussianBlur", "feOffset", "feBlend", "feColorMatrix", "feComposite", "feMerge", "feMergeNode", "animate", "animateTransform", "foreignObject", "template", "slot", "dialog", "menu"]; + + // VOID_ELEMENTS + var VOID_ELEMENTS = ["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]; + + // BOOLEAN_ATTRS + var BOOLEAN_ATTRS = ["disabled", "checked", "selected", "readonly", "required", "hidden", "autofocus", "autoplay", "controls", "loop", "muted", "defer", "async", "novalidate", "formnovalidate", "multiple", "open", "allowfullscreen"]; + + // render-to-html + var renderToHtml = function(expr, env) { return (function() { + var result = trampoline(evalExpr(expr, env)); + return renderValueToHtml(result, env); +})(); }; + + // render-value-to-html + var renderValueToHtml = function(val, env) { return (function() { var _m = typeOf(val); if (_m == "nil") return ""; if (_m == "string") return escapeHtml(val); if (_m == "number") return (String(val)); if (_m == "boolean") return (isSxTruthy(val) ? "true" : "false"); if (_m == "list") return renderListToHtml(val, env); if (_m == "raw-html") return rawHtmlContent(val); return escapeHtml((String(val))); })(); }; + + // render-list-to-html + var renderListToHtml = function(expr, env) { return (isSxTruthy(isEmpty(expr)) ? "" : (function() { + var head = first(expr); + return (isSxTruthy(!(typeOf(head) == "symbol")) ? join("", map(function(x) { return renderValueToHtml(x, env); }, expr)) : (function() { + var name = symbolName(head); + var args = rest(expr); + return (isSxTruthy((name == "<>")) ? join("", map(function(x) { return renderToHtml(x, env); }, args)) : (isSxTruthy((name == "raw!")) ? join("", map(function(x) { return (String(trampoline(evalExpr(x, env)))); }, args)) : (isSxTruthy(contains(HTML_TAGS, name)) ? renderHtmlElement(name, args, env) : (isSxTruthy(startsWith(name, "~")) ? (function() { + var comp = envGet(env, name); + return (isSxTruthy(isComponent(comp)) ? renderToHtml(trampoline(callComponent(comp, args, env)), env) : error((String("Unknown component: ") + String(name)))); +})() : (isSxTruthy((isSxTruthy(envHas(env, name)) && isMacro(envGet(env, name)))) ? renderToHtml(trampoline(evalExpr(expandMacro(envGet(env, name), args, env), env)), env) : renderValueToHtml(trampoline(evalExpr(expr, env)), env)))))); +})()); +})()); }; + + // render-html-element + var renderHtmlElement = function(tag, args, env) { return (function() { + var parsed = parseElementArgs(args, env); + var attrs = first(parsed); + var children = nth(parsed, 1); + var isVoid = contains(VOID_ELEMENTS, tag); + return (String("<") + String(tag) + String(renderAttrs(attrs)) + String((isSxTruthy(isVoid) ? " />" : (String(">") + String(join("", map(function(c) { return renderToHtml(c, env); }, children))) + String(""))))); +})(); }; + + // parse-element-args + var parseElementArgs = function(args, env) { return (function() { + var attrs = {}; + var children = []; + reduce(function(state, arg) { return (function() { + var skip = get(state, "skip"); + return (isSxTruthy(skip) ? assoc(state, "skip", false) : (isSxTruthy((isSxTruthy((typeOf(arg) == "keyword")) && ((get(state, "i") + 1) < len(args)))) ? (function() { + var val = trampoline(evalExpr(nth(args, (get(state, "i") + 1)), env)); + attrs[keywordName(arg)] = val; + return assoc(state, "skip", true, "i", (get(state, "i") + 1)); +})() : (append_b(children, arg), assoc(state, "i", (get(state, "i") + 1))))); +})(); }, {["i"]: 0, ["skip"]: false}, args); + return [attrs, children]; +})(); }; + + // render-attrs + var renderAttrs = function(attrs) { return join("", map(function(key) { return (function() { + var val = dictGet(attrs, key); + return (isSxTruthy((isSxTruthy(contains(BOOLEAN_ATTRS, key)) && val)) ? (String(" ") + String(key)) : (isSxTruthy((isSxTruthy(contains(BOOLEAN_ATTRS, key)) && !val)) ? "" : (isSxTruthy(isNil(val)) ? "" : (String(" ") + String(key) + String("=\"") + String(escapeAttr((String(val)))) + String("\""))))); +})(); }, keys(attrs))); }; + + // render-to-sx + var renderToSx = function(expr, env) { return (function() { + var result = aser(expr, env); + return serialize(result); +})(); }; + + // aser + var aser = function(expr, env) { return (function() { var _m = typeOf(expr); if (_m == "number") return expr; if (_m == "string") return expr; if (_m == "boolean") return expr; if (_m == "nil") return NIL; if (_m == "symbol") return (function() { + var name = symbolName(expr); + return (isSxTruthy(envHas(env, name)) ? envGet(env, name) : (isSxTruthy(isPrimitive(name)) ? getPrimitive(name) : (isSxTruthy((name == "true")) ? true : (isSxTruthy((name == "false")) ? false : (isSxTruthy((name == "nil")) ? NIL : error((String("Undefined symbol: ") + String(name)))))))); +})(); if (_m == "keyword") return keywordName(expr); if (_m == "list") return (isSxTruthy(isEmpty(expr)) ? [] : aserList(expr, env)); return expr; })(); }; + + // aser-list + var aserList = function(expr, env) { return (function() { + var head = first(expr); + var args = rest(expr); + return (isSxTruthy(!(typeOf(head) == "symbol")) ? map(function(x) { return aser(x, env); }, expr) : (function() { + var name = symbolName(head); + return (isSxTruthy((name == "<>")) ? aserFragment(args, env) : (isSxTruthy(startsWith(name, "~")) ? aserCall(name, args, env) : (isSxTruthy(contains(HTML_TAGS, name)) ? aserCall(name, args, env) : (isSxTruthy(sxOr(isSpecialForm(name), isHoForm(name))) ? aserSpecial(name, expr, env) : (isSxTruthy((isSxTruthy(envHas(env, name)) && isMacro(envGet(env, name)))) ? aser(expandMacro(envGet(env, name), args, env), env) : (function() { + var f = trampoline(evalExpr(head, env)); + var evaledArgs = map(function(a) { return trampoline(evalExpr(a, env)); }, args); + return (isSxTruthy((isSxTruthy(isCallable(f)) && isSxTruthy(!isLambda(f)) && !isComponent(f))) ? apply(f, evaledArgs) : (isSxTruthy(isLambda(f)) ? trampoline(callLambda(f, evaledArgs, env)) : (isSxTruthy(isComponent(f)) ? aserCall((String("~") + String(componentName(f))), args, env) : error((String("Not callable: ") + String(inspect(f))))))); +})()))))); +})()); +})(); }; + + // aser-fragment + var aserFragment = function(children, env) { return (function() { + var parts = filter(function(x) { return !isNil(x); }, map(function(c) { return aser(c, env); }, children)); + return (isSxTruthy(isEmpty(parts)) ? "" : (String("(<> ") + String(join(" ", map(serialize, parts))) + String(")"))); +})(); }; + + // aser-call + var aserCall = function(name, args, env) { return (function() { + var parts = [name]; + reduce(function(state, arg) { return (function() { + var skip = get(state, "skip"); + return (isSxTruthy(skip) ? assoc(state, "skip", false) : (isSxTruthy((isSxTruthy((typeOf(arg) == "keyword")) && ((get(state, "i") + 1) < len(args)))) ? (function() { + var val = aser(nth(args, (get(state, "i") + 1)), env); + if (isSxTruthy(!isNil(val))) { + parts.push((String(":") + String(keywordName(arg)))); + parts.push(serialize(val)); +} + return assoc(state, "skip", true, "i", (get(state, "i") + 1)); +})() : (function() { + var val = aser(arg, env); + if (isSxTruthy(!isNil(val))) { + parts.push(serialize(val)); +} + return assoc(state, "i", (get(state, "i") + 1)); +})())); +})(); }, {["i"]: 0, ["skip"]: false}, args); + return (String("(") + String(join(" ", parts)) + String(")")); +})(); }; + + + // ========================================================================= + // Post-transpilation fixups + // ========================================================================= + // The reference spec's call-lambda only handles Lambda objects, but HO forms + // (map, reduce, etc.) may receive native primitives. Wrap to handle both. + var _rawCallLambda = callLambda; + callLambda = function(f, args, callerEnv) { + if (typeof f === "function") return f.apply(null, args); + return _rawCallLambda(f, args, callerEnv); + }; + + // ========================================================================= + // Parser (reused from reference — hand-written for bootstrap simplicity) + // ========================================================================= + + // The parser is the one piece we keep as hand-written JS since the + // reference parser.sx is more of a spec than directly compilable code + // (it uses mutable cursor state that doesn't map cleanly to the + // transpiler's functional output). A future version could bootstrap + // the parser too. + + function parse(text) { + var pos = 0; + function skipWs() { + while (pos < text.length) { + var ch = text[pos]; + if (ch === " " || ch === "\t" || ch === "\n" || ch === "\r") { pos++; continue; } + if (ch === ";") { while (pos < text.length && text[pos] !== "\n") pos++; continue; } + break; + } + } + function readExpr() { + skipWs(); + if (pos >= text.length) return undefined; + var ch = text[pos]; + if (ch === "(") { pos++; return readList(")"); } + if (ch === "[") { pos++; return readList("]"); } + if (ch === '"') return readString(); + if (ch === ":") return readKeyword(); + if (ch === "-" && pos + 1 < text.length && text[pos + 1] >= "0" && text[pos + 1] <= "9") return readNumber(); + if (ch >= "0" && ch <= "9") return readNumber(); + return readSymbol(); + } + function readList(close) { + var items = []; + while (true) { + skipWs(); + if (pos >= text.length) throw new Error("Unterminated list"); + if (text[pos] === close) { pos++; return items; } + items.push(readExpr()); + } + } + function readString() { + pos++; // skip " + var s = ""; + while (pos < text.length) { + var ch = text[pos]; + if (ch === '"') { pos++; return s; } + if (ch === "\\") { pos++; var esc = text[pos]; s += esc === "n" ? "\n" : esc === "t" ? "\t" : esc === "r" ? "\r" : esc; pos++; continue; } + s += ch; pos++; + } + throw new Error("Unterminated string"); + } + function readKeyword() { + pos++; // skip : + var name = readIdent(); + return new Keyword(name); + } + function readNumber() { + var start = pos; + if (text[pos] === "-") pos++; + while (pos < text.length && text[pos] >= "0" && text[pos] <= "9") pos++; + if (pos < text.length && text[pos] === ".") { pos++; while (pos < text.length && text[pos] >= "0" && text[pos] <= "9") pos++; } + if (pos < text.length && (text[pos] === "e" || text[pos] === "E")) { + pos++; + if (pos < text.length && (text[pos] === "+" || text[pos] === "-")) pos++; + while (pos < text.length && text[pos] >= "0" && text[pos] <= "9") pos++; + } + return Number(text.slice(start, pos)); + } + function readIdent() { + var start = pos; + while (pos < text.length && /[a-zA-Z0-9_~*+\-><=/!?.:&]/.test(text[pos])) pos++; + return text.slice(start, pos); + } + function readSymbol() { + var name = readIdent(); + if (name === "true") return true; + if (name === "false") return false; + if (name === "nil") return NIL; + return new Symbol(name); + } + var exprs = []; + while (true) { + skipWs(); + if (pos >= text.length) break; + exprs.push(readExpr()); + } + return exprs; + } + + // ========================================================================= + // Public API + // ========================================================================= + + var componentEnv = {}; + + function loadComponents(source) { + var exprs = parse(source); + for (var i = 0; i < exprs.length; i++) { + trampoline(evalExpr(exprs[i], componentEnv)); + } + } + + function render(source) { + var exprs = parse(source); + var frag = document.createDocumentFragment(); + for (var i = 0; i < exprs.length; i++) { + var result = trampoline(evalExpr(exprs[i], merge(componentEnv))); + appendToDOM(frag, result, merge(componentEnv)); + } + return frag; + } + + function appendToDOM(parent, val, env) { + if (isNil(val)) return; + if (typeof val === "string") { parent.appendChild(document.createTextNode(val)); return; } + if (typeof val === "number") { parent.appendChild(document.createTextNode(String(val))); return; } + if (val._raw) { var t = document.createElement("template"); t.innerHTML = val.html; parent.appendChild(t.content); return; } + if (Array.isArray(val)) { + // Could be a rendered element or a list of results + if (val.length > 0 && isSym(val[0])) { + // It's an unevaluated expression — evaluate it + var result = trampoline(evalExpr(val, env)); + appendToDOM(parent, result, env); + } else { + for (var i = 0; i < val.length; i++) appendToDOM(parent, val[i], env); + } + return; + } + parent.appendChild(document.createTextNode(String(val))); + } + + var SxRef = { + parse: parse, + eval: function(expr, env) { return trampoline(evalExpr(expr, env || merge(componentEnv))); }, + loadComponents: loadComponents, + render: render, + serialize: serialize, + NIL: NIL, + Symbol: Symbol, + Keyword: Keyword, + componentEnv: componentEnv, + _version: "ref-1.0 (bootstrap-compiled)" + }; + + if (typeof module !== "undefined" && module.exports) module.exports = SxRef; + else global.SxRef = SxRef; + +})(typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : this); diff --git a/shared/sx/ref/bootstrap_js.py b/shared/sx/ref/bootstrap_js.py new file mode 100644 index 0000000..5e9583c --- /dev/null +++ b/shared/sx/ref/bootstrap_js.py @@ -0,0 +1,1070 @@ +#!/usr/bin/env python3 +""" +Bootstrap compiler: reference SX evaluator → JavaScript. + +Reads the .sx reference specification and emits a standalone JavaScript +evaluator (sx-ref.js) that can be compared against the hand-written sx.js. + +The compiler translates the restricted SX subset used in eval.sx/render.sx +into idiomatic JavaScript. Platform interface functions are emitted as +native JS implementations. + +Usage: + python bootstrap_js.py > sx-ref.js +""" +from __future__ import annotations + +import os +import sys + +# Add project root to path for imports +_HERE = os.path.dirname(os.path.abspath(__file__)) +_PROJECT = os.path.abspath(os.path.join(_HERE, "..", "..", "..")) +sys.path.insert(0, _PROJECT) + +from shared.sx.parser import parse_all +from shared.sx.types import Symbol, Keyword, NIL as SX_NIL + +# --------------------------------------------------------------------------- +# SX → JavaScript transpiler +# --------------------------------------------------------------------------- + +class JSEmitter: + """Transpile an SX AST node to JavaScript source code.""" + + def __init__(self): + self.indent = 0 + + def emit(self, expr) -> str: + """Emit a JS expression from an SX AST node.""" + # Bool MUST be checked before int (bool is subclass of int in Python) + if isinstance(expr, bool): + return "true" if expr else "false" + if isinstance(expr, (int, float)): + return str(expr) + if isinstance(expr, str): + return self._js_string(expr) + if expr is None or expr is SX_NIL: + return "NIL" + if isinstance(expr, Symbol): + return self._emit_symbol(expr.name) + if isinstance(expr, Keyword): + return self._js_string(expr.name) + if isinstance(expr, list): + return self._emit_list(expr) + return str(expr) + + def emit_statement(self, expr) -> str: + """Emit a JS statement (with semicolon) from an SX AST node.""" + if isinstance(expr, list) and expr: + head = expr[0] + if isinstance(head, Symbol): + name = head.name + if name == "define": + return self._emit_define(expr) + if name == "set!": + return f"{self._mangle(expr[1].name)} = {self.emit(expr[2])};" + if name == "when": + return self._emit_when_stmt(expr) + if name == "do" or name == "begin": + return "\n".join(self.emit_statement(e) for e in expr[1:]) + if name == "for-each": + return self._emit_for_each_stmt(expr) + if name == "dict-set!": + return f"{self.emit(expr[1])}[{self.emit(expr[2])}] = {self.emit(expr[3])};" + if name == "append!": + return f"{self.emit(expr[1])}.push({self.emit(expr[2])});" + if name == "env-set!": + return f"{self.emit(expr[1])}[{self.emit(expr[2])}] = {self.emit(expr[3])};" + if name == "set-lambda-name!": + return f"{self.emit(expr[1])}.name = {self.emit(expr[2])};" + return f"{self.emit(expr)};" + + # --- Symbol emission --- + + def _emit_symbol(self, name: str) -> str: + # Map SX names to JS names + return self._mangle(name) + + def _mangle(self, name: str) -> str: + """Convert SX identifier to valid JS identifier.""" + RENAMES = { + "nil": "NIL", + "true": "true", + "false": "false", + "nil?": "isNil", + "type-of": "typeOf", + "symbol-name": "symbolName", + "keyword-name": "keywordName", + "make-lambda": "makeLambda", + "make-component": "makeComponent", + "make-macro": "makeMacro", + "make-thunk": "makeThunk", + "make-symbol": "makeSymbol", + "make-keyword": "makeKeyword", + "lambda-params": "lambdaParams", + "lambda-body": "lambdaBody", + "lambda-closure": "lambdaClosure", + "lambda-name": "lambdaName", + "set-lambda-name!": "setLambdaName", + "component-params": "componentParams", + "component-body": "componentBody", + "component-closure": "componentClosure", + "component-has-children?": "componentHasChildren", + "component-name": "componentName", + "macro-params": "macroParams", + "macro-rest-param": "macroRestParam", + "macro-body": "macroBody", + "macro-closure": "macroClosure", + "thunk?": "isThunk", + "thunk-expr": "thunkExpr", + "thunk-env": "thunkEnv", + "callable?": "isCallable", + "lambda?": "isLambda", + "component?": "isComponent", + "macro?": "isMacro", + "primitive?": "isPrimitive", + "get-primitive": "getPrimitive", + "env-has?": "envHas", + "env-get": "envGet", + "env-set!": "envSet", + "env-extend": "envExtend", + "env-merge": "envMerge", + "dict-set!": "dictSet", + "dict-get": "dictGet", + "eval-expr": "evalExpr", + "eval-list": "evalList", + "eval-call": "evalCall", + "call-lambda": "callLambda", + "call-component": "callComponent", + "parse-keyword-args": "parseKeywordArgs", + "parse-comp-params": "parseCompParams", + "parse-macro-params": "parseMacroParams", + "expand-macro": "expandMacro", + "render-to-html": "renderToHtml", + "render-to-sx": "renderToSx", + "render-value-to-html": "renderValueToHtml", + "render-list-to-html": "renderListToHtml", + "render-html-element": "renderHtmlElement", + "parse-element-args": "parseElementArgs", + "render-attrs": "renderAttrs", + "aser-list": "aserList", + "aser-fragment": "aserFragment", + "aser-call": "aserCall", + "aser-special": "aserSpecial", + "sf-if": "sfIf", + "sf-when": "sfWhen", + "sf-cond": "sfCond", + "sf-cond-scheme": "sfCondScheme", + "sf-cond-clojure": "sfCondClojure", + "sf-case": "sfCase", + "sf-case-loop": "sfCaseLoop", + "sf-and": "sfAnd", + "sf-or": "sfOr", + "sf-let": "sfLet", + "sf-lambda": "sfLambda", + "sf-define": "sfDefine", + "sf-defcomp": "sfDefcomp", + "sf-defmacro": "sfDefmacro", + "sf-begin": "sfBegin", + "sf-quote": "sfQuote", + "sf-quasiquote": "sfQuasiquote", + "sf-thread-first": "sfThreadFirst", + "sf-set!": "sfSetBang", + "qq-expand": "qqExpand", + "ho-map": "hoMap", + "ho-map-indexed": "hoMapIndexed", + "ho-filter": "hoFilter", + "ho-reduce": "hoReduce", + "ho-some": "hoSome", + "ho-every": "hoEvery", + "special-form?": "isSpecialForm", + "ho-form?": "isHoForm", + "strip-prefix": "stripPrefix", + "escape-html": "escapeHtml", + "escape-attr": "escapeAttr", + "escape-string": "escapeString", + "raw-html-content": "rawHtmlContent", + "HTML_TAGS": "HTML_TAGS", + "VOID_ELEMENTS": "VOID_ELEMENTS", + "BOOLEAN_ATTRS": "BOOLEAN_ATTRS", + "whitespace?": "isWhitespace", + "digit?": "isDigit", + "ident-start?": "isIdentStart", + "ident-char?": "isIdentChar", + "parse-number": "parseNumber", + "sx-expr-source": "sxExprSource", + "starts-with?": "startsWith", + "ends-with?": "endsWith", + "contains?": "contains", + "empty?": "isEmpty", + "odd?": "isOdd", + "even?": "isEven", + "zero?": "isZero", + "number?": "isNumber", + "string?": "isString", + "list?": "isList", + "dict?": "isDict", + "every?": "isEvery", + "map-indexed": "mapIndexed", + "for-each": "forEach", + "map-dict": "mapDict", + "chunk-every": "chunkEvery", + "zip-pairs": "zipPairs", + "strip-tags": "stripTags", + "format-date": "formatDate", + "format-decimal": "formatDecimal", + "parse-int": "parseInt_", + } + if name in RENAMES: + return RENAMES[name] + # General mangling: replace - with camelCase, ? with _p, ! with _b + result = name + if result.endswith("?"): + result = result[:-1] + "_p" + if result.endswith("!"): + result = result[:-1] + "_b" + # Kebab to camel + parts = result.split("-") + if len(parts) > 1: + result = parts[0] + "".join(p.capitalize() for p in parts[1:]) + return result + + # --- List emission --- + + def _emit_list(self, expr: list) -> str: + if not expr: + return "[]" + head = expr[0] + if not isinstance(head, Symbol): + # Data list + return "[" + ", ".join(self.emit(x) for x in expr) + "]" + name = head.name + handler = getattr(self, f"_sf_{name.replace('-', '_').replace('!', '_b').replace('?', '_p')}", None) + if handler: + return handler(expr) + # Built-in forms + if name == "fn" or name == "lambda": + return self._emit_fn(expr) + if name == "let" or name == "let*": + return self._emit_let(expr) + if name == "if": + return self._emit_if(expr) + if name == "when": + return self._emit_when(expr) + if name == "cond": + return self._emit_cond(expr) + if name == "case": + return self._emit_case(expr) + if name == "and": + return self._emit_and(expr) + if name == "or": + return self._emit_or(expr) + if name == "not": + return f"!{self.emit(expr[1])}" + if name == "do" or name == "begin": + return self._emit_do(expr) + if name == "list": + return "[" + ", ".join(self.emit(x) for x in expr[1:]) + "]" + if name == "dict": + return self._emit_dict_literal(expr) + if name == "quote": + return self._emit_quote(expr[1]) + if name == "set!": + return f"({self._mangle(expr[1].name)} = {self.emit(expr[2])})" + if name == "str": + parts = [self.emit(x) for x in expr[1:]] + return "(" + " + ".join(f'String({p})' for p in parts) + ")" + # Infix operators + if name in ("+", "-", "*", "/", "=", "!=", "<", ">", "<=", ">=", "mod"): + return self._emit_infix(name, expr[1:]) + if name == "inc": + return f"({self.emit(expr[1])} + 1)" + if name == "dec": + return f"({self.emit(expr[1])} - 1)" + + # Regular function call + fn_name = self._mangle(name) + args = ", ".join(self.emit(x) for x in expr[1:]) + return f"{fn_name}({args})" + + # --- Special form emitters --- + + def _emit_fn(self, expr) -> str: + params = expr[1] + body = expr[2] + param_names = [] + for p in params: + if isinstance(p, Symbol): + param_names.append(self._mangle(p.name)) + else: + param_names.append(str(p)) + params_str = ", ".join(param_names) + body_js = self.emit(body) + return f"function({params_str}) {{ return {body_js}; }}" + + def _emit_let(self, expr) -> str: + bindings = expr[1] + body = expr[2:] + parts = ["(function() {"] + if isinstance(bindings, list): + if bindings and isinstance(bindings[0], list): + # Scheme-style: ((name val) ...) + for b in bindings: + vname = b[0].name if isinstance(b[0], Symbol) else str(b[0]) + parts.append(f" var {self._mangle(vname)} = {self.emit(b[1])};") + else: + # Clojure-style: (name val name val ...) + for i in range(0, len(bindings), 2): + vname = bindings[i].name if isinstance(bindings[i], Symbol) else str(bindings[i]) + parts.append(f" var {self._mangle(vname)} = {self.emit(bindings[i + 1])};") + for b_expr in body[:-1]: + parts.append(f" {self.emit_statement(b_expr)}") + parts.append(f" return {self.emit(body[-1])};") + parts.append("})()") + return "\n".join(parts) + + def _emit_if(self, expr) -> str: + cond = self.emit(expr[1]) + then = self.emit(expr[2]) + els = self.emit(expr[3]) if len(expr) > 3 else "NIL" + return f"(isSxTruthy({cond}) ? {then} : {els})" + + def _emit_when(self, expr) -> str: + cond = self.emit(expr[1]) + body_parts = expr[2:] + if len(body_parts) == 1: + return f"(isSxTruthy({cond}) ? {self.emit(body_parts[0])} : NIL)" + body = self._emit_do_inner(body_parts) + return f"(isSxTruthy({cond}) ? {body} : NIL)" + + def _emit_when_stmt(self, expr) -> str: + cond = self.emit(expr[1]) + body_parts = expr[2:] + stmts = "\n".join(f" {self.emit_statement(e)}" for e in body_parts) + return f"if (isSxTruthy({cond})) {{\n{stmts}\n}}" + + def _emit_cond(self, expr) -> str: + clauses = expr[1:] + if not clauses: + return "NIL" + # Determine style ONCE: Scheme-style if every element is a 2-element + # list AND no bare keywords appear (bare :else = Clojure). + is_scheme = ( + all(isinstance(c, list) and len(c) == 2 for c in clauses) + and not any(isinstance(c, Keyword) for c in clauses) + ) + if is_scheme: + return self._cond_scheme(clauses) + return self._cond_clojure(clauses) + + def _cond_scheme(self, clauses) -> str: + if not clauses: + return "NIL" + clause = clauses[0] + test = clause[0] + body = clause[1] + if isinstance(test, Symbol) and test.name in ("else", ":else"): + return self.emit(body) + if isinstance(test, Keyword) and test.name == "else": + return self.emit(body) + return f"(isSxTruthy({self.emit(test)}) ? {self.emit(body)} : {self._cond_scheme(clauses[1:])})" + + def _cond_clojure(self, clauses) -> str: + if len(clauses) < 2: + return "NIL" + test = clauses[0] + body = clauses[1] + if isinstance(test, Keyword) and test.name == "else": + return self.emit(body) + if isinstance(test, Symbol) and test.name in ("else", ":else"): + return self.emit(body) + return f"(isSxTruthy({self.emit(test)}) ? {self.emit(body)} : {self._cond_clojure(clauses[2:])})" + + def _emit_case(self, expr) -> str: + match_expr = self.emit(expr[1]) + clauses = expr[2:] + return f"(function() {{ var _m = {match_expr}; {self._case_chain(clauses)} }})()" + + def _case_chain(self, clauses) -> str: + if len(clauses) < 2: + return "return NIL;" + test = clauses[0] + body = clauses[1] + if isinstance(test, Keyword) and test.name == "else": + return f"return {self.emit(body)};" + if isinstance(test, Symbol) and test.name in ("else", ":else"): + return f"return {self.emit(body)};" + return f"if (_m == {self.emit(test)}) return {self.emit(body)}; {self._case_chain(clauses[2:])}" + + def _emit_and(self, expr) -> str: + parts = [self.emit(x) for x in expr[1:]] + return "(" + " && ".join(f"isSxTruthy({p})" for p in parts[:-1]) + (" && " if len(parts) > 1 else "") + parts[-1] + ")" + + def _emit_or(self, expr) -> str: + if len(expr) == 2: + return self.emit(expr[1]) + parts = [self.emit(x) for x in expr[1:]] + # Use a helper that returns the first truthy value + return f"sxOr({', '.join(parts)})" + + def _emit_do(self, expr) -> str: + return self._emit_do_inner(expr[1:]) + + def _emit_do_inner(self, exprs) -> str: + if len(exprs) == 1: + return self.emit(exprs[0]) + parts = [self.emit(e) for e in exprs] + return "(" + ", ".join(parts) + ")" + + def _emit_dict_literal(self, expr) -> str: + pairs = expr[1:] + parts = [] + i = 0 + while i < len(pairs) - 1: + key = pairs[i] + val = pairs[i + 1] + if isinstance(key, Keyword): + parts.append(f"{self._js_string(key.name)}: {self.emit(val)}") + else: + parts.append(f"[{self.emit(key)}]: {self.emit(val)}") + i += 2 + return "{" + ", ".join(parts) + "}" + + def _emit_infix(self, op: str, args: list) -> str: + JS_OPS = {"=": "==", "!=": "!=", "mod": "%"} + js_op = JS_OPS.get(op, op) + if len(args) == 1 and op == "-": + return f"(-{self.emit(args[0])})" + return f"({self.emit(args[0])} {js_op} {self.emit(args[1])})" + + def _emit_define(self, expr) -> str: + name = expr[1].name if isinstance(expr[1], Symbol) else str(expr[1]) + val = self.emit(expr[2]) + return f"var {self._mangle(name)} = {val};" + + def _emit_for_each_stmt(self, expr) -> str: + fn_expr = expr[1] + coll_expr = expr[2] + coll = self.emit(coll_expr) + # If fn is an inline lambda, emit a for loop + if isinstance(fn_expr, list) and fn_expr[0] == Symbol("fn"): + params = fn_expr[1] + body = fn_expr[2] + p = params[0].name if isinstance(params[0], Symbol) else str(params[0]) + p_js = self._mangle(p) + body_js = self.emit_statement(body) + return f"{{ var _c = {coll}; for (var _i = 0; _i < _c.length; _i++) {{ var {p_js} = _c[_i]; {body_js} }} }}" + fn = self.emit(fn_expr) + return f"{{ var _c = {coll}; for (var _i = 0; _i < _c.length; _i++) {{ {fn}(_c[_i]); }} }}" + + def _emit_quote(self, expr) -> str: + """Emit a quoted expression as a JS literal AST.""" + if isinstance(expr, bool): + return "true" if expr else "false" + if isinstance(expr, (int, float)): + return str(expr) + if isinstance(expr, str): + return self._js_string(expr) + if expr is None or expr is SX_NIL: + return "NIL" + if isinstance(expr, Symbol): + return f'new Symbol({self._js_string(expr.name)})' + if isinstance(expr, Keyword): + return f'new Keyword({self._js_string(expr.name)})' + if isinstance(expr, list): + return "[" + ", ".join(self._emit_quote(x) for x in expr) + "]" + return str(expr) + + def _js_string(self, s: str) -> str: + return '"' + s.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n").replace("\r", "\\r").replace("\t", "\\t") + '"' + + +# --------------------------------------------------------------------------- +# Bootstrap compiler +# --------------------------------------------------------------------------- + +def extract_defines(source: str) -> list[tuple[str, list]]: + """Parse .sx source, return list of (name, define-expr) for top-level defines.""" + exprs = parse_all(source) + defines = [] + for expr in exprs: + if isinstance(expr, list) and expr and isinstance(expr[0], Symbol): + if expr[0].name == "define": + name = expr[1].name if isinstance(expr[1], Symbol) else str(expr[1]) + defines.append((name, expr)) + return defines + + +def compile_ref_to_js() -> str: + """Read reference .sx files and emit JavaScript.""" + ref_dir = os.path.dirname(os.path.abspath(__file__)) + emitter = JSEmitter() + + # Read reference files + with open(os.path.join(ref_dir, "eval.sx")) as f: + eval_src = f.read() + with open(os.path.join(ref_dir, "render.sx")) as f: + render_src = f.read() + + eval_defines = extract_defines(eval_src) + render_defines = extract_defines(render_src) + + # Build output + parts = [] + parts.append(PREAMBLE) + parts.append(PLATFORM_JS) + parts.append("\n // === Transpiled from eval.sx ===\n") + for name, expr in eval_defines: + parts.append(f" // {name}") + parts.append(f" {emitter.emit_statement(expr)}") + parts.append("") + parts.append("\n // === Transpiled from render.sx ===\n") + for name, expr in render_defines: + parts.append(f" // {name}") + parts.append(f" {emitter.emit_statement(expr)}") + parts.append("") + parts.append(FIXUPS) + parts.append(PUBLIC_API) + parts.append(EPILOGUE) + return "\n".join(parts) + + +# --------------------------------------------------------------------------- +# Static JS sections +# --------------------------------------------------------------------------- + +PREAMBLE = '''\ +/** + * sx-ref.js — Generated from reference SX evaluator specification. + * + * Bootstrap-compiled from shared/sx/ref/{eval,render,primitives}.sx + * Compare against hand-written sx.js for correctness verification. + * + * DO NOT EDIT — regenerate with: python bootstrap_js.py + */ +;(function(global) { + "use strict"; + + // ========================================================================= + // Types + // ========================================================================= + + var NIL = Object.freeze({ _nil: true, toString: function() { return "nil"; } }); + + function isNil(x) { return x === NIL || x === null || x === undefined; } + function isSxTruthy(x) { return x !== false && !isNil(x); } + + function Symbol(name) { this.name = name; } + Symbol.prototype.toString = function() { return this.name; }; + Symbol.prototype._sym = true; + + function Keyword(name) { this.name = name; } + Keyword.prototype.toString = function() { return ":" + this.name; }; + Keyword.prototype._kw = true; + + function Lambda(params, body, closure, name) { + this.params = params; + this.body = body; + this.closure = closure || {}; + this.name = name || null; + } + Lambda.prototype._lambda = true; + + function Component(name, params, hasChildren, body, closure) { + this.name = name; + this.params = params; + this.hasChildren = hasChildren; + this.body = body; + this.closure = closure || {}; + } + Component.prototype._component = true; + + function Macro(params, restParam, body, closure, name) { + this.params = params; + this.restParam = restParam; + this.body = body; + this.closure = closure || {}; + this.name = name || null; + } + Macro.prototype._macro = true; + + function Thunk(expr, env) { this.expr = expr; this.env = env; } + Thunk.prototype._thunk = true; + + function RawHTML(html) { this.html = html; } + RawHTML.prototype._raw = true; + + function isSym(x) { return x != null && x._sym === true; } + function isKw(x) { return x != null && x._kw === true; } + + function merge() { + var out = {}; + for (var i = 0; i < arguments.length; i++) { + var d = arguments[i]; + if (d) for (var k in d) out[k] = d[k]; + } + return out; + } + + function sxOr() { + for (var i = 0; i < arguments.length; i++) { + if (isSxTruthy(arguments[i])) return arguments[i]; + } + return arguments.length ? arguments[arguments.length - 1] : false; + }''' + +PLATFORM_JS = ''' + // ========================================================================= + // Platform interface — JS implementation + // ========================================================================= + + function typeOf(x) { + if (isNil(x)) return "nil"; + if (typeof x === "number") return "number"; + if (typeof x === "string") return "string"; + if (typeof x === "boolean") return "boolean"; + if (x._sym) return "symbol"; + if (x._kw) return "keyword"; + if (x._thunk) return "thunk"; + if (x._lambda) return "lambda"; + if (x._component) return "component"; + if (x._macro) return "macro"; + if (x._raw) return "raw-html"; + if (Array.isArray(x)) return "list"; + if (typeof x === "object") return "dict"; + return "unknown"; + } + + function symbolName(s) { return s.name; } + function keywordName(k) { return k.name; } + function makeSymbol(n) { return new Symbol(n); } + function makeKeyword(n) { return new Keyword(n); } + + function makeLambda(params, body, env) { return new Lambda(params, body, merge(env)); } + function makeComponent(name, params, hasChildren, body, env) { + return new Component(name, params, hasChildren, body, merge(env)); + } + function makeMacro(params, restParam, body, env, name) { + return new Macro(params, restParam, body, merge(env), name); + } + function makeThunk(expr, env) { return new Thunk(expr, env); } + + function lambdaParams(f) { return f.params; } + function lambdaBody(f) { return f.body; } + function lambdaClosure(f) { return f.closure; } + function lambdaName(f) { return f.name; } + function setLambdaName(f, n) { f.name = n; } + + function componentParams(c) { return c.params; } + function componentBody(c) { return c.body; } + function componentClosure(c) { return c.closure; } + function componentHasChildren(c) { return c.hasChildren; } + function componentName(c) { return c.name; } + + function macroParams(m) { return m.params; } + function macroRestParam(m) { return m.restParam; } + function macroBody(m) { return m.body; } + function macroClosure(m) { return m.closure; } + + function isThunk(x) { return x != null && x._thunk === true; } + function thunkExpr(t) { return t.expr; } + function thunkEnv(t) { return t.env; } + + function isCallable(x) { return typeof x === "function" || (x != null && x._lambda === true); } + function isLambda(x) { return x != null && x._lambda === true; } + function isComponent(x) { return x != null && x._component === true; } + function isMacro(x) { return x != null && x._macro === true; } + + function envHas(env, name) { return name in env; } + function envGet(env, name) { return env[name]; } + function envSet(env, name, val) { env[name] = val; } + function envExtend(env) { return merge(env); } + function envMerge(base, overlay) { return merge(base, overlay); } + + function dictSet(d, k, v) { d[k] = v; } + function dictGet(d, k) { var v = d[k]; return v !== undefined ? v : NIL; } + + function stripPrefix(s, prefix) { + return s.indexOf(prefix) === 0 ? s.slice(prefix.length) : s; + } + + function error(msg) { throw new Error(msg); } + function inspect(x) { return JSON.stringify(x); } + + // ========================================================================= + // Primitives + // ========================================================================= + + var PRIMITIVES = {}; + + // Arithmetic + PRIMITIVES["+"] = function() { var s = 0; for (var i = 0; i < arguments.length; i++) s += arguments[i]; return s; }; + PRIMITIVES["-"] = function(a, b) { return arguments.length === 1 ? -a : a - b; }; + PRIMITIVES["*"] = function() { var s = 1; for (var i = 0; i < arguments.length; i++) s *= arguments[i]; return s; }; + PRIMITIVES["/"] = function(a, b) { return a / b; }; + PRIMITIVES["mod"] = function(a, b) { return a % b; }; + PRIMITIVES["inc"] = function(n) { return n + 1; }; + PRIMITIVES["dec"] = function(n) { return n - 1; }; + PRIMITIVES["abs"] = Math.abs; + PRIMITIVES["floor"] = Math.floor; + PRIMITIVES["ceil"] = Math.ceil; + PRIMITIVES["round"] = Math.round; + PRIMITIVES["min"] = Math.min; + PRIMITIVES["max"] = Math.max; + PRIMITIVES["sqrt"] = Math.sqrt; + PRIMITIVES["pow"] = Math.pow; + PRIMITIVES["clamp"] = function(x, lo, hi) { return Math.max(lo, Math.min(hi, x)); }; + + // Comparison + PRIMITIVES["="] = function(a, b) { return a == b; }; + PRIMITIVES["!="] = function(a, b) { return a != b; }; + PRIMITIVES["<"] = function(a, b) { return a < b; }; + PRIMITIVES[">"] = function(a, b) { return a > b; }; + PRIMITIVES["<="] = function(a, b) { return a <= b; }; + PRIMITIVES[">="] = function(a, b) { return a >= b; }; + + // Logic + PRIMITIVES["not"] = function(x) { return !isSxTruthy(x); }; + + // String + PRIMITIVES["str"] = function() { + var p = []; + for (var i = 0; i < arguments.length; i++) { + var v = arguments[i]; if (isNil(v)) continue; p.push(String(v)); + } + return p.join(""); + }; + PRIMITIVES["upper"] = function(s) { return String(s).toUpperCase(); }; + PRIMITIVES["lower"] = function(s) { return String(s).toLowerCase(); }; + PRIMITIVES["trim"] = function(s) { return String(s).trim(); }; + PRIMITIVES["split"] = function(s, sep) { return String(s).split(sep || " "); }; + PRIMITIVES["join"] = function(sep, coll) { return coll.join(sep); }; + PRIMITIVES["replace"] = function(s, old, nw) { return s.split(old).join(nw); }; + PRIMITIVES["starts-with?"] = function(s, p) { return String(s).indexOf(p) === 0; }; + PRIMITIVES["ends-with?"] = function(s, p) { var str = String(s); return str.indexOf(p, str.length - p.length) !== -1; }; + PRIMITIVES["slice"] = function(c, a, b) { return b !== undefined ? c.slice(a, b) : c.slice(a); }; + PRIMITIVES["concat"] = function() { + var out = []; + for (var i = 0; i < arguments.length; i++) if (arguments[i]) out = out.concat(arguments[i]); + return out; + }; + PRIMITIVES["strip-tags"] = function(s) { return String(s).replace(/<[^>]+>/g, ""); }; + + // Predicates + PRIMITIVES["nil?"] = isNil; + PRIMITIVES["number?"] = function(x) { return typeof x === "number"; }; + PRIMITIVES["string?"] = function(x) { return typeof x === "string"; }; + PRIMITIVES["list?"] = Array.isArray; + PRIMITIVES["dict?"] = function(x) { return x !== null && typeof x === "object" && !Array.isArray(x) && !x._sym && !x._kw; }; + PRIMITIVES["empty?"] = function(c) { return isNil(c) || (Array.isArray(c) ? c.length === 0 : typeof c === "string" ? c.length === 0 : Object.keys(c).length === 0); }; + PRIMITIVES["contains?"] = function(c, k) { + if (typeof c === "string") return c.indexOf(String(k)) !== -1; + if (Array.isArray(c)) return c.indexOf(k) !== -1; + return k in c; + }; + PRIMITIVES["odd?"] = function(n) { return n % 2 !== 0; }; + PRIMITIVES["even?"] = function(n) { return n % 2 === 0; }; + PRIMITIVES["zero?"] = function(n) { return n === 0; }; + + // Collections + PRIMITIVES["list"] = function() { return Array.prototype.slice.call(arguments); }; + PRIMITIVES["dict"] = function() { + var d = {}; + for (var i = 0; i < arguments.length - 1; i += 2) d[arguments[i]] = arguments[i + 1]; + return d; + }; + PRIMITIVES["range"] = function(a, b, step) { + var r = []; step = step || 1; + for (var i = a; step > 0 ? i < b : i > b; i += step) r.push(i); + return r; + }; + PRIMITIVES["get"] = function(c, k, def) { var v = (c && c[k]); return v !== undefined ? v : (def !== undefined ? def : NIL); }; + PRIMITIVES["len"] = function(c) { return Array.isArray(c) ? c.length : typeof c === "string" ? c.length : Object.keys(c).length; }; + PRIMITIVES["first"] = function(c) { return c && c.length > 0 ? c[0] : NIL; }; + PRIMITIVES["last"] = function(c) { return c && c.length > 0 ? c[c.length - 1] : NIL; }; + PRIMITIVES["rest"] = function(c) { return c ? c.slice(1) : []; }; + PRIMITIVES["nth"] = function(c, n) { return c && n >= 0 && n < c.length ? c[n] : NIL; }; + PRIMITIVES["cons"] = function(x, c) { return [x].concat(c || []); }; + PRIMITIVES["append"] = function(c, x) { return (c || []).concat([x]); }; + PRIMITIVES["keys"] = function(d) { return Object.keys(d || {}); }; + PRIMITIVES["vals"] = function(d) { var r = []; for (var k in d) r.push(d[k]); return r; }; + PRIMITIVES["merge"] = function() { + var out = {}; + for (var i = 0; i < arguments.length; i++) { var d = arguments[i]; if (d && !isNil(d)) for (var k in d) out[k] = d[k]; } + return out; + }; + PRIMITIVES["assoc"] = function(d) { + var out = {}; if (d && !isNil(d)) for (var k in d) out[k] = d[k]; + for (var i = 1; i < arguments.length - 1; i += 2) out[arguments[i]] = arguments[i + 1]; + return out; + }; + PRIMITIVES["dissoc"] = function(d) { + var out = {}; for (var k in d) out[k] = d[k]; + for (var i = 1; i < arguments.length; i++) delete out[arguments[i]]; + return out; + }; + PRIMITIVES["chunk-every"] = function(c, n) { + var r = []; for (var i = 0; i < c.length; i += n) r.push(c.slice(i, i + n)); return r; + }; + PRIMITIVES["zip-pairs"] = function(c) { + var r = []; for (var i = 0; i < c.length - 1; i++) r.push([c[i], c[i + 1]]); return r; + }; + PRIMITIVES["into"] = function(target, coll) { + if (Array.isArray(target)) return Array.isArray(coll) ? coll.slice() : Object.entries(coll); + var r = {}; for (var i = 0; i < coll.length; i++) { var p = coll[i]; if (Array.isArray(p) && p.length >= 2) r[p[0]] = p[1]; } + return r; + }; + + // Format + PRIMITIVES["format-decimal"] = function(v, p) { return Number(v).toFixed(p || 2); }; + PRIMITIVES["parse-int"] = function(v, d) { var n = parseInt(v, 10); return isNaN(n) ? (d || 0) : n; }; + PRIMITIVES["pluralize"] = function(n, s, p) { + if (s || (p && p !== "s")) return n == 1 ? (s || "") : (p || "s"); + return n == 1 ? "" : "s"; + }; + PRIMITIVES["escape"] = function(s) { + return String(s).replace(/&/g,"&").replace(//g,">").replace(/"/g,"""); + }; + + function isPrimitive(name) { return name in PRIMITIVES; } + function getPrimitive(name) { return PRIMITIVES[name]; } + + // Higher-order helpers used by the transpiled code + function map(fn, coll) { return coll.map(fn); } + function mapIndexed(fn, coll) { return coll.map(function(item, i) { return fn(i, item); }); } + function filter(fn, coll) { return coll.filter(function(x) { return isSxTruthy(fn(x)); }); } + function reduce(fn, init, coll) { + var acc = init; + for (var i = 0; i < coll.length; i++) acc = fn(acc, coll[i]); + return acc; + } + function some(fn, coll) { + for (var i = 0; i < coll.length; i++) { var r = fn(coll[i]); if (isSxTruthy(r)) return r; } + return NIL; + } + function forEach(fn, coll) { for (var i = 0; i < coll.length; i++) fn(coll[i]); return NIL; } + function mapDict(fn, d) { var r = {}; for (var k in d) r[k] = fn(k, d[k]); return r; } + + // List primitives used directly by transpiled code + var len = PRIMITIVES["len"]; + var first = PRIMITIVES["first"]; + var last = PRIMITIVES["last"]; + var rest = PRIMITIVES["rest"]; + var nth = PRIMITIVES["nth"]; + var cons = PRIMITIVES["cons"]; + var append = PRIMITIVES["append"]; + var isEmpty = PRIMITIVES["empty?"]; + var contains = PRIMITIVES["contains?"]; + var startsWith = PRIMITIVES["starts-with?"]; + var slice = PRIMITIVES["slice"]; + var concat = PRIMITIVES["concat"]; + var str = PRIMITIVES["str"]; + var join = PRIMITIVES["join"]; + var keys = PRIMITIVES["keys"]; + var get = PRIMITIVES["get"]; + var assoc = PRIMITIVES["assoc"]; + var range = PRIMITIVES["range"]; + function zip(a, b) { var r = []; for (var i = 0; i < Math.min(a.length, b.length); i++) r.push([a[i], b[i]]); return r; } + function append_b(arr, x) { arr.push(x); return arr; } + var apply = function(f, args) { return f.apply(null, args); }; + + // HTML rendering helpers + function escapeHtml(s) { + return String(s).replace(/&/g,"&").replace(//g,">").replace(/"/g,"""); + } + function escapeAttr(s) { return escapeHtml(s); } + function rawHtmlContent(r) { return r.html; } + + // Serializer + function serialize(val) { + if (isNil(val)) return "nil"; + if (typeof val === "boolean") return val ? "true" : "false"; + if (typeof val === "number") return String(val); + if (typeof val === "string") return \'"\' + val.replace(/\\\\/g, "\\\\\\\\").replace(/"/g, \'\\\\"\') + \'"\'; + if (isSym(val)) return val.name; + if (isKw(val)) return ":" + val.name; + if (Array.isArray(val)) return "(" + val.map(serialize).join(" ") + ")"; + return String(val); + } + + function isSpecialForm(n) { return n in { + "if":1,"when":1,"cond":1,"case":1,"and":1,"or":1,"let":1,"let*":1, + "lambda":1,"fn":1,"define":1,"defcomp":1,"defmacro":1,"begin":1,"do":1, + "quote":1,"quasiquote":1,"->":1,"set!":1 + }; } + function isHoForm(n) { return n in { + "map":1,"map-indexed":1,"filter":1,"reduce":1,"some":1,"every?":1,"for-each":1 + }; }''' + +FIXUPS = ''' + // ========================================================================= + // Post-transpilation fixups + // ========================================================================= + // The reference spec's call-lambda only handles Lambda objects, but HO forms + // (map, reduce, etc.) may receive native primitives. Wrap to handle both. + var _rawCallLambda = callLambda; + callLambda = function(f, args, callerEnv) { + if (typeof f === "function") return f.apply(null, args); + return _rawCallLambda(f, args, callerEnv); + };''' + +PUBLIC_API = ''' + // ========================================================================= + // Parser (reused from reference — hand-written for bootstrap simplicity) + // ========================================================================= + + // The parser is the one piece we keep as hand-written JS since the + // reference parser.sx is more of a spec than directly compilable code + // (it uses mutable cursor state that doesn't map cleanly to the + // transpiler's functional output). A future version could bootstrap + // the parser too. + + function parse(text) { + var pos = 0; + function skipWs() { + while (pos < text.length) { + var ch = text[pos]; + if (ch === " " || ch === "\\t" || ch === "\\n" || ch === "\\r") { pos++; continue; } + if (ch === ";") { while (pos < text.length && text[pos] !== "\\n") pos++; continue; } + break; + } + } + function readExpr() { + skipWs(); + if (pos >= text.length) return undefined; + var ch = text[pos]; + if (ch === "(") { pos++; return readList(")"); } + if (ch === "[") { pos++; return readList("]"); } + if (ch === \'"\') return readString(); + if (ch === ":") return readKeyword(); + if (ch === "-" && pos + 1 < text.length && text[pos + 1] >= "0" && text[pos + 1] <= "9") return readNumber(); + if (ch >= "0" && ch <= "9") return readNumber(); + return readSymbol(); + } + function readList(close) { + var items = []; + while (true) { + skipWs(); + if (pos >= text.length) throw new Error("Unterminated list"); + if (text[pos] === close) { pos++; return items; } + items.push(readExpr()); + } + } + function readString() { + pos++; // skip " + var s = ""; + while (pos < text.length) { + var ch = text[pos]; + if (ch === \'"\') { pos++; return s; } + if (ch === "\\\\") { pos++; var esc = text[pos]; s += esc === "n" ? "\\n" : esc === "t" ? "\\t" : esc === "r" ? "\\r" : esc; pos++; continue; } + s += ch; pos++; + } + throw new Error("Unterminated string"); + } + function readKeyword() { + pos++; // skip : + var name = readIdent(); + return new Keyword(name); + } + function readNumber() { + var start = pos; + if (text[pos] === "-") pos++; + while (pos < text.length && text[pos] >= "0" && text[pos] <= "9") pos++; + if (pos < text.length && text[pos] === ".") { pos++; while (pos < text.length && text[pos] >= "0" && text[pos] <= "9") pos++; } + if (pos < text.length && (text[pos] === "e" || text[pos] === "E")) { + pos++; + if (pos < text.length && (text[pos] === "+" || text[pos] === "-")) pos++; + while (pos < text.length && text[pos] >= "0" && text[pos] <= "9") pos++; + } + return Number(text.slice(start, pos)); + } + function readIdent() { + var start = pos; + while (pos < text.length && /[a-zA-Z0-9_~*+\\-><=/!?.:&]/.test(text[pos])) pos++; + return text.slice(start, pos); + } + function readSymbol() { + var name = readIdent(); + if (name === "true") return true; + if (name === "false") return false; + if (name === "nil") return NIL; + return new Symbol(name); + } + var exprs = []; + while (true) { + skipWs(); + if (pos >= text.length) break; + exprs.push(readExpr()); + } + return exprs; + } + + // ========================================================================= + // Public API + // ========================================================================= + + var componentEnv = {}; + + function loadComponents(source) { + var exprs = parse(source); + for (var i = 0; i < exprs.length; i++) { + trampoline(evalExpr(exprs[i], componentEnv)); + } + } + + function render(source) { + var exprs = parse(source); + var frag = document.createDocumentFragment(); + for (var i = 0; i < exprs.length; i++) { + var result = trampoline(evalExpr(exprs[i], merge(componentEnv))); + appendToDOM(frag, result, merge(componentEnv)); + } + return frag; + } + + function appendToDOM(parent, val, env) { + if (isNil(val)) return; + if (typeof val === "string") { parent.appendChild(document.createTextNode(val)); return; } + if (typeof val === "number") { parent.appendChild(document.createTextNode(String(val))); return; } + if (val._raw) { var t = document.createElement("template"); t.innerHTML = val.html; parent.appendChild(t.content); return; } + if (Array.isArray(val)) { + // Could be a rendered element or a list of results + if (val.length > 0 && isSym(val[0])) { + // It's an unevaluated expression — evaluate it + var result = trampoline(evalExpr(val, env)); + appendToDOM(parent, result, env); + } else { + for (var i = 0; i < val.length; i++) appendToDOM(parent, val[i], env); + } + return; + } + parent.appendChild(document.createTextNode(String(val))); + } + + var SxRef = { + parse: parse, + eval: function(expr, env) { return trampoline(evalExpr(expr, env || merge(componentEnv))); }, + loadComponents: loadComponents, + render: render, + serialize: serialize, + NIL: NIL, + Symbol: Symbol, + Keyword: Keyword, + componentEnv: componentEnv, + _version: "ref-1.0 (bootstrap-compiled)" + }; + + if (typeof module !== "undefined" && module.exports) module.exports = SxRef; + else global.SxRef = SxRef;''' + +EPILOGUE = ''' +})(typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : this);''' + + +# --------------------------------------------------------------------------- +# Main +# --------------------------------------------------------------------------- + +if __name__ == "__main__": + print(compile_ref_to_js()) From a9526c4fa1f7a88bd1b1b1def666a47da858146b Mon Sep 17 00:00:00 2001 From: giles Date: Thu, 5 Mar 2026 10:17:28 +0000 Subject: [PATCH 3/3] Update reference SX spec to match sx.js macros branch (CSSX, dict literals, new primitives) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - eval.sx: Add defstyle, defkeyframes, defhandler special forms; add ho-for-each - parser.sx: Add dict {...} literal parsing and quasiquote/unquote sugar - primitives.sx: Add parse-datetime, split-ids, css, merge-styles primitives - render.sx: Add StyleValue handling, SVG filter elements, definition forms in render, fix render-to-html to handle HTML tags directly - bootstrap_js.py: Add StyleValue type, buildKeyframes, isEvery platform helper, new primitives (format-date, parse-datetime, split-ids, css, merge-styles), dict/quasiquote parser, expose render functions as primitives - sx-ref.js: Regenerated — 132/132 tests passing Co-Authored-By: Claude Opus 4.6 --- shared/static/scripts/sx-ref.js | 143 +++++++++++++++++++++++++++++--- shared/sx/ref/bootstrap_js.py | 109 +++++++++++++++++++++++- shared/sx/ref/eval.sx | 36 +++++++- shared/sx/ref/parser.sx | 67 ++++++++++++++- shared/sx/ref/primitives.sx | 31 +++++++ shared/sx/ref/render.sx | 49 +++++++++-- 6 files changed, 406 insertions(+), 29 deletions(-) diff --git a/shared/static/scripts/sx-ref.js b/shared/static/scripts/sx-ref.js index 324f0d9..4b9b587 100644 --- a/shared/static/scripts/sx-ref.js +++ b/shared/static/scripts/sx-ref.js @@ -58,6 +58,15 @@ function RawHTML(html) { this.html = html; } RawHTML.prototype._raw = true; + function StyleValue(className, declarations, mediaRules, pseudoRules, keyframes) { + this.className = className; + this.declarations = declarations || ""; + this.mediaRules = mediaRules || []; + this.pseudoRules = pseudoRules || []; + this.keyframes = keyframes || []; + } + StyleValue.prototype._styleValue = true; + function isSym(x) { return x != null && x._sym === true; } function isKw(x) { return x != null && x._kw === true; } @@ -93,6 +102,7 @@ if (x._component) return "component"; if (x._macro) return "macro"; if (x._raw) return "raw-html"; + if (x._styleValue) return "style-value"; if (Array.isArray(x)) return "list"; if (typeof x === "object") return "dict"; return "unknown"; @@ -138,6 +148,27 @@ function isComponent(x) { return x != null && x._component === true; } function isMacro(x) { return x != null && x._macro === true; } + function isStyleValue(x) { return x != null && x._styleValue === true; } + function styleValueClass(x) { return x.className; } + function styleValue_p(x) { return x != null && x._styleValue === true; } + + function buildKeyframes(kfName, steps, env) { + // Platform implementation of defkeyframes + var parts = []; + for (var i = 0; i < steps.length; i++) { + var step = steps[i]; + var selector = isSym(step[0]) ? step[0].name : String(step[0]); + var body = trampoline(evalExpr(step[1], env)); + var decls = isStyleValue(body) ? body.declarations : String(body); + parts.push(selector + "{" + decls + "}"); + } + var kfRule = "@keyframes " + kfName + "{" + parts.join("") + "}"; + var cn = "sx-ref-kf-" + kfName; + var sv = new StyleValue(cn, "animation-name:" + kfName, [], [], [[kfName, kfRule]]); + env[kfName] = sv; + return sv; + } + function envHas(env, name) { return name in env; } function envGet(env, name) { return env[name]; } function envSet(env, name, val) { env[name] = val; } @@ -288,6 +319,45 @@ PRIMITIVES["escape"] = function(s) { return String(s).replace(/&/g,"&").replace(//g,">").replace(/"/g,"""); }; + PRIMITIVES["format-date"] = function(s, fmt) { + if (!s) return ""; + try { + var d = new Date(s); + if (isNaN(d.getTime())) return String(s); + var months = ["January","February","March","April","May","June","July","August","September","October","November","December"]; + var short_months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]; + return fmt.replace(/%-d/g, d.getDate()).replace(/%d/g, ("0"+d.getDate()).slice(-2)) + .replace(/%B/g, months[d.getMonth()]).replace(/%b/g, short_months[d.getMonth()]) + .replace(/%Y/g, d.getFullYear()).replace(/%m/g, ("0"+(d.getMonth()+1)).slice(-2)) + .replace(/%H/g, ("0"+d.getHours()).slice(-2)).replace(/%M/g, ("0"+d.getMinutes()).slice(-2)); + } catch (e) { return String(s); } + }; + PRIMITIVES["parse-datetime"] = function(s) { return s ? String(s) : NIL; }; + PRIMITIVES["split-ids"] = function(s) { + if (!s) return []; + return String(s).split(",").map(function(x) { return x.trim(); }).filter(function(x) { return x; }); + }; + PRIMITIVES["css"] = function() { + // Stub — CSSX requires style dictionary which is browser-only + var atoms = []; + for (var i = 0; i < arguments.length; i++) { + var a = arguments[i]; + if (isNil(a) || a === false) continue; + atoms.push(isKw(a) ? a.name : String(a)); + } + if (!atoms.length) return NIL; + return new StyleValue("sx-" + atoms.join("-"), atoms.join(";"), [], [], []); + }; + PRIMITIVES["merge-styles"] = function() { + var valid = []; + for (var i = 0; i < arguments.length; i++) { + if (isStyleValue(arguments[i])) valid.push(arguments[i]); + } + if (!valid.length) return NIL; + if (valid.length === 1) return valid[0]; + var allDecls = valid.map(function(v) { return v.declarations; }).join(";"); + return new StyleValue("sx-merged", allDecls, [], [], []); + }; function isPrimitive(name) { return name in PRIMITIVES; } function getPrimitive(name) { return PRIMITIVES[name]; } @@ -306,6 +376,10 @@ return NIL; } function forEach(fn, coll) { for (var i = 0; i < coll.length; i++) fn(coll[i]); return NIL; } + function isEvery(fn, coll) { + for (var i = 0; i < coll.length; i++) { if (!isSxTruthy(fn(coll[i]))) return false; } + return true; + } function mapDict(fn, d) { var r = {}; for (var k in d) r[k] = fn(k, d[k]); return r; } // List primitives used directly by transpiled code @@ -352,7 +426,8 @@ function isSpecialForm(n) { return n in { "if":1,"when":1,"cond":1,"case":1,"and":1,"or":1,"let":1,"let*":1, - "lambda":1,"fn":1,"define":1,"defcomp":1,"defmacro":1,"begin":1,"do":1, + "lambda":1,"fn":1,"define":1,"defcomp":1,"defmacro":1,"defstyle":1, + "defkeyframes":1,"defhandler":1,"begin":1,"do":1, "quote":1,"quasiquote":1,"->":1,"set!":1 }; } function isHoForm(n) { return n in { @@ -371,7 +446,7 @@ var evalExpr = function(expr, env) { return (function() { var _m = typeOf(expr); if (_m == "number") return expr; if (_m == "string") return expr; if (_m == "boolean") return expr; if (_m == "nil") return NIL; if (_m == "symbol") return (function() { var name = symbolName(expr); return (isSxTruthy(envHas(env, name)) ? envGet(env, name) : (isSxTruthy(isPrimitive(name)) ? getPrimitive(name) : (isSxTruthy((name == "true")) ? true : (isSxTruthy((name == "false")) ? false : (isSxTruthy((name == "nil")) ? NIL : error((String("Undefined symbol: ") + String(name)))))))); -})(); if (_m == "keyword") return keywordName(expr); if (_m == "dict") return mapDict(function(k, v) { return [k, trampoline(evalExpr(v, env))]; }, expr); if (_m == "list") return (isSxTruthy(isEmpty(expr)) ? [] : evalList(expr, env)); return expr; })(); }; +})(); if (_m == "keyword") return keywordName(expr); if (_m == "dict") return mapDict(function(k, v) { return trampoline(evalExpr(v, env)); }, expr); if (_m == "list") return (isSxTruthy(isEmpty(expr)) ? [] : evalList(expr, env)); return expr; })(); }; // eval-list var evalList = function(expr, env) { return (function() { @@ -379,10 +454,10 @@ var args = rest(expr); return (isSxTruthy(!sxOr((typeOf(head) == "symbol"), (typeOf(head) == "lambda"), (typeOf(head) == "list"))) ? map(function(x) { return trampoline(evalExpr(x, env)); }, expr) : (isSxTruthy((typeOf(head) == "symbol")) ? (function() { var name = symbolName(head); - return (isSxTruthy((name == "if")) ? sfIf(args, env) : (isSxTruthy((name == "when")) ? sfWhen(args, env) : (isSxTruthy((name == "cond")) ? sfCond(args, env) : (isSxTruthy((name == "case")) ? sfCase(args, env) : (isSxTruthy((name == "and")) ? sfAnd(args, env) : (isSxTruthy((name == "or")) ? sfOr(args, env) : (isSxTruthy((name == "let")) ? sfLet(args, env) : (isSxTruthy((name == "let*")) ? sfLet(args, env) : (isSxTruthy((name == "lambda")) ? sfLambda(args, env) : (isSxTruthy((name == "fn")) ? sfLambda(args, env) : (isSxTruthy((name == "define")) ? sfDefine(args, env) : (isSxTruthy((name == "defcomp")) ? sfDefcomp(args, env) : (isSxTruthy((name == "defmacro")) ? sfDefmacro(args, env) : (isSxTruthy((name == "begin")) ? sfBegin(args, env) : (isSxTruthy((name == "do")) ? sfBegin(args, env) : (isSxTruthy((name == "quote")) ? sfQuote(args, env) : (isSxTruthy((name == "quasiquote")) ? sfQuasiquote(args, env) : (isSxTruthy((name == "->")) ? sfThreadFirst(args, env) : (isSxTruthy((name == "set!")) ? sfSetBang(args, env) : (isSxTruthy((name == "map")) ? hoMap(args, env) : (isSxTruthy((name == "map-indexed")) ? hoMapIndexed(args, env) : (isSxTruthy((name == "filter")) ? hoFilter(args, env) : (isSxTruthy((name == "reduce")) ? hoReduce(args, env) : (isSxTruthy((name == "some")) ? hoSome(args, env) : (isSxTruthy((name == "every?")) ? hoEvery(args, env) : (isSxTruthy((name == "for-each")) ? hoForEach(args, env) : (isSxTruthy((isSxTruthy(envHas(env, name)) && isMacro(envGet(env, name)))) ? (function() { + return (isSxTruthy((name == "if")) ? sfIf(args, env) : (isSxTruthy((name == "when")) ? sfWhen(args, env) : (isSxTruthy((name == "cond")) ? sfCond(args, env) : (isSxTruthy((name == "case")) ? sfCase(args, env) : (isSxTruthy((name == "and")) ? sfAnd(args, env) : (isSxTruthy((name == "or")) ? sfOr(args, env) : (isSxTruthy((name == "let")) ? sfLet(args, env) : (isSxTruthy((name == "let*")) ? sfLet(args, env) : (isSxTruthy((name == "lambda")) ? sfLambda(args, env) : (isSxTruthy((name == "fn")) ? sfLambda(args, env) : (isSxTruthy((name == "define")) ? sfDefine(args, env) : (isSxTruthy((name == "defcomp")) ? sfDefcomp(args, env) : (isSxTruthy((name == "defmacro")) ? sfDefmacro(args, env) : (isSxTruthy((name == "defstyle")) ? sfDefstyle(args, env) : (isSxTruthy((name == "defkeyframes")) ? sfDefkeyframes(args, env) : (isSxTruthy((name == "defhandler")) ? sfDefine(args, env) : (isSxTruthy((name == "begin")) ? sfBegin(args, env) : (isSxTruthy((name == "do")) ? sfBegin(args, env) : (isSxTruthy((name == "quote")) ? sfQuote(args, env) : (isSxTruthy((name == "quasiquote")) ? sfQuasiquote(args, env) : (isSxTruthy((name == "->")) ? sfThreadFirst(args, env) : (isSxTruthy((name == "set!")) ? sfSetBang(args, env) : (isSxTruthy((name == "map")) ? hoMap(args, env) : (isSxTruthy((name == "map-indexed")) ? hoMapIndexed(args, env) : (isSxTruthy((name == "filter")) ? hoFilter(args, env) : (isSxTruthy((name == "reduce")) ? hoReduce(args, env) : (isSxTruthy((name == "some")) ? hoSome(args, env) : (isSxTruthy((name == "every?")) ? hoEvery(args, env) : (isSxTruthy((name == "for-each")) ? hoForEach(args, env) : (isSxTruthy((isSxTruthy(envHas(env, name)) && isMacro(envGet(env, name)))) ? (function() { var mac = envGet(env, name); return makeThunk(expandMacro(mac, args, env), env); -})() : evalCall(head, args, env)))))))))))))))))))))))))))); +})() : evalCall(head, args, env))))))))))))))))))))))))))))))); })() : evalCall(head, args, env))); })(); }; @@ -574,6 +649,21 @@ return [params, restParam]; })(); }; + // sf-defstyle + var sfDefstyle = function(args, env) { return (function() { + var nameSym = first(args); + var value = trampoline(evalExpr(nth(args, 1), env)); + env[symbolName(nameSym)] = value; + return value; +})(); }; + + // sf-defkeyframes + var sfDefkeyframes = function(args, env) { return (function() { + var kfName = symbolName(first(args)); + var steps = rest(args); + return buildKeyframes(kfName, steps, env); +})(); }; + // sf-begin var sfBegin = function(args, env) { return (isSxTruthy(isEmpty(args)) ? NIL : (forEach(function(e) { return trampoline(evalExpr(e, env)); }, slice(args, 0, (len(args) - 1))), makeThunk(last(args), env))); }; @@ -667,26 +757,30 @@ return isEvery(function(item) { return trampoline(callLambda(f, [item], env)); }, coll); })(); }; + // ho-for-each + var hoForEach = function(args, env) { return (function() { + var f = trampoline(evalExpr(first(args), env)); + var coll = trampoline(evalExpr(nth(args, 1), env)); + return forEach(function(item) { return trampoline(callLambda(f, [item], env)); }, coll); +})(); }; + // === Transpiled from render.sx === // HTML_TAGS - var HTML_TAGS = ["html", "head", "body", "title", "meta", "link", "script", "style", "noscript", "header", "nav", "main", "section", "article", "aside", "footer", "h1", "h2", "h3", "h4", "h5", "h6", "hgroup", "div", "p", "blockquote", "pre", "figure", "figcaption", "address", "details", "summary", "a", "span", "em", "strong", "small", "b", "i", "u", "s", "mark", "sub", "sup", "abbr", "cite", "code", "time", "br", "wbr", "hr", "ul", "ol", "li", "dl", "dt", "dd", "table", "thead", "tbody", "tfoot", "tr", "th", "td", "caption", "colgroup", "col", "form", "input", "textarea", "select", "option", "optgroup", "button", "label", "fieldset", "legend", "output", "datalist", "img", "video", "audio", "source", "picture", "canvas", "iframe", "svg", "path", "circle", "rect", "line", "polyline", "polygon", "text", "g", "defs", "use", "clipPath", "mask", "pattern", "linearGradient", "radialGradient", "stop", "filter", "feGaussianBlur", "feOffset", "feBlend", "feColorMatrix", "feComposite", "feMerge", "feMergeNode", "animate", "animateTransform", "foreignObject", "template", "slot", "dialog", "menu"]; + var HTML_TAGS = ["html", "head", "body", "title", "meta", "link", "script", "style", "noscript", "header", "nav", "main", "section", "article", "aside", "footer", "h1", "h2", "h3", "h4", "h5", "h6", "hgroup", "div", "p", "blockquote", "pre", "figure", "figcaption", "address", "details", "summary", "a", "span", "em", "strong", "small", "b", "i", "u", "s", "mark", "sub", "sup", "abbr", "cite", "code", "time", "br", "wbr", "hr", "ul", "ol", "li", "dl", "dt", "dd", "table", "thead", "tbody", "tfoot", "tr", "th", "td", "caption", "colgroup", "col", "form", "input", "textarea", "select", "option", "optgroup", "button", "label", "fieldset", "legend", "output", "datalist", "img", "video", "audio", "source", "picture", "canvas", "iframe", "svg", "math", "path", "circle", "ellipse", "rect", "line", "polyline", "polygon", "text", "tspan", "g", "defs", "use", "clipPath", "mask", "pattern", "linearGradient", "radialGradient", "stop", "filter", "feGaussianBlur", "feOffset", "feBlend", "feColorMatrix", "feComposite", "feMerge", "feMergeNode", "feTurbulence", "feComponentTransfer", "feFuncR", "feFuncG", "feFuncB", "feFuncA", "feDisplacementMap", "feFlood", "feImage", "feMorphology", "feSpecularLighting", "feDiffuseLighting", "fePointLight", "feSpotLight", "feDistantLight", "animate", "animateTransform", "foreignObject", "template", "slot", "dialog", "menu"]; // VOID_ELEMENTS var VOID_ELEMENTS = ["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]; // BOOLEAN_ATTRS - var BOOLEAN_ATTRS = ["disabled", "checked", "selected", "readonly", "required", "hidden", "autofocus", "autoplay", "controls", "loop", "muted", "defer", "async", "novalidate", "formnovalidate", "multiple", "open", "allowfullscreen"]; + var BOOLEAN_ATTRS = ["async", "autofocus", "autoplay", "checked", "controls", "default", "defer", "disabled", "formnovalidate", "hidden", "inert", "ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "selected"]; // render-to-html - var renderToHtml = function(expr, env) { return (function() { - var result = trampoline(evalExpr(expr, env)); - return renderValueToHtml(result, env); -})(); }; + var renderToHtml = function(expr, env) { return (function() { var _m = typeOf(expr); if (_m == "nil") return ""; if (_m == "string") return escapeHtml(expr); if (_m == "number") return (String(expr)); if (_m == "boolean") return (isSxTruthy(expr) ? "true" : "false"); if (_m == "list") return (isSxTruthy(isEmpty(expr)) ? "" : renderListToHtml(expr, env)); if (_m == "symbol") return renderValueToHtml(trampoline(evalExpr(expr, env)), env); if (_m == "keyword") return escapeHtml(keywordName(expr)); return renderValueToHtml(trampoline(evalExpr(expr, env)), env); })(); }; // render-value-to-html - var renderValueToHtml = function(val, env) { return (function() { var _m = typeOf(val); if (_m == "nil") return ""; if (_m == "string") return escapeHtml(val); if (_m == "number") return (String(val)); if (_m == "boolean") return (isSxTruthy(val) ? "true" : "false"); if (_m == "list") return renderListToHtml(val, env); if (_m == "raw-html") return rawHtmlContent(val); return escapeHtml((String(val))); })(); }; + var renderValueToHtml = function(val, env) { return (function() { var _m = typeOf(val); if (_m == "nil") return ""; if (_m == "string") return escapeHtml(val); if (_m == "number") return (String(val)); if (_m == "boolean") return (isSxTruthy(val) ? "true" : "false"); if (_m == "list") return renderListToHtml(val, env); if (_m == "raw-html") return rawHtmlContent(val); if (_m == "style-value") return styleValueClass(val); return escapeHtml((String(val))); })(); }; // render-list-to-html var renderListToHtml = function(expr, env) { return (isSxTruthy(isEmpty(expr)) ? "" : (function() { @@ -697,7 +791,7 @@ return (isSxTruthy((name == "<>")) ? join("", map(function(x) { return renderToHtml(x, env); }, args)) : (isSxTruthy((name == "raw!")) ? join("", map(function(x) { return (String(trampoline(evalExpr(x, env)))); }, args)) : (isSxTruthy(contains(HTML_TAGS, name)) ? renderHtmlElement(name, args, env) : (isSxTruthy(startsWith(name, "~")) ? (function() { var comp = envGet(env, name); return (isSxTruthy(isComponent(comp)) ? renderToHtml(trampoline(callComponent(comp, args, env)), env) : error((String("Unknown component: ") + String(name)))); -})() : (isSxTruthy((isSxTruthy(envHas(env, name)) && isMacro(envGet(env, name)))) ? renderToHtml(trampoline(evalExpr(expandMacro(envGet(env, name), args, env), env)), env) : renderValueToHtml(trampoline(evalExpr(expr, env)), env)))))); +})() : (isSxTruthy(sxOr((name == "define"), (name == "defcomp"), (name == "defmacro"), (name == "defstyle"), (name == "defkeyframes"), (name == "defhandler"))) ? (trampoline(evalExpr(expr, env)), "") : (isSxTruthy((isSxTruthy(envHas(env, name)) && isMacro(envGet(env, name)))) ? renderToHtml(trampoline(evalExpr(expandMacro(envGet(env, name), args, env), env)), env) : renderValueToHtml(trampoline(evalExpr(expr, env)), env))))))); })()); })()); }; @@ -728,7 +822,7 @@ // render-attrs var renderAttrs = function(attrs) { return join("", map(function(key) { return (function() { var val = dictGet(attrs, key); - return (isSxTruthy((isSxTruthy(contains(BOOLEAN_ATTRS, key)) && val)) ? (String(" ") + String(key)) : (isSxTruthy((isSxTruthy(contains(BOOLEAN_ATTRS, key)) && !val)) ? "" : (isSxTruthy(isNil(val)) ? "" : (String(" ") + String(key) + String("=\"") + String(escapeAttr((String(val)))) + String("\""))))); + return (isSxTruthy((isSxTruthy(contains(BOOLEAN_ATTRS, key)) && val)) ? (String(" ") + String(key)) : (isSxTruthy((isSxTruthy(contains(BOOLEAN_ATTRS, key)) && !val)) ? "" : (isSxTruthy(isNil(val)) ? "" : (isSxTruthy((isSxTruthy((key == "style")) && isStyleValue(val))) ? (String(" class=\"") + String(styleValueClass(val)) + String("\"")) : (String(" ") + String(key) + String("=\"") + String(escapeAttr((String(val)))) + String("\"")))))); })(); }, keys(attrs))); }; // render-to-sx @@ -798,6 +892,11 @@ return _rawCallLambda(f, args, callerEnv); }; + // Expose render functions as primitives so SX code can call them + if (typeof renderToHtml === "function") PRIMITIVES["render-to-html"] = renderToHtml; + if (typeof renderToSx === "function") PRIMITIVES["render-to-sx"] = renderToSx; + if (typeof aser === "function") PRIMITIVES["aser"] = aser; + // ========================================================================= // Parser (reused from reference — hand-written for bootstrap simplicity) // ========================================================================= @@ -824,8 +923,15 @@ var ch = text[pos]; if (ch === "(") { pos++; return readList(")"); } if (ch === "[") { pos++; return readList("]"); } + if (ch === "{") { pos++; return readMap(); } if (ch === '"') return readString(); if (ch === ":") return readKeyword(); + if (ch === "`") { pos++; return [new Symbol("quasiquote"), readExpr()]; } + if (ch === ",") { + pos++; + if (pos < text.length && text[pos] === "@") { pos++; return [new Symbol("splice-unquote"), readExpr()]; } + return [new Symbol("unquote"), readExpr()]; + } if (ch === "-" && pos + 1 < text.length && text[pos + 1] >= "0" && text[pos + 1] <= "9") return readNumber(); if (ch >= "0" && ch <= "9") return readNumber(); return readSymbol(); @@ -839,6 +945,17 @@ items.push(readExpr()); } } + function readMap() { + var result = {}; + while (true) { + skipWs(); + if (pos >= text.length) throw new Error("Unterminated map"); + if (text[pos] === "}") { pos++; return result; } + var key = readExpr(); + var keyStr = (key && key._kw) ? key.name : String(key); + result[keyStr] = readExpr(); + } + } function readString() { pos++; // skip " var s = ""; diff --git a/shared/sx/ref/bootstrap_js.py b/shared/sx/ref/bootstrap_js.py index 5e9583c..bb53b8a 100644 --- a/shared/sx/ref/bootstrap_js.py +++ b/shared/sx/ref/bootstrap_js.py @@ -178,6 +178,13 @@ class JSEmitter: "ho-reduce": "hoReduce", "ho-some": "hoSome", "ho-every": "hoEvery", + "ho-for-each": "hoForEach", + "sf-defstyle": "sfDefstyle", + "sf-defkeyframes": "sfDefkeyframes", + "build-keyframes": "buildKeyframes", + "style-value?": "isStyleValue", + "style-value-class": "styleValueClass", + "kf-name": "kfName", "special-form?": "isSpecialForm", "ho-form?": "isHoForm", "strip-prefix": "stripPrefix", @@ -595,6 +602,15 @@ PREAMBLE = '''\ function RawHTML(html) { this.html = html; } RawHTML.prototype._raw = true; + function StyleValue(className, declarations, mediaRules, pseudoRules, keyframes) { + this.className = className; + this.declarations = declarations || ""; + this.mediaRules = mediaRules || []; + this.pseudoRules = pseudoRules || []; + this.keyframes = keyframes || []; + } + StyleValue.prototype._styleValue = true; + function isSym(x) { return x != null && x._sym === true; } function isKw(x) { return x != null && x._kw === true; } @@ -631,6 +647,7 @@ PLATFORM_JS = ''' if (x._component) return "component"; if (x._macro) return "macro"; if (x._raw) return "raw-html"; + if (x._styleValue) return "style-value"; if (Array.isArray(x)) return "list"; if (typeof x === "object") return "dict"; return "unknown"; @@ -676,6 +693,27 @@ PLATFORM_JS = ''' function isComponent(x) { return x != null && x._component === true; } function isMacro(x) { return x != null && x._macro === true; } + function isStyleValue(x) { return x != null && x._styleValue === true; } + function styleValueClass(x) { return x.className; } + function styleValue_p(x) { return x != null && x._styleValue === true; } + + function buildKeyframes(kfName, steps, env) { + // Platform implementation of defkeyframes + var parts = []; + for (var i = 0; i < steps.length; i++) { + var step = steps[i]; + var selector = isSym(step[0]) ? step[0].name : String(step[0]); + var body = trampoline(evalExpr(step[1], env)); + var decls = isStyleValue(body) ? body.declarations : String(body); + parts.push(selector + "{" + decls + "}"); + } + var kfRule = "@keyframes " + kfName + "{" + parts.join("") + "}"; + var cn = "sx-ref-kf-" + kfName; + var sv = new StyleValue(cn, "animation-name:" + kfName, [], [], [[kfName, kfRule]]); + env[kfName] = sv; + return sv; + } + function envHas(env, name) { return name in env; } function envGet(env, name) { return env[name]; } function envSet(env, name, val) { env[name] = val; } @@ -826,6 +864,45 @@ PLATFORM_JS = ''' PRIMITIVES["escape"] = function(s) { return String(s).replace(/&/g,"&").replace(//g,">").replace(/"/g,"""); }; + PRIMITIVES["format-date"] = function(s, fmt) { + if (!s) return ""; + try { + var d = new Date(s); + if (isNaN(d.getTime())) return String(s); + var months = ["January","February","March","April","May","June","July","August","September","October","November","December"]; + var short_months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]; + return fmt.replace(/%-d/g, d.getDate()).replace(/%d/g, ("0"+d.getDate()).slice(-2)) + .replace(/%B/g, months[d.getMonth()]).replace(/%b/g, short_months[d.getMonth()]) + .replace(/%Y/g, d.getFullYear()).replace(/%m/g, ("0"+(d.getMonth()+1)).slice(-2)) + .replace(/%H/g, ("0"+d.getHours()).slice(-2)).replace(/%M/g, ("0"+d.getMinutes()).slice(-2)); + } catch (e) { return String(s); } + }; + PRIMITIVES["parse-datetime"] = function(s) { return s ? String(s) : NIL; }; + PRIMITIVES["split-ids"] = function(s) { + if (!s) return []; + return String(s).split(",").map(function(x) { return x.trim(); }).filter(function(x) { return x; }); + }; + PRIMITIVES["css"] = function() { + // Stub — CSSX requires style dictionary which is browser-only + var atoms = []; + for (var i = 0; i < arguments.length; i++) { + var a = arguments[i]; + if (isNil(a) || a === false) continue; + atoms.push(isKw(a) ? a.name : String(a)); + } + if (!atoms.length) return NIL; + return new StyleValue("sx-" + atoms.join("-"), atoms.join(";"), [], [], []); + }; + PRIMITIVES["merge-styles"] = function() { + var valid = []; + for (var i = 0; i < arguments.length; i++) { + if (isStyleValue(arguments[i])) valid.push(arguments[i]); + } + if (!valid.length) return NIL; + if (valid.length === 1) return valid[0]; + var allDecls = valid.map(function(v) { return v.declarations; }).join(";"); + return new StyleValue("sx-merged", allDecls, [], [], []); + }; function isPrimitive(name) { return name in PRIMITIVES; } function getPrimitive(name) { return PRIMITIVES[name]; } @@ -844,6 +921,10 @@ PLATFORM_JS = ''' return NIL; } function forEach(fn, coll) { for (var i = 0; i < coll.length; i++) fn(coll[i]); return NIL; } + function isEvery(fn, coll) { + for (var i = 0; i < coll.length; i++) { if (!isSxTruthy(fn(coll[i]))) return false; } + return true; + } function mapDict(fn, d) { var r = {}; for (var k in d) r[k] = fn(k, d[k]); return r; } // List primitives used directly by transpiled code @@ -890,7 +971,8 @@ PLATFORM_JS = ''' function isSpecialForm(n) { return n in { "if":1,"when":1,"cond":1,"case":1,"and":1,"or":1,"let":1,"let*":1, - "lambda":1,"fn":1,"define":1,"defcomp":1,"defmacro":1,"begin":1,"do":1, + "lambda":1,"fn":1,"define":1,"defcomp":1,"defmacro":1,"defstyle":1, + "defkeyframes":1,"defhandler":1,"begin":1,"do":1, "quote":1,"quasiquote":1,"->":1,"set!":1 }; } function isHoForm(n) { return n in { @@ -907,7 +989,12 @@ FIXUPS = ''' callLambda = function(f, args, callerEnv) { if (typeof f === "function") return f.apply(null, args); return _rawCallLambda(f, args, callerEnv); - };''' + }; + + // Expose render functions as primitives so SX code can call them + if (typeof renderToHtml === "function") PRIMITIVES["render-to-html"] = renderToHtml; + if (typeof renderToSx === "function") PRIMITIVES["render-to-sx"] = renderToSx; + if (typeof aser === "function") PRIMITIVES["aser"] = aser;''' PUBLIC_API = ''' // ========================================================================= @@ -936,8 +1023,15 @@ PUBLIC_API = ''' var ch = text[pos]; if (ch === "(") { pos++; return readList(")"); } if (ch === "[") { pos++; return readList("]"); } + if (ch === "{") { pos++; return readMap(); } if (ch === \'"\') return readString(); if (ch === ":") return readKeyword(); + if (ch === "`") { pos++; return [new Symbol("quasiquote"), readExpr()]; } + if (ch === ",") { + pos++; + if (pos < text.length && text[pos] === "@") { pos++; return [new Symbol("splice-unquote"), readExpr()]; } + return [new Symbol("unquote"), readExpr()]; + } if (ch === "-" && pos + 1 < text.length && text[pos + 1] >= "0" && text[pos + 1] <= "9") return readNumber(); if (ch >= "0" && ch <= "9") return readNumber(); return readSymbol(); @@ -951,6 +1045,17 @@ PUBLIC_API = ''' items.push(readExpr()); } } + function readMap() { + var result = {}; + while (true) { + skipWs(); + if (pos >= text.length) throw new Error("Unterminated map"); + if (text[pos] === "}") { pos++; return result; } + var key = readExpr(); + var keyStr = (key && key._kw) ? key.name : String(key); + result[keyStr] = readExpr(); + } + } function readString() { pos++; // skip " var s = ""; diff --git a/shared/sx/ref/eval.sx b/shared/sx/ref/eval.sx index 018a621..fd1a60e 100644 --- a/shared/sx/ref/eval.sx +++ b/shared/sx/ref/eval.sx @@ -96,7 +96,7 @@ ;; --- dict literal --- "dict" - (map-dict (fn (k v) (list k (trampoline (eval-expr v env)))) expr) + (map-dict (fn (k v) (trampoline (eval-expr v env))) expr) ;; --- list = call or special form --- "list" @@ -141,6 +141,9 @@ (= name "define") (sf-define args env) (= name "defcomp") (sf-defcomp args env) (= name "defmacro") (sf-defmacro args env) + (= name "defstyle") (sf-defstyle args env) + (= name "defkeyframes") (sf-defkeyframes args env) + (= name "defhandler") (sf-define args env) (= name "begin") (sf-begin args env) (= name "do") (sf-begin args env) (= name "quote") (sf-quote args env) @@ -495,6 +498,25 @@ (list params rest-param)))) +(define sf-defstyle + (fn (args env) + ;; (defstyle name expr) — bind name to evaluated expr (typically a StyleValue) + (let ((name-sym (first args)) + (value (trampoline (eval-expr (nth args 1) env)))) + (env-set! env (symbol-name name-sym) value) + value))) + + +(define sf-defkeyframes + (fn (args env) + ;; (defkeyframes name (selector body) ...) — build @keyframes rule, + ;; register in keyframes dict, return StyleValue. + ;; Delegates to platform: build-keyframes returns a StyleValue. + (let ((kf-name (symbol-name (first args))) + (steps (rest args))) + (build-keyframes kf-name steps env)))) + + (define sf-begin (fn (args env) (if (empty? args) @@ -651,6 +673,15 @@ coll)))) +(define ho-for-each + (fn (args env) + (let ((f (trampoline (eval-expr (first args) env))) + (coll (trampoline (eval-expr (nth args 1) env)))) + (for-each + (fn (item) (trampoline (call-lambda f (list item) env))) + coll)))) + + ;; -------------------------------------------------------------------------- ;; 8. Primitives — pure functions available in all targets ;; -------------------------------------------------------------------------- @@ -728,4 +759,7 @@ ;; (strip-prefix s prefix) → string with prefix removed (or s unchanged) ;; (apply f args) → call f with args list ;; (zip lists...) → list of tuples +;; +;; CSSX (style system): +;; (build-keyframes name steps env) → StyleValue (platform builds @keyframes) ;; -------------------------------------------------------------------------- diff --git a/shared/sx/ref/parser.sx b/shared/sx/ref/parser.sx index 3ed6d17..5c50bf4 100644 --- a/shared/sx/ref/parser.sx +++ b/shared/sx/ref/parser.sx @@ -18,11 +18,13 @@ ;; ident → [a-zA-Z_~*+\-><=/!?&] [a-zA-Z0-9_~*+\-><=/!?.:&]* ;; comment → ';' to end of line (discarded) ;; -;; Quote sugar (optional — not used in current SX): -;; '(expr) → (quote expr) +;; Dict literal: +;; {key val ...} → dict object (keys are keywords or expressions) +;; +;; Quote sugar: ;; `(expr) → (quasiquote expr) -;; ~(expr) → (unquote expr) -;; ~@(expr) → (splice-unquote expr) +;; ,(expr) → (unquote expr) +;; ,@(expr) → (splice-unquote expr) ;; ========================================================================== @@ -81,6 +83,37 @@ (advance-pos!) (scan-next)) + ;; Open brace (dict literal) + (= ch "{") + (do (append! tokens (list "lbrace" "{" line col)) + (advance-pos!) + (scan-next)) + + ;; Close brace + (= ch "}") + (do (append! tokens (list "rbrace" "}" line col)) + (advance-pos!) + (scan-next)) + + ;; Quasiquote sugar + (= ch "`") + (do (advance-pos!) + (let ((inner (scan-next-expr))) + (append! tokens (list "quasiquote" inner line col)) + (scan-next))) + + ;; Unquote / splice-unquote + (= ch ",") + (do (advance-pos!) + (if (and (< pos len-src) (= (nth source pos) "@")) + (do (advance-pos!) + (let ((inner (scan-next-expr))) + (append! tokens (list "splice-unquote" inner line col)) + (scan-next))) + (let ((inner (scan-next-expr))) + (append! tokens (list "unquote" inner line col)) + (scan-next)))) + ;; Keyword (= ch ":") (do (append! tokens (scan-keyword)) (scan-next)) @@ -229,6 +262,10 @@ (do (set! pos (inc pos)) (parse-list tokens "rbracket")) + "lbrace" + (do (set! pos (inc pos)) + (parse-dict tokens)) + "string" (do (set! pos (inc pos)) (nth tok 1)) "number" (do (set! pos (inc pos)) (nth tok 1)) "boolean" (do (set! pos (inc pos)) (nth tok 1)) @@ -261,6 +298,28 @@ items))) +(define parse-dict + (fn (tokens) + ;; Parse {key val key val ...} until "rbrace" token. + ;; Returns a dict (plain object). + (let ((result (dict))) + (define parse-dict-loop + (fn () + (if (>= pos (len tokens)) + (error "Unterminated dict") + (if (= (first (nth tokens pos)) "rbrace") + (do (set! pos (inc pos)) nil) ;; done + (let ((key-expr (parse-expr tokens)) + (key-str (if (= (type-of key-expr) "keyword") + (keyword-name key-expr) + (str key-expr))) + (val-expr (parse-expr tokens))) + (dict-set! result key-str val-expr) + (parse-dict-loop)))))) + (parse-dict-loop) + result))) + + ;; -------------------------------------------------------------------------- ;; Serializer — AST → SX source text ;; -------------------------------------------------------------------------- diff --git a/shared/sx/ref/primitives.sx b/shared/sx/ref/primitives.sx index 05a9a9e..7aea3bb 100644 --- a/shared/sx/ref/primitives.sx +++ b/shared/sx/ref/primitives.sx @@ -426,3 +426,34 @@ :params (s) :returns "string" :doc "Remove HTML tags from string.") + + +;; -------------------------------------------------------------------------- +;; Date & parsing helpers +;; -------------------------------------------------------------------------- + +(define-primitive "parse-datetime" + :params (s) + :returns "string" + :doc "Parse datetime string — identity passthrough (returns string or nil).") + +(define-primitive "split-ids" + :params (s) + :returns "list" + :doc "Split comma-separated ID string into list of trimmed non-empty strings.") + + +;; -------------------------------------------------------------------------- +;; CSSX — style system primitives +;; -------------------------------------------------------------------------- + +(define-primitive "css" + :params (&rest atoms) + :returns "style-value" + :doc "Resolve style atoms to a StyleValue with className and CSS declarations. + Atoms are keywords or strings: (css :flex :gap-4 :hover:bg-sky-200).") + +(define-primitive "merge-styles" + :params (&rest styles) + :returns "style-value" + :doc "Merge multiple StyleValues into one combined StyleValue.") diff --git a/shared/sx/ref/render.sx b/shared/sx/ref/render.sx index 0e118bd..624d781 100644 --- a/shared/sx/ref/render.sx +++ b/shared/sx/ref/render.sx @@ -44,10 +44,15 @@ ;; Media "img" "video" "audio" "source" "picture" "canvas" "iframe" ;; SVG - "svg" "path" "circle" "rect" "line" "polyline" "polygon" "text" - "g" "defs" "use" "clipPath" "mask" "pattern" "linearGradient" - "radialGradient" "stop" "filter" "feGaussianBlur" "feOffset" - "feBlend" "feColorMatrix" "feComposite" "feMerge" "feMergeNode" + "svg" "math" "path" "circle" "ellipse" "rect" "line" "polyline" "polygon" + "text" "tspan" "g" "defs" "use" "clipPath" "mask" "pattern" + "linearGradient" "radialGradient" "stop" "filter" + "feGaussianBlur" "feOffset" "feBlend" "feColorMatrix" "feComposite" + "feMerge" "feMergeNode" "feTurbulence" + "feComponentTransfer" "feFuncR" "feFuncG" "feFuncB" "feFuncA" + "feDisplacementMap" "feFlood" "feImage" "feMorphology" + "feSpecularLighting" "feDiffuseLighting" + "fePointLight" "feSpotLight" "feDistantLight" "animate" "animateTransform" "foreignObject" ;; Other "template" "slot" "dialog" "menu")) @@ -57,9 +62,10 @@ "link" "meta" "param" "source" "track" "wbr")) (define BOOLEAN_ATTRS - (list "disabled" "checked" "selected" "readonly" "required" "hidden" - "autofocus" "autoplay" "controls" "loop" "muted" "defer" "async" - "novalidate" "formnovalidate" "multiple" "open" "allowfullscreen")) + (list "async" "autofocus" "autoplay" "checked" "controls" "default" + "defer" "disabled" "formnovalidate" "hidden" "inert" "ismap" + "loop" "multiple" "muted" "nomodule" "novalidate" "open" + "playsinline" "readonly" "required" "reversed" "selected")) ;; -------------------------------------------------------------------------- @@ -68,8 +74,20 @@ (define render-to-html (fn (expr env) - (let ((result (trampoline (eval-expr expr env)))) - (render-value-to-html result env)))) + (case (type-of expr) + ;; Literals — render directly + "nil" "" + "string" (escape-html expr) + "number" (str expr) + "boolean" (if expr "true" "false") + ;; List — dispatch to render-list which handles HTML tags, special forms, etc. + "list" (if (empty? expr) "" (render-list-to-html expr env)) + ;; Symbol — evaluate then render + "symbol" (render-value-to-html (trampoline (eval-expr expr env)) env) + ;; Keyword — render as text + "keyword" (escape-html (keyword-name expr)) + ;; Everything else — evaluate first + :else (render-value-to-html (trampoline (eval-expr expr env)) env)))) (define render-value-to-html (fn (val env) @@ -80,6 +98,7 @@ "boolean" (if val "true" "false") "list" (render-list-to-html val env) "raw-html" (raw-html-content val) + "style-value" (style-value-class val) :else (escape-html (str val))))) (define render-list-to-html @@ -114,6 +133,11 @@ env) (error (str "Unknown component: " name)))) + ;; Definitions — evaluate for side effects, render nothing + (or (= name "define") (= name "defcomp") (= name "defmacro") + (= name "defstyle") (= name "defkeyframes") (= name "defhandler")) + (do (trampoline (eval-expr expr env)) "") + ;; Macro expansion (and (env-has? env name) (macro? (env-get env name))) (render-to-html @@ -182,6 +206,9 @@ "" ;; Nil values — skip (nil? val) "" + ;; StyleValue on :style → emit as class + (and (= key "style") (style-value? val)) + (str " class=\"" (style-value-class val) "\"") ;; Normal attr :else (str " " key "=\"" (escape-attr (str val)) "\"")))) (keys attrs))))) @@ -323,6 +350,10 @@ ;; (set-attribute el k v) → void ;; (append-child parent c) → void ;; +;; StyleValue: +;; (style-value? x) → boolean (is x a StyleValue?) +;; (style-value-class sv) → string (CSS class name) +;; ;; Serialization: ;; (serialize val) → SX source string representation of val ;;