Make more JSON-friendly

Author: dy

feature/literal.js

@@ -2,12 +2,16 @@
  * Literal values
  *
  * true, false, null, undefined, NaN, Infinity
+ *
+ * Note: undefined uses [] (empty array) for JSON round-trip compatibility.
+ * [, undefined] serializes to [null, null] which would compile to null.
+ * [] serializes to [] and compiles back to undefined.
  */
-import { literal } from '../parse.js';
+import { literal, token } from '../parse.js';
 
 literal('true', true);
 literal('false', false);
 literal('null', null);
-literal('undefined', undefined);
+token('undefined', 200, a => !a && []);  // [] for JSON compatibility
 literal('NaN', NaN);
 literal('Infinity', Infinity);

feature/regex.js

@@ -1,14 +1,18 @@
 /**
  * Regex literals: /pattern/flags
  *
- * AST:
- *   /abc/gi  → [, /abc/gi]
+ * AST (constructor form, JSON-serializable):
+ *   /abc/gi  → ['//', 'abc', 'gi']
+ *   /abc/    → ['//', 'abc']
  *
  * Note: Disambiguates from division by context:
  *   - `/` after value = division (falls through to prev)
  *   - `/` at start or after operator = regex
+ *
+ * Compile:
+ *   ['//', 'abc', 'gi']  → new RegExp('abc', 'gi')
  */
-import { token, skip, err, next, idx, cur } from '../parse.js';
+import { token, skip, err, next, idx, cur, operator } from '../parse.js';
 
 const PREFIX = 140, SLASH = 47, BSLASH = 92;
 
@@ -26,6 +30,16 @@ token('/', PREFIX, a => {
   cur.charCodeAt(idx) === SLASH || err('Unterminated regex');
   skip(); // consume closing /
 
-  try { return [, new RegExp(pattern, next(regexFlag))]; }
+  const flags = next(regexFlag);
+  // Validate regex syntax
+  try { new RegExp(pattern, flags); }
   catch (e) { err('Invalid regex: ' + e.message); }
+
+  return flags ? ['//', pattern, flags] : ['//', pattern];
+});
+
+// Compile: ['//', pattern, flags?] → RegExp
+operator('//', (a, b) => {
+  const re = new RegExp(a, b || '');
+  return () => re;
 });

parse.js

@@ -137,9 +137,10 @@ export const operator = (op, fn, prev = operators[op]) =>
   (operators[op] = (...args) => fn(...args) || prev?.(...args));
 
 // Compile AST to evaluator function
+// Note: [, value] serializes to [null, value] in JSON, both forms accepted
 export const compile = node => (
   !Array.isArray(node) ? (node === undefined ? () => undefined : ctx => ctx?.[node]) :
-  node[0] === undefined ? (v => () => v)(node[1]) :
+  node[0] == null ? (v => () => v)(node[1]) :  // == catches both undefined and null
   operators[node[0]]?.(...node.slice(1)) ?? err(`Unknown operator: ${node[0]}`, node?.loc)
 );
 

spec.md

@@ -151,8 +151,9 @@ Sequence operators flatten naturally into n-ary form.
 [, true]           true
 [, false]          false
 [, null]           null
-[, undefined]      undefined
-[, NaN]            NaN
+[]                 undefined (empty array for JSON safety)
+[, NaN]            NaN (JS only)
+[, Infinity]       Infinity (JS only)
 ```
 
 Keywords are literals — they have no operator, only a value.
@@ -272,21 +273,29 @@ Custom operators are simply strings in position zero.
 
 ### Non-JSON Primitives
 
-JSON supports: number, string, boolean, null. Other values require representation choices:
+Literals (`[, value]`) hold JSON primitives only: number, string, boolean, null.
 
-| Value | Options |
-|-------|---------|
-| `undefined` | `[, undefined]` (JS only, serializes as `[null]`) |
-| `NaN` | `[, NaN]` (JS only) or keyword via context |
-| `10n` (BigInt) | `['n', [, '10']]` (constructor) or `[, '10n']` (string literal) |
+Non-JSON values use **constructor form** — an operator that constructs the value:
+
+| Value | Constructor Form |
+|-------|------------------|
+| `undefined` | `[]` (empty array, JSON round-trip safe) |
+| `NaN` | `[, NaN]` (JS runtime only, serializes to `[null, null]`) |
+| `Infinity` | `[, Infinity]` (JS runtime only, serializes to `[null, null]`) |
+| `/abc/gi` | `['//', 'abc', 'gi']` |
+| `/abc/` | `['//', 'abc']` |
+| `10n` (BigInt) | `['n', '10']` |
 | `Symbol('x')` | `['()', 'Symbol', [, 'x']]` (function call) |
-| `/abc/gi` | `['regex', [, 'abc'], [, 'gi']]` (constructor) or `[, '/abc/gi']` (string) |
-| `100px` | `['px', [, 100]]` (operator) or `[, '100px']` (string literal) |
-| `` `a${x}b` `` | `['\`', [, 'a'], 'x', [, 'b']]` (must interpolate) |
+| `100px` | `['px', [, 100]]` (unit operator) |
+| `` `a${x}b` `` | `` ['`', [, 'a'], 'x', [, 'b']] `` (interpolation) |
+
+**Regex** uses `//` as constructor operator (distinct from `/` division):
+- Division: `['/', a, b]`
+- Regex: `['//', pattern]` or `['//', pattern, flags]`
 
 **Template literals** must be operations — they contain sub-expressions to evaluate.
 
-**Units, regex, BigInt** can be either operators or string literals — parser decides, evaluator must match.
+**Note**: For full JSON serialization portability, non-JSON primitives should use constructor form. JS-only values (`undefined`, `NaN`, `Infinity`) work in JS runtime but serialize to `null`.
 
 
 ### Operand Validity

test/feature/regex.js

@@ -6,20 +6,20 @@ const run = (code, ctx = {}) => compile(parse(code))(ctx)
 
 test('regex: basic', t => {
   const ast = parse('/abc/')
-  is(ast[0], undefined)
-  is(ast[1] instanceof RegExp, true)
-  is(ast[1].source, 'abc')
+  is(ast[0], '//')
+  is(ast[1], 'abc')
+  is(ast.length, 2)  // no flags
 })
 
 test('regex: flags', t => {
-  is(parse('/abc/gi')[1].flags, 'gi')
-  is(parse('/test/m')[1].multiline, true)
-  is(parse('/test/i')[1].ignoreCase, true)
+  is(parse('/abc/gi'), ['//', 'abc', 'gi'])
+  is(parse('/test/m'), ['//', 'test', 'm'])
+  is(parse('/test/i'), ['//', 'test', 'i'])
 })
 
 test('regex: escapes', t => {
-  is(parse('/a\\/b/')[1].source, 'a\\/b')
-  is(parse('/a\\nb/')[1].source, 'a\\nb')
+  is(parse('/a\\/b/')[1], 'a\\/b')
+  is(parse('/a\\nb/')[1], 'a\\nb')
 })
 
 test('regex: eval', t => {
@@ -41,3 +41,15 @@ test('regex: in expressions', t => {
   is(run('x.match(/\\d+/)', { x: 'abc123def' })[0], '123')
   is(run('x.replace(/a/g, "b")', { x: 'aaa' }), 'bbb')
 })
+
+test('regex: JSON serializable', t => {
+  const ast = parse('/abc/gi')
+  const json = JSON.stringify(ast)
+  const restored = JSON.parse(json)
+  is(restored, ['//', 'abc', 'gi'])
+  // Can compile from restored AST
+  const re = compile(restored)()
+  is(re instanceof RegExp, true)
+  is(re.source, 'abc')
+  is(re.flags, 'gi')
+})

test/justin.js

@@ -67,6 +67,27 @@ test('justin: booleans', () => {
   is(justin('null')(), null)
 })
 
+test('justin: JSON serialization', () => {
+  // JSON primitives serialize cleanly
+  is(JSON.parse(JSON.stringify(parse('true'))), [null, true])
+  is(JSON.parse(JSON.stringify(parse('false'))), [null, false])
+  is(JSON.parse(JSON.stringify(parse('null'))), [null, null])
+  is(JSON.parse(JSON.stringify(parse('42'))), [null, 42])
+  is(JSON.parse(JSON.stringify(parse('"hi"'))), [null, 'hi'])
+
+  // undefined uses [] for JSON round-trip (compiles back to undefined)
+  is(JSON.parse(JSON.stringify(parse('undefined'))), [])
+  is(compile(JSON.parse(JSON.stringify(parse('undefined'))))(), undefined)
+
+  // NaN/Infinity lose value in JSON (become null)
+  is(JSON.parse(JSON.stringify(parse('NaN'))), [null, null])
+  is(JSON.parse(JSON.stringify(parse('Infinity'))), [null, null])
+
+  // Compile from JSON-restored AST
+  const ast = JSON.parse(JSON.stringify(parse('1 + 2')))
+  is(compile(ast)({}), 3)
+})
+
 test('justin: logical', () => {
   is(parse('a && b'), ['&&', 'a', 'b'])
   is(parse('a || b'), ['||', 'a', 'b'])

test/stringify.js

@@ -149,3 +149,9 @@ test('stringify: sequence', () => {
   is(gen('a,b'), 'a, b')
   is(gen('a,b,c'), 'a, b, c')
 })
+
+test('stringify: regex', () => {
+  is(gen('/abc/'), '/abc/')
+  is(gen('/abc/gi'), '/abc/gi')
+  is(gen('/a\\/b/'), '/a\\/b/')
+})

util/stringify.js

@@ -25,8 +25,11 @@ export const codegen = node => {
   // Literal: [, value]
   if (op === undefined) return typeof args[0] === 'string' ? JSON.stringify(args[0]) : String(args[0]);
 
-  // Custom generator
-  if (generators[op]) return generators[op](...args);
+  // Custom generator (if returns result, use it; undefined falls through)
+  if (generators[op]) {
+    const result = generators[op](...args);
+    if (result !== undefined) return result;
+  }
 
   // Brackets: [], {}, ()
   if (op === '[]' || op === '{}' || op === '()') {
@@ -143,6 +146,9 @@ generator(':', (k, v) => (typeof k === 'string' ? k : '[' + codegen(k) + ']') +
 generator('`', (...parts) => '`' + parts.map(p => p?.[0] === undefined ? String(p[1]).replace(/`/g, '\\`').replace(/\$/g, '\\$') : '${' + codegen(p) + '}').join('') + '`');
 generator('``', (tag, ...parts) => codegen(tag) + '`' + parts.map(p => p?.[0] === undefined ? String(p[1]).replace(/`/g, '\\`').replace(/\$/g, '\\$') : '${' + codegen(p) + '}').join('') + '`');
 
+// Regex constructor: ['//', pattern, flags?]
+generator('//', (a, b) => '/' + a + '/' + (b || ''));
+
 // Getter/Setter
 generator('get', (name, body) => 'get ' + name + '() { ' + (body ? codegen(body) : '') + ' }');
 generator('set', (name, param, body) => 'set ' + name + '(' + param + ') { ' + (body ? codegen(body) : '') + ' }');