Emit a warning when a `match` expression on an ADT value misses one
or more constructors and lacks an `else`/`_` clause. Behaviour is
non-fatal — the match still runs, the warning goes to stderr.
- spec/evaluator.sx: helpers `match-clause-is-else?`, `match-clause-ctor-name`,
`match-warn-non-exhaustive`, `match-check-exhaustiveness`. The latter
reads the `*adt-registry*` (already populated by `define-type`),
collects constructor patterns from clauses, and dedupes via an
`*adt-warned*` env-bound dict so each (type, missing-set) warns once.
Wired into `step-sf-match` via a `do` block before clause dispatch.
- hosts/javascript/platform.py: `host-warn` primitive (`console.warn`)
+ matching `hostWarn` js-id helper so the JS-transpiled spec code
can call it directly. Spec code reaches JS via `sx_build target=js`.
- hosts/ocaml/lib/sx_runtime.ml + sx_primitives.ml: `host-warn` runtime
helper (`prerr_endline`) and registered primitive.
- hosts/ocaml/lib/sx_ref.ml: HAND-PATCHED. `step_sf_match` now calls
a hand-written `match_check_exhaustiveness` that handles both
`AdtValue` and back-compat dict-shape ADT values. The OCaml side
is *not* retranspiled because regenerating sx_ref.ml drops
several preamble fixes (seq_to_list, string->symbol mangling,
empty-dict literal bug). Future retranspile must reapply this patch.
- spec/tests/test-adt.sx: 5 new tests covering exhaustive,
non-exhaustive (warning is non-fatal), `else` suppression,
partial coverage with one missing constructor, and `_` wildcard
suppression. Tests assert return values only — warnings go to
stderr and are not captured.
Warning format: `[sx] match: non-exhaustive — TypeName: missing Ctor1, Ctor2`
Both hosts emit identical messages.
Tests: OCaml 4540 → 4545 (+5), JS 2586 → 2591 (+5). Zero regressions.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Mirror of OCaml Step 5 to the JavaScript host. Native ADT representation
for define-type instances, with the same dict-shaped shim approach so
spec-level match-pattern code in evaluator.sx works without changes.
- platform.py typeOf: recognize ._adtv tag, return ._type (so
(type-of (Just 42)) returns "Maybe" not "dict").
- platform.py adds makeAdtValue/isAdtValue helpers and registers
PRIMITIVES["adt?"], "make-adt-value", "adt-value?".
- platform.py inspect: format AdtValue as "(Ctor f1 f2 ...)" and
register as a primitive (was missing entirely on JS).
- fixups_js: hand-written define-type override that constructs
AdtValue via makeAdtValue, with arity check, type/ctor predicates,
and field accessors. Re-registered via registerSpecialForm so the
CEK dispatch routes through it.
- dict? unchanged: AdtValue still passes (no _adtv exclusion) so
the existing (and (dict? v) (get v :_adt) ...) checks in spec
predicates keep working.
Tests: 2578 pass (was 2575), zero regressions. All 43 ADT tests
pass on the JS host (was 40, the 3 new Step 5 tests for type-of /
adt? / inspect are now green).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Extend hs-make-token to (type value pos &rest extras) producing dicts
{:pos :end :line :value :type}. End defaults to pos+len(value); line
defaults to 1. Both tokenize loops now track current-line via newline
counting in advance!. hs-emit! and t-emit! pass the right end and
start-line to the constructor; redundant dict-set! after construction
removed.
Mirror copied to shared/static/wasm/sx/hs-tokenizer.sx (byte-identical).
Verify: (hs-make-token "NUMBER" "1" 0) returns
{:pos 0 :end 1 :line 1 :value "1" :type "NUMBER"}.
OCaml suite: 4529 pass, 1339 pre-existing failures (baseline). All
4/4 hs-upstream-core/sourceInfo tests now pass (was 2/4 — closes E38).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Parser: bracket-open in obj-collect key cond → (computed-key expr).
Compiler: detect computed-key list at object-literal pair key and compile
the inner expression instead of emitting a literal string.
Generator: special case for 'expressions work in object literal field names'
using eval-hs-locals with host-callback so hs-win-call can find the fn.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Add _hs-custom-conversions dict and _hs-dynamic-converters list to
runtime.sx. hs-set-conversion!/hs-clear-conversion!/hs-add-dynamic-converter!/
hs-pop-dynamic-converter!/hs-clear-converters! helpers expose the API.
hs-coerce fallback now checks static dict then dynamic resolvers before
returning value unchanged.
Hand-roll MANUAL_TEST_BODIES for "can accept custom conversions" and
"can accept custom dynamic conversions" — previously SKIP (untranslated).
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Parser: add 'the ...' as a recognized transition target in parse-transition-cmd's
tgt cond, enabling 'transition the next <div/>'s *width from A to B'.
Generator MANUAL_TEST_BODIES for 4 previously-SKIP tests:
- can transition on query ref with possessive (transition suite, 17/17)
- can write to next element with put command (relativePositionalExpression, 23/23)
- parse error at EOF on trailing newline does not crash (core/parser, 13/14)
- halt works outside of event context (halt suite, 7/7)
Also fix hs-kernel-eval.js navigator assignment for Node.js v22 (read-only global).
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
parse-feat true fallback now routes directly to parse-cmd-list when the first
token is a keyword (e.g. "add - to"), so command-keyword scripts always produce
parse errors rather than being treated as subtraction expressions. Non-keyword
tokens (numbers, identifiers, paren-open) still try expression-first.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Three parse-cmd / parse-feat refinements:
1. Remove dict-branch from arith guard: span-mode=true produces dict nodes
with :kind "arith", not lists. The guard only needs the list-branch (for
span-mode=false). Without this, hs-src "x + y" threw a parse error.
2. parse-feat top-level expression-first fallback: when no feature keyword is
found, try parse-expr first. If it fully consumes the input (at-end?),
return the expression directly — bypassing parse-cmd and its arith guard.
This matches upstream _hyperscript("1 + 1") which evaluates as an
expression, not a pseudo-command.
3. paren-close exception in arith guard: when the token after the arithmetic
expression is ")", we are inside a parenthesised context (e.g. "(0+1) em"
string-postfix). Allow it through without the pseudo-command error.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
The previous callable check (0bef67dd) was too strict, rejecting legitimate
pseudo-commands like 'as' conversions, array literals, and property accesses.
The new approach:
- at-end? returns nil (trailing-then EOF guard, unchanged)
- arithmetic expressions (op symbols +/-/*//%) throw 'Pseudo-commands must
be function calls', matching upstream _hyperscript behaviour
- everything else (literals, calls, as-expr, arrays, refs) passes through
Handles both hs-span-mode=false (raw list with op as first) and true (dict
with :kind "arith"). pseudoCommand 11/11, asExpression 36/42, arrayLiteral
8/8, breakpoint 2/2, evalStatically 8/8, regressions 16/16.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
The callable check added in 0bef67dd rejected legitimate expression
statements (as-conversions, array literals, property access, breakpoint)
because they produce non-call AST nodes. The at-end? guard already handles
the trailing-then EOF case; the callable check is redundant and wrong.
Removing it restores the original open fallback: any parse-expr result is
a valid command. arrayLiteral 8/8, breakpoint 2/2, asExpression +35,
evalStatically +5, regressions +3.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
- install BehaviorName: parse-set-cmd handles `element` separately so
`element's foo` after `set` invokes parse-poss rather than parse-expr,
fixing `set element's bar["count"] to X` inside behavior bodies
- parse-poss-tail ident case: call parse-poss (handles `[`) instead of
parse-prop-chain (does not) when next token is bracket-open
- hs-activate!: replace (handler el) with host-call-fn safe wrapper so
native OCaml "Undefined symbol" throws (which bypass SX guard frames)
are caught at the JS api_call_fn boundary rather than propagating
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Three-part fix for element-scoped reactive expressions:
1. Parser: add when/bind to parse-cmd's feature-keyword nil set so
`... then when X changes ...` is parsed as a new feature, not absorbed
into the preceding on-handler body as a (ref "when") expression.
2. Parser: parse-when-feat now recognises local (:var) token type so
`when :count changes ...` dispatches to the when-changes branch.
3. Runtime + compiler: hs-scoped-set! now fires hs-scoped-fire-watchers!
on change; new hs-scoped-watch! / hs-scoped-fire-watchers! registry;
compiler emits (hs-scoped-watch! me name (fn (it) body)) for local
expressions in when-changes AST nodes.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Three-part fix for hs-upstream-core/asyncError test 2/2:
1. runtime.sx hs-win-call: when an async call returns a rejected promise,
store the error value in window.__hs_async_error (side-channel) and
raise the sentinel "__hs_async_error__" so the value survives the
raise boundary intact.
2. compiler.sx catch clause: inject `(let ((var (host-hs-normalize-exc var))) ...)`
around the catch body so the sentinel gets swapped for the real error
object before user code runs. Uses let (not set!) so shadowing works
correctly for guard catch variables.
3. tests/hs-run-filtered.js:
- host-promise-state wraps JS Error objects as plain {message:...} dicts
before they cross the WASM boundary (Error.toString() was producing
"Error: boom" strings instead of accessible objects)
- host-hs-normalize-exc native retrieves the side-channel value when
the sentinel arrives in a catch variable
- host-get coercion restricted to El instances — plain JS objects with
a "value" key were being stringified to "[object Object]"
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Add `bind` keyword to tokenizer, parse-bind-feat to parser, and
bind-feat no-op case to compiler. Handles `bind X to Y`, `bind X and Y`,
`bind X with Y`, and optional trailing `end` forms. All 43/44 bind tests
pass (1 is an explicit skip).
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Add (when (not (nil? target)) ...) guards after every hs-null-raise!
call in both the compiler and runtime so execution stops cleanly when
a DOM element is not found, instead of continuing into a JS operation
on null that takes ~34 seconds to propagate.
Compiler: emit-set dot/poss, emit-inc/dec poss case, remove-element,
remove-attr, add-styles all now wrap the action after hs-null-raise!
in a nil guard.
Runtime: hs-toggle-class!, hs-toggle-between!, hs-dispatch!,
hs-set-attr!, hs-toggle-attr!, hs-set-inner-html!, hs-put!,
hs-transition all guarded — hs-settle and hs-measure already were.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
parse-feat's paren-open handler stripped the grouping parens and
returned the inner feature, leaving any trailing ident (like `em`)
as a separate top-level feature. After consuming the closing paren,
now checks if the next token is a non-keyword ident or `%` op and
wraps as (string-postfix inner unit), making `(0 + 1) em` → "1em".
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Two fixes:
(1) compiler.sx: remove `it` from hs-reserved-var?. `it` is the standard
HS loop variable for `repeat in` loops; renaming it to `_hs_lv_it` made
the body reference the outer (nil) `it` rather than the bound element.
Other reserved vars (meta, event, result) still get renamed to prevent
shadowing built-ins in misnamed loops.
(2) runtime.sx: hs-make-object now appends an `_order` list tracking
insertion order, mirroring the pattern used by other dict-building paths.
Without this, `for prop in obj` fell back to `(keys obj)` which gives
non-deterministic key order for objects with string keys.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
When parse-feat returns nil but the token stream is not at EOF,
coll-feats now throws a parse error ('Unexpected token X') instead
of silently returning the partial result. Fixes 'extra chars cause
error when evaling': eval-hs("1!") now correctly throws because '!'
is left over after parsing the number expression.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
- parse-on-feat: event-vars paren check now restores position and returns empty
list when the first token after '(' is a keyword (command starter). Previously
'(log me)' was consumed as event variable names instead of a parenthesized
command, silently dropping the command body and returning empty innerHTML.
Fixes 'can support parenthesized commands and features'.
- parse-add-cmd: true-fallback now throws instead of returning nil when no 'to'
keyword follows the expression. Makes 'add - to' and similar invalid add forms
throw a parse error, satisfying assert-throws in 'basic parse error messages
work' and '_hyperscript() evaluate API still throws on first error'.
- read-class-name: '(' and ')' now only allowed inside '[...]' bracket groups
(depth > 0). Previously allowing them at top level caused '.innerHTML)' at the
end of a possessive expression to be consumed into the class token, producing
'innerHTML))' as a bogus property name. Tailwind classes like
'group-[:nth-of-type(3)_&]:block' still tokenize correctly.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
- parser: `toggle $var between v1 and v2 ...` → `(toggle-var-cycle $var (v1 v2 ...))`
- compiler: emit `(hs-toggle-var-cycle! win var-name values)` for new AST node
- runtime: `hs-toggle-var-cycle!` cycles through a list of values on a variable
- parser: `closest .sel to .target` / `closest #id to .target` / `closest sel to .target`
now consumes the `to` keyword and parses the target expr instead of defaulting to beingTold
- tokenizer: `read-class-name` handles backslash escapes and allows `(`, `)`, `&`
chars so Tailwind classes like `group-[:nth-of-type(3)_&]:block` tokenize correctly
- platform.py: `domListen` drives async result via `_driveAsync` after `cekCall`
- test: fixed-time toggle asserts `.foo` IS present after click (toggle started, 10ms window open)
- generate-sx-tests.py: aligned MANUAL_TEST_BODIES for timed toggle with corrected assertion
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
- parse-halt-cmd: after consuming 'the event's', check for 'bubbling'
token and return "bubbling" mode instead of "the-event"
- parse-wait-cmd: skip article words (a/an/the) before reading event
name, so 'wait for a customEvent' works correctly
- parse-on-feat: parse optional (vars) paren group before flt and
consume-having!, so 'on intersection(intersecting) having ...' works;
inject event-var refs into body for compiler's event-refs mechanism
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
- parser: nil return in parse-cmd for feature keywords (on/init/def/behavior/live)
so "then on click" correctly hands off to outer coll-feats loop
- compiler: cek-try wrap for undefined variable refs in coll-where compilation
so "doesNotExist where it > 1" returns nil instead of throwing
- integration: hs-activate! detects script[type=text/hyperscript-template] and
applies handler to DOM instances via hs-query-all(component attr) not to script el
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
- parser.sx: parse-logical now rejects mixed and/or without parens
- parser.sx: parse-arith now rejects mixed +/-/* //%/mod without parens
- generate-sx-tests.py: MANUAL_TEST_BODIES for short-circuit and/or,
typecheck (direct hs-type-assert calls), template string test
- generate-sx-tests.py: Pattern 5 for error("expr") -> assert-throws
- hs-run-filtered.js: redefine try-call to _run-test-thunk after loading
so assert-throws actually catches exceptions (was always {ok true})
- hs-run-filtered.js: clear __hs_deadline immediately after test eval
to prevent cascading timeout fires in result inspection K.eval calls
- hs-run-filtered.js: typecheck suite in _NO_STEP_LIMIT_SUITES and
_SLOW_DEADLINE_SUITES (hs-type-assert JIT is slow on first call)
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Capture raised exception in a let-bound variable before the guard
exits, then re-raise after. Avoids the WASM OCaml kernel bug where
(raise e) called from within a guard handler re-invokes the same
handler infinitely.
Affects hs-repeat-forever, hs-repeat-times, hs-repeat-while,
hs-repeat-until, hs-for-each. Repeat suite: 25/30 → 28/29 counted
(1 skipped: 'until event keyword works' requires async event dispatch).
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Adds 9 regexp primitives to stdlib.regexp. OCaml: SxRegexp(src,flags,Re.re)
using Re.Pcre; $&/$1 capture expansion in replace. JS: native RegExp
with SxRegexp wrapper; regexp-match returns {:match :start :end :groups}.
32 tests in test-regexp.sx, all pass on both hosts.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Adds 13 set primitives to stdlib.sets. OCaml: SxSet as (string,value)
Hashtbl keyed by inspect(val); JS: SxSet wrapping Map keyed by
write-to-string. Structural equality — (make-set '(1 2)) contains 1.
Includes union, intersection, difference, for-each, map.
33 tests in test-sets.sx, all pass on both JS and OCaml.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Adds read, write, display, newline, write-to-string, display-to-string
and current-*-port primitives to both JS and OCaml hosts.
JS: sxReadNormalize (#t/#f→true/false), sxReadConvert (()→nil),
sxEq array comparison, sxWriteVal symbol/keyword name fix,
readerMacroGet/readerMacroSet registry in parser platform.
OCaml: sx_write_val/sx_display_val helpers, read/write/display/newline
primitives on port types; parser extended for #t/#f and N/D rationals.
42 new tests (test-read-write.sx), all passing on JS and OCaml.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
SxRational type in OCaml (Rational of int * int, stored reduced, denom>0)
and JS (SxRational class with _rational marker). n/d reader syntax in
spec/parser.sx. Arithmetic contagion: int op rational → rational, rational
op float → float. JS keeps int/int → float for CSS backward compatibility.
OCaml as_number + safe_eq extended for cross-type rational equality so
(= 2.5 5/2) → true. 62 tests in test-rationals.sx, all pass.
JS: 2232 passed. OCaml: 4532 passed (+11 vs pre-fix baseline).
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Phase 14: port type + eof-object. Input ports track _pos cursor; output ports
accumulate _buffer. All 15 port primitives in spec/primitives.sx (stdlib.ports
module), platform.py (JS), and 39/39 tests in spec/tests/test-ports.sx.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
- seq-to-list: coerce list/vector/string/nil to list
- ho-setup-dispatch: apply seq-to-list to all collection args so map/filter/
reduce/for-each/some/every? work over vectors and strings natively
- sequence->list, sequence->vector, sequence-length, sequence-ref,
sequence-append: full polymorphic sequence helpers
- in-range: list-returning range generator (eager, works with all HO forms)
- Restore 3 accidentally-deleted make-cek-state/make-cek-value/make-cek-suspended
- Fix 8 shorthand define forms (transpiler requires long form)
- Add vector->list/list->vector to transpiler js-renames + platform aliases
- JS: 2137 passing (+28 vs HEAD baseline)
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
25 tests pass on both JS and OCaml hosts. Uses dict marker
{:_values true :_list [...]} for 0/2+ values; 1 value passes
through directly. step-sf-define extended to desugar shorthand
(define (name params) body) forms on both hosts.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
parse-on-feat now skips 'queue MODE' tokens before parsing the body,
so 'on foo queue first ...' and 'on foo queue last ...' parse correctly.
Compiler ignores queue mode (catch-all drops unknown parts).
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Parser: parse-set-cmd now emits (set-el! target value) when target is
a query node (e.g. #id, .class), keeping (set! ...) for all other
targets.
Compiler: add (set-el! ...) handler that calls hs-set-element!; revert
emit-set for query targets back to hs-set-inner-html! so that
put "x" into #target keeps setting innerHTML rather than replacing
the element.
Runtime: hs-set-element! new function — parses value as HTML into a
temp div; if it contains element children, replaces the target element
via replaceChild and boots hyperscript on the new element; otherwise
falls through to hs-set-inner-html!. Removes the spurious
host-to-list wrapper that was causing len() to always return 0.
Result: all 8 assignableElements tests pass (set #id / set .class /
set closest / swap, plus put-into-still-works-as-innerHTML).
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
- hs-value-of-node: use selectedIndex fallback when SELECT.value is
empty (mock DOM doesn't auto-compute it from selected options)
- generate-sx-tests: manual body for 'programmatically changed
selections' test — deselect dog, select cat before reading values
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
- parse-atom: unrecognized keywords (e.g. index) fall back to ref,
fixing 'set index to N' parse failure
- hs-set-inner-html!: join list values as "" so 'put [A,C] into el'
concatenates strings not [object Object]
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Add style case to the of-target compiler branch so
'set *color of #el to x' emits dom-set-style correctly.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Store target element in meta.owner when hs-on fires;
hs-fetch-impl dispatches beforeFetch on it before the perform.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
Track halt mode via __hs-no-stop flag; skip stopPropagation when
handler raised hs-halt-default (from 'halt default'). All other
halt variants (halt, halt the event, halt bubbling) unchanged.
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
- compiler: wrap catch body in nested guard so (raise e) inside a
catch handler defers the re-raise until after the guard exits,
avoiding the handler-stays-active infinite loop
- generator: MANUAL_TEST_BODIES for rethrown/uncaught exception events,
can-pick-detail/event-property, bootstrap bootstraps; remove from
skip-list; regenerate behavioral spec
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
