Swap order for catch operator

Author: dy

.github/copilot-instructions.md

@@ -1,6 +1,7 @@
 Avoid writing to `lookup`, use token instead.
 Avoid ad-hocs - that signals inconsistency of design. High-level API is for a reason, we need to use it and if it doesn't fit, we need to improve it.
 `/features` represent generic language features, not only JS: avoid js-specific checks.
+AST should be faithful to source tokens - don't normalize or assume C-like semantics. If a language has `elif`/`elsif` tokens, preserve them in AST rather than converting to nested `else if`. Parse what's written, don't invent structure.
 For features you implement or any changes, if relevant please add tests, update spec.md, docs.md and README.md, as well as REPL and other relevant files. Make sure tests pass.
 Make sure API and feature code is intuitive and user-friendly: prefer `unary`/`binary`/`nary`/`group`/`token` calls in the right order ( eg. first `|`, then `||`, then `||=` ) rather than low-level parsing. Eg. feature should not use `cur`, `idx` and use `skip` instead.
 The project is planned to be built with jz - simple javascript subset compiling to wasm, so don't use complex structures like Proxy, classes etc.

.work/research.md

@@ -0,0 +1,123 @@
+## AST Structure Decisions
+
+### AST vs CST (2026-02-01)
+
+**Decision:** Subscript produces AST (Abstract Syntax Tree), not CST (Concrete Syntax Tree).
+
+| Type | Purpose | Preserves | Use case |
+|------|---------|-----------|----------|
+| CST | Source-faithful | All tokens, whitespace | Formatters, refactoring |
+| AST | Semantic structure | Meaning only | Compilers, evaluators |
+
+**Implications:**
+- Delimiters like `()` `{}` stripped when purely syntactic
+- Keywords preserved when they carry meaning (`catch`, `finally`)
+- Normalization happens in parser, not compiler
+- Lisp tradition: `(if cond then else)` not `(if cond then (else body))`
+
+---
+
+### Delimiter Handling (2026-02-01)
+
+**Principle:** Strip delimiters when purely syntactic, keep when semantic.
+
+| Construct | Parens meaning | Result |
+|-----------|---------------|--------|
+| `if (cond)` | Required syntax | Strip → `['if', cond, ...]` |
+| `while (cond)` | Required syntax | Strip → `['while', cond, ...]` |
+| `f(a, b)` | Call operator | Keep → `['()', 'f', ...]` |
+| `(a, b) => x` | Grouping | Keep → `['=>', ['()', ...], ...]` |
+
+**Why arrow keeps `['()']`:** Distinguishes `a => x` from `(a) => x`. Also, Python would need this to distinguish tuple `(a, b)` from grouping.
+
+**Core helper:** `parens()` in parse.js strips and returns content. Features use it when parens are syntactic.
+
+---
+
+### Try/catch structure (2026-02-01)
+
+**Decision:** Keywords as operators: `['try', body, ['catch', param, handler]?, ['finally', cleanup]?]`
+
+**Rationale:**
+- `catch` and `finally` are distinct keywords deserving operator status
+- Clean optional structure - just omit the clause
+- No null padding needed
+- Dialect-friendly: Python `except`, Ruby `rescue` become their own operators
+
+**Examples:**
+```
+try { a } catch (e) { b }       → ['try', 'a', ['catch', 'e', 'b']]
+try { a } finally { c }         → ['try', 'a', ['finally', 'c']]
+try { a } catch (e) { b } finally { c } → ['try', 'a', ['catch', 'e', 'b'], ['finally', 'c']]
+```
+
+---
+
+### If-else-if chains (2026-02-01)
+
+  **Decision:** `['if', cond, then, ['if', cond2, then2, else]]` for C-family
+
+  **Rejected alternatives:**
+  1. `['if', c, t, ['else', ['if', ...]]]` — `else` isn't an operator, just positional marker
+  2. `['if', c1, t1, c2, t2, else]` — flat chain loses structure, hard to delimit
+
+  **Rationale:**
+  - JS/C have no `else if` token — else branch contains if statement
+  - Position 4 = else branch, which can be any expression including another if
+  - Minimal structure: no invented wrappers
+  - Compiles trivially: `c(ctx) ? t(ctx) : e?.(ctx)`
+
+  **Dialect handling:**
+  - Python `elif` IS a keyword → `['if', c, t, ['elif', c2, t2, ['else', e]]]`
+  - Ruby `elsif` IS a keyword → `['if', c, t, ['elsif', c2, t2, ['else', e]]]`
+  - The operator name reflects the source token
+
+  **Principle:** Use C tokens as universal semantic structure. Dialects that have distinct keywords (elif, elsif) preserve them. Dialects that don't (JS else-if) don't invent them.
+
+  ### Try-catch structure (2026-02-01)
+
+  **Decision:** Flat `['try', body, param, catch, finally?]`
+
+  **Rejected:** Wrapped `['finally', ['catch', ['try', body], ...], ...]`
+
+  **Rationale:**
+  - Consistent with if: flat positional args
+  - One node per statement, not nested operators
+  - `null` for missing parts: `['try', body, null, null, finally]`
+
+  **Dialect handling:**
+  - Python: `['try', body, 'e', except, ['else', e], finally]` (try-except has else!)
+  - Ruby: `['begin', body, 'e', rescue, ensure]`
+
+## Design Principles
+
+  ### Token Customization
+
+  Just as precedence is customizable via `prec()`, tokens should be customizable per dialect.
+
+  Current: Features hardcode keywords (`keyword('try')`)
+
+  Future possibility:
+  ```js
+  // Feature exports factory
+  export default (tokens = {try:'try', catch:'catch', finally:'finally'}) => {
+    keyword(tokens.try, ...)
+  }
+  ```
+
+  This allows:
+  - **subscript.js**: default C/JS tokens
+  - **worm.js** (Python): `{try:'try', catch:'except', finally:'finally', throw:'raise'}`
+  - **subruby.js**: `{try:'begin', catch:'rescue', finally:'ensure', throw:'raise'}`
+
+  ### C as Universal Foundation
+
+  C-like tokens serve as **canonical semantic representation**, not because C is superior, but because:
+  1. Widely understood baseline
+  2. Minimal syntax (no significant whitespace)
+  3. Most languages have C-family equivalents
+
+  Other dialects parse TO this structure (with their tokens), enabling:
+  - Cross-compilation: Python AST → JS output
+  - Universal tooling: one AST walker works for all
+  - Round-trip within dialect: preserves source tokens

todo.md .work/todo.mdtodo.md renamed to .work/todo.md

@@ -24,15 +24,15 @@ fn({ a: 1, b: 3 })  // 7
 
 ## Presets
 
-**Subscript** – common expressions:
+[**Subscript**]() – common expressions:
 
 ```js
 import subscript from 'subscript'
 
 subscript('a.b + c * 2')({ a: { b: 1 }, c: 3 })  // 7
 ```
 
-**Justin** – JSON + expressions + templates + arrows:
+[**Justin**]() – JSON + expressions + templates + arrows:
 
 ```js
 import justin from 'subscript/justin.js'
@@ -41,7 +41,7 @@ justin('{ x: a?.b ?? 0, y: [1, ...rest] }')({ a: null, rest: [2, 3] })
 // { x: 0, y: [1, 2, 3] }
 ```
 
-**Jessie** – JSON + expressions + statements, functions (JS subset):
+[**Jessie**]() – JSON + expressions + statements, functions (JS subset):
 
 ```js
 import jessie from 'subscript/jessie.js'

README.md

@@ -1,14 +1,27 @@
 // try/catch/finally/throw statements
-// AST: ['catch', ['try', body], param, catchBody] or ['finally', inner, body]
-import { space, parse, parens, expr, operator, compile } from '../parse.js';
-import { keyword, infix, block } from './block.js';
+// AST (faithful): ['try', body, ['catch', param, handler]?, ['finally', cleanup]?]
+// Note: body/handler are raw block results, param is raw parens result
+import { space, parse, parens, expr, word, skip, operator, compile } from '../parse.js';
+import { keyword, block } from './block.js';
 import { BREAK, CONTINUE, RETURN } from './control.js';
 
 const STATEMENT = 5;
 
-keyword('try', STATEMENT + 1, () => ['try', block()]);
-infix('catch', STATEMENT + 1, a => (space(), ['catch', a, parens(), block()]));
-infix('finally', STATEMENT + 1, a => ['finally', a, block()]);
+// try { body } [catch (param) { handler }] [finally { cleanup }]
+keyword('try', STATEMENT + 1, () => {
+  const node = ['try', block()];
+  space();
+  if (word('catch')) {
+    skip(5); space();
+    node.push(['catch', parens(), block()]);
+  }
+  space();
+  if (word('finally')) {
+    skip(7);
+    node.push(['finally', block()]);
+  }
+  return node;
+});
 
 keyword('throw', STATEMENT + 1, () => {
   parse.asi && (parse.newline = false);
@@ -17,39 +30,33 @@ keyword('throw', STATEMENT + 1, () => {
   return ['throw', expr(STATEMENT)];
 });
 
-// Compile
-operator('try', tryBody => {
+// Compile try - normalize in compiler, not parser
+operator('try', (tryBody, ...clauses) => {
   tryBody = tryBody ? compile(tryBody) : null;
-  return ctx => tryBody?.(ctx);
-});
+  
+  let catchClause = clauses.find(c => c?.[0] === 'catch');
+  let finallyClause = clauses.find(c => c?.[0] === 'finally');
+  
+  const catchParam = catchClause?.[1];
+  const catchBody = catchClause?.[2] ? compile(catchClause[2]) : null;
+  const finallyBody = finallyClause?.[1] ? compile(finallyClause[1]) : null;
 
-operator('catch', (tryNode, catchName, catchBody) => {
-  const tryBody = tryNode?.[1] ? compile(tryNode[1]) : null;
-  catchBody = catchBody ? compile(catchBody) : null;
   return ctx => {
     let result;
     try {
       result = tryBody?.(ctx);
     } catch (e) {
       if (e === BREAK || e === CONTINUE || e === RETURN) throw e;
-      if (catchName !== null && catchBody) {
-        const had = catchName in ctx, orig = ctx[catchName];
-        ctx[catchName] = e;
+      if (catchParam !== null && catchParam !== undefined && catchBody) {
+        const had = catchParam in ctx, orig = ctx[catchParam];
+        ctx[catchParam] = e;
         try { result = catchBody(ctx); }
-        finally { had ? ctx[catchName] = orig : delete ctx[catchName]; }
-      } else if (catchName === null) throw e;
+        finally { had ? ctx[catchParam] = orig : delete ctx[catchParam]; }
+      } else if (!catchBody) throw e;
+    }
+    finally {
+      finallyBody?.(ctx);
     }
-    return result;
-  };
-});
-
-operator('finally', (inner, finallyBody) => {
-  inner = inner ? compile(inner) : null;
-  finallyBody = finallyBody ? compile(finallyBody) : null;
-  return ctx => {
-    let result;
-    try { result = inner?.(ctx); }
-    finally { finallyBody?.(ctx); }
     return result;
   };
 });

feature/try.js

@@ -174,15 +174,7 @@ Template literals contain string parts (as literals) interleaved with expression
 
 ### Statements (jessie)
 
-ASI (Automatic Semicolon Insertion) treats newlines as statement separators, producing flat `;` arrays:
-```
-a; b        → [';', 'a', 'b']
-a\nb        → [';', 'a', 'b']       (ASI inserts ;)
-a; b; c     → [';', 'a', 'b', 'c']
-a\nb\nc     → [';', 'a', 'b', 'c']  (flat, not nested)
-```
-
-Control flow:
+### Control flow
 ```
 ['if', cond, then]            if (cond) then
 ['if', cond, then, else]      if (cond) then else alt
@@ -203,10 +195,10 @@ Control flow:
 
 ### Exceptions (feature/throw.js, feature/try.js)
 ```
-['throw', val]                              throw val
-['catch', ['try', body], 'e', handler]      try { body } catch (e) { handler }
-['finally', ['try', body], handler]         try { body } finally { handler }
-['finally', ['catch', ...], handler]        try {...} catch {...} finally {...}
+['throw', val]                                  throw val
+['try', body, ['catch', 'e', handler]]          try { body } catch (e) { handler }
+['try', body, ['finally', cleanup]]             try { body } finally { cleanup }
+['try', body, ['catch', 'e', h], ['finally', c]] try {...} catch {...} finally {...}
 ```
 
 ### Function Declarations (feature/function.js)
@@ -256,7 +248,20 @@ Postfix operators use `null` to mark the absent second operand:
 
 This preserves structural consistency without inventing new node types.
 
-### 5. Flat Sequences
+
+### 5. AST, not CST
+
+This is an Abstract, not Concrete Syntax Tree.
+The parser normalizes syntax to semantic structure.
+Delimiters like `()` `{}` are stripped when purely syntactic; operators preserve meaning.
+
+| Type | Purpose | Example |
+|------|---------|---------|
+| CST | Preserve source exactly | Formatters, refactoring tools |
+| AST | Semantic structure | Compilers, evaluators |
+
+
+### 6. Flat Sequences
 
 Associative operators flatten:
 ```
@@ -265,7 +270,7 @@ a + b + c  →  ['+', 'a', 'b', 'c']    // not ['+', ['+', 'a', 'b'], 'c']
 
 This reflects execution semantics and enables SIMD-style optimization.
 
-### 6. Location Metadata
+### 7. Location Metadata
 
 Nodes may carry a `.loc` property indicating source position:
 ```js
@@ -340,11 +345,11 @@ for (x in obj) {}         → ['for', ['in', 'x', 'obj'], body]
 for (;;) {}               → ['for', [';', null, null, null], body]
 ```
 
-**Try/catch** — uses `catch`/`finally` as operators:
+**Try/catch** — keywords preserved as operators:
 ```
-try { a } catch (e) { b }     → ['catch', ['try', 'a'], 'e', 'b']
-try { a } finally { c }       → ['finally', ['try', 'a'], 'c']
-try { a } catch (e) { b } finally { c }  → ['finally', ['catch', ['try', 'a'], 'e', 'b'], 'c']
+try { a } catch (e) { b }                 → ['try', 'a', ['catch', 'e', 'b']]
+try { a } finally { c }                   → ['try', 'a', ['finally', 'c']]
+try { a } catch (e) { b } finally { c }   → ['try', 'a', ['catch', 'e', 'b'], ['finally', 'c']]
 ```
 
 **Functions** — name and params are tokens:

spec.md

@@ -141,24 +141,30 @@ test('jessie: try basic', () => {
 
 test('jessie: try-catch', () => {
   const ast = parse('try { x } catch (e) { y }')
-  is(ast[0], 'catch')
-  is(ast[1][0], 'try')
-  is(ast[2], 'e')
-  is(ast[3], 'y')
+  is(ast[0], 'try')
+  is(ast[1], 'x')
+  is(ast[2][0], 'catch')
+  is(ast[2][1], 'e')
+  is(ast[2][2], 'y')
 })
 
 test('jessie: try-finally', () => {
   const ast = parse('try { x } finally { y }')
-  is(ast[0], 'finally')
-  is(ast[1][0], 'try')
-  is(ast[2], 'y')
+  is(ast[0], 'try')
+  is(ast[1], 'x')
+  is(ast[2][0], 'finally')
+  is(ast[2][1], 'y')
 })
 
 test('jessie: try-catch-finally', () => {
   const ast = parse('try { a } catch (e) { b } finally { c }')
-  is(ast[0], 'finally')
-  is(ast[1][0], 'catch')
-  is(ast[2], 'c')
+  is(ast[0], 'try')
+  is(ast[1], 'a')
+  is(ast[2][0], 'catch')
+  is(ast[2][1], 'e')
+  is(ast[2][2], 'b')
+  is(ast[3][0], 'finally')
+  is(ast[3][1], 'c')
 })
 
 test('jessie: throw', () => {
@@ -519,15 +525,15 @@ test('jessie: JSON roundtrip - for loops', () => {
 test('jessie: JSON roundtrip - try/catch', () => {
   let ast = parse('try { a } catch (e) { b }')
   let restored = JSON.parse(JSON.stringify(ast))
-  is(restored, ['catch', ['try', 'a'], 'e', 'b'])
+  is(restored, ['try', 'a', ['catch', 'e', 'b']])
 
   ast = parse('try { a } finally { c }')
   restored = JSON.parse(JSON.stringify(ast))
-  is(restored, ['finally', ['try', 'a'], 'c'])
+  is(restored, ['try', 'a', ['finally', 'c']])
 
   ast = parse('try { a } catch (e) { b } finally { c }')
   restored = JSON.parse(JSON.stringify(ast))
-  is(restored, ['finally', ['catch', ['try', 'a'], 'e', 'b'], 'c'])
+  is(restored, ['try', 'a', ['catch', 'e', 'b'], ['finally', 'c']])
 })
 
 test('jessie: JSON roundtrip - functions', () => {