rip-lang 2.8.5 → 2.8.7

package/docs/repl.html

@@ -659,6 +659,7 @@ console.log "Domain:", domain</textarea>
     let replHistory = [];
     let historyIndex = -1;
     let replBuffer = '';
+    let reactiveVars = new Set();  // Track reactive variables across evaluations
 
     // Create isolated iframe context for REPL (like vm.createContext in Node)
     const iframe = document.createElement('iframe');
@@ -670,6 +671,90 @@ console.log "Domain:", domain</textarea>
     replContext.console = console;
     replContext.showSexp = false;
     replContext.showTokens = false;
+    replContext.__reactiveVars = {};  // Store reactive objects persistently
+
+    // Inject reactive runtime into iframe context
+    (function injectReactiveRuntime() {
+      const ctx = replContext;
+      ctx.__currentEffect = null;
+      ctx.__pendingEffects = new Set();
+
+      ctx.__state = function(v) {
+        const subs = new Set();
+        let notifying = false, locked = false, dead = false;
+        const s = {
+          get value() { if (dead) return v; if (ctx.__currentEffect) { subs.add(ctx.__currentEffect); ctx.__currentEffect.dependencies.add(subs); } return v; },
+          set value(n) {
+            if (dead || locked || n === v || notifying) return;
+            v = n;
+            notifying = true;
+            for (const sub of subs) if (sub.markDirty) sub.markDirty();
+            for (const sub of subs) if (!sub.markDirty) ctx.__pendingEffects.add(sub);
+            const fx = [...ctx.__pendingEffects]; ctx.__pendingEffects.clear();
+            for (const e of fx) e.run();
+            notifying = false;
+          },
+          read() { return v; },
+          lock() { locked = true; return s; },
+          free() { subs.clear(); return s; },
+          kill() { dead = true; subs.clear(); return v; },
+          valueOf() { return this.value; },
+          toString() { return String(this.value); },
+          [Symbol.toPrimitive](hint) { return hint === 'string' ? this.toString() : this.valueOf(); }
+        };
+        return s;
+      };
+
+      ctx.__computed = function(fn) {
+        let v, dirty = true, locked = false, dead = false;
+        const subs = new Set();
+        const c = {
+          dependencies: new Set(),
+          markDirty() {
+            if (dead || locked || dirty) return;
+            dirty = true;
+            for (const s of subs) if (s.markDirty) s.markDirty();
+            for (const s of subs) if (!s.markDirty) ctx.__pendingEffects.add(s);
+          },
+          get value() {
+            if (dead) return v;
+            if (ctx.__currentEffect) { subs.add(ctx.__currentEffect); ctx.__currentEffect.dependencies.add(subs); }
+            if (dirty && !locked) {
+              for (const d of c.dependencies) d.delete(c); c.dependencies.clear();
+              const prev = ctx.__currentEffect; ctx.__currentEffect = c;
+              try { v = fn(); } finally { ctx.__currentEffect = prev; }
+              dirty = false;
+            }
+            return v;
+          },
+          read() { return dead ? v : c.value; },
+          lock() { locked = true; c.value; return c; },
+          free() { for (const d of c.dependencies) d.delete(c); c.dependencies.clear(); subs.clear(); return c; },
+          kill() { dead = true; const result = v; c.free(); return result; },
+          valueOf() { return this.value; },
+          toString() { return String(this.value); },
+          [Symbol.toPrimitive](hint) { return hint === 'string' ? this.toString() : this.valueOf(); }
+        };
+        return c;
+      };
+
+      ctx.__effect = function(fn) {
+        const e = {
+          dependencies: new Set(),
+          run() {
+            for (const d of e.dependencies) d.delete(e); e.dependencies.clear();
+            const prev = ctx.__currentEffect; ctx.__currentEffect = e;
+            try { fn(); } finally { ctx.__currentEffect = prev; }
+          },
+          free() { for (const d of e.dependencies) d.delete(e); e.dependencies.clear(); }
+        };
+        e.run();
+        return () => e.free();
+      };
+
+      ctx.__batch = function(fn) { fn(); };
+      ctx.__readonly = function(v) { return Object.freeze({ value: v }); };
+    })();
 
     function addOutput(content, className = '') {
       const line = document.createElement('div');
@@ -681,9 +766,17 @@ console.log "Domain:", domain</textarea>
 
     function evaluateRip(code) {
       try {
-        const result = compile(code);
+        // Pass reactiveVars to compiler so it knows which vars need .value access
+        const result = compile(code, { reactiveVars, skipReactiveRuntime: true });
         let js = result.code;
 
+        // Track new reactive variables
+        if (result.reactiveVars) {
+          for (const v of result.reactiveVars) {
+            reactiveVars.add(v);
+          }
+        }
+
         // REPL strategy: Strip let/const declarations entirely
         // Assignments will create properties on iframe's window (global scope)
         // This allows variables to persist between eval() calls
@@ -691,13 +784,22 @@ console.log "Domain:", domain</textarea>
         // Remove: let x, y, z;\n
         js = js.replace(/^let\s+[^;]+;\s*\n+/m, '');
 
-        // Remove: const x = ... (but keep the assignment)
+        // Transform reactive declarations to persist in __reactiveVars
+        // const x = __state(...) → x = __reactiveVars.x ?? (__reactiveVars.x = __state(...))
+        js = js.replace(
+          /^const\s+(\w+)\s*=\s*((?:__state|__computed|__effect)\(.+\));?$/gm,
+          (match, varName, rhs) => {
+            return `${varName} = __reactiveVars['${varName}'] ?? (__reactiveVars['${varName}'] = ${rhs});`;
+          }
+        );
+
+        // Remove remaining const (but keep the assignment) for non-reactive
         js = js.replace(/^const\s+(\w+)\s*=/gm, '$1 =');
 
         // Evaluate in iframe context - assignments create globals
         const evalResult = replContext.eval(js);
 
-        // Store in _
+        // Store in _ (unwrap reactive values)
         if (evalResult !== undefined) {
           replContext._ = evalResult;
         }
@@ -730,13 +832,27 @@ console.log "Domain:", domain</textarea>
 
         case '.clear':
           replOutput.innerHTML = '';
-          addOutput('<div class="welcome">Output cleared.</div>');
+          // Reset reactive tracking
+          reactiveVars.clear();
+          replContext.__reactiveVars = {};
+          // Clear all user-defined globals in iframe
+          const builtinsToKeep = ['console', 'showSexp', 'showTokens', 'eval', 'window', 'document',
+            'location', 'navigator', 'self', 'top', 'parent', 'frames', '__state', '__computed',
+            '__effect', '__batch', '__readonly', '__currentEffect', '__pendingEffects', '__reactiveVars'];
+          for (const key of Object.keys(replContext)) {
+            if (!builtinsToKeep.includes(key) && !key.startsWith('__')) {
+              try { delete replContext[key]; } catch {}
+            }
+          }
+          addOutput('<div class="welcome">Output and context cleared.</div>');
           break;
 
         case '.vars':
-          const builtins = ['console', 'showSexp', 'showTokens', 'eval', 'window', 'document', 'location', 'navigator', 'self', 'top', 'parent', 'frames'];
+          const builtins = ['console', 'showSexp', 'showTokens', 'eval', 'window', 'document',
+            'location', 'navigator', 'self', 'top', 'parent', 'frames', '__state', '__computed',
+            '__effect', '__batch', '__readonly', '__currentEffect', '__pendingEffects', '__reactiveVars'];
           const vars = Object.keys(replContext).filter(k =>
-            !builtins.includes(k) && !k.startsWith('_') || k === '_'
+            !builtins.includes(k) && !k.startsWith('__') || k === '_'
           );
           if (vars.length === 0 || (vars.length === 1 && vars[0] === '_' && replContext._ === undefined)) {
             addOutput('<span class="help-text">No variables defined</span>', 'command-output');
@@ -744,8 +860,21 @@ console.log "Domain:", domain</textarea>
             let output = '<span class="help-text">Variables:</span>\\n';
             vars.forEach(v => {
               try {
-                const val = JSON.stringify(replContext[v]);
-                output += `  <span class="var-name">${v}</span> = <span class="var-value">${val}</span>\\n`;
+                let val = replContext[v];
+                let typeIndicator = '=';
+                // Check if it's a reactive value
+                if (val && typeof val === 'object' && 'value' in val) {
+                  if (typeof val.markDirty === 'function') {
+                    typeIndicator = '<span style="color:#c586c0">~=</span>';  // computed
+                  } else if (typeof val === 'function') {
+                    typeIndicator = '<span style="color:#c586c0">~&gt;</span>';  // effect
+                  } else {
+                    typeIndicator = '<span style="color:#c586c0">:=</span>';  // state
+                  }
+                  val = val.value;
+                }
+                const formatted = formatValue(val);
+                output += `  <span class="var-name">${v}</span> ${typeIndicator} <span class="var-value">${escapeHtml(formatted)}</span>\\n`;
               } catch {
                 output += `  <span class="var-name">${v}</span> = <span class="var-value">[object]</span>\\n`;
               }
@@ -809,11 +938,14 @@ console.log "Domain:", domain</textarea>
           addOutput(`${formatted}`, 'command-output');
         }
 
-        // Show result
+        // Show result (unwrap reactive values)
         if (evalResult.value !== undefined) {
-          const formatted = typeof evalResult.value === 'object'
-            ? JSON.stringify(evalResult.value, null, 2)
-            : String(evalResult.value);
+          let displayValue = evalResult.value;
+          // Unwrap reactive objects to show their .value
+          if (displayValue && typeof displayValue === 'object' && 'value' in displayValue) {
+            displayValue = displayValue.value;
+          }
+          const formatted = formatValue(displayValue);
           addOutput(`<span class="result">→ ${escapeHtml(formatted)}</span>`);
         }
 
@@ -838,6 +970,23 @@ console.log "Domain:", domain</textarea>
         .replace(/"/g, '&quot;');
     }
 
+    // Format values for display (like Node's util.inspect)
+    function formatValue(val) {
+      if (val === null) return 'null';
+      if (val === undefined) return 'undefined';
+      if (val instanceof RegExp) return val.toString();
+      if (typeof val === 'function') return val.toString();
+      if (typeof val === 'string') return JSON.stringify(val);
+      if (typeof val === 'number' || typeof val === 'boolean') return String(val);
+      if (Array.isArray(val)) {
+        try { return JSON.stringify(val); } catch { return '[Array]'; }
+      }
+      if (typeof val === 'object') {
+        try { return JSON.stringify(val, null, 2); } catch { return '[Object]'; }
+      }
+      return String(val);
+    }
+
     // REPL input handling
     replInput.addEventListener('keydown', (e) => {
       if (e.key === 'Enter') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "2.8.5",
+  "version": "2.8.7",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",

package/src/compiler.js

@@ -227,6 +227,7 @@ export class CodeGenerator {
     'until': 'generateUntil',
     'try': 'generateTry',
     'throw': 'generateThrow',
+    'control': 'generateControl',
     'switch': 'generateSwitch',
     'when': 'generateWhen',
 
@@ -1081,6 +1082,53 @@ export class CodeGenerator {
       return valueCode;
     }
 
+    // Handle control flow short-circuits: x = expr or return/throw
+    // Pattern: ["=", target, ["control", op, expr, ["return", value]]]
+    // Operators: || (falsy), ?? (nullish), && (truthy)
+    if (Array.isArray(value) && op === '=' && value[0] === 'control') {
+      const [, rawCtrlOp, expr, ctrlSexpr] = value;
+      const ctrlOp = rawCtrlOp instanceof String ? rawCtrlOp.valueOf() : rawCtrlOp;
+      const isReturn = ctrlSexpr[0] === 'return';
+
+      // Declare the target variable if it's a simple identifier
+      const targetCode = this.generate(target, 'value');
+      if (typeof target === 'string') {
+        this.programVars.add(target);
+      }
+
+      // Generate the expression that will be assigned
+      const exprCode = this.generate(expr, 'value');
+
+      // Generate the control flow statement
+      const ctrlValue = ctrlSexpr.length > 1 ? ctrlSexpr[1] : null;
+      const ctrlCode = isReturn
+        ? (ctrlValue ? `return ${this.generate(ctrlValue, 'value')}` : 'return')
+        : (ctrlValue ? `throw ${this.generate(ctrlValue, 'value')}` : 'throw new Error()');
+
+      // In value context, wrap in IIFE that returns the assigned value
+      if (context === 'value') {
+        if (ctrlOp === '??') {
+          return `(() => { const __v = ${exprCode}; if (__v == null) ${ctrlCode}; return (${targetCode} = __v); })()`;
+        } else if (ctrlOp === '||') {
+          return `(() => { const __v = ${exprCode}; if (!__v) ${ctrlCode}; return (${targetCode} = __v); })()`;
+        } else {
+          return `(() => { const __v = ${exprCode}; if (__v) ${ctrlCode}; return (${targetCode} = __v); })()`;
+        }
+      }
+
+      // Statement context: if (condition) return/throw value;
+      // || → if (!(target = expr))
+      // ?? → if ((target = expr) == null)
+      // && → if ((target = expr))
+      if (ctrlOp === '??') {
+        return `if ((${targetCode} = ${exprCode}) == null) ${ctrlCode}`;
+      } else if (ctrlOp === '||') {
+        return `if (!(${targetCode} = ${exprCode})) ${ctrlCode}`;
+      } else {
+        return `if ((${targetCode} = ${exprCode})) ${ctrlCode}`;
+      }
+    }
+
     // Check for middle/leading rest in array destructuring
     if (Array.isArray(target) && target[0] === 'array') {
       const restIndex = target.slice(1).findIndex(el =>
@@ -2739,6 +2787,60 @@ export class CodeGenerator {
     return throwStmt;
   }
 
+  /**
+   * Generate control flow short-circuits: or/and return/throw
+   * Pattern: ["control", op, expr, ["return", value]] or ["control", op, expr, ["throw", error]]
+   * Operators: || (falsy), ?? (nullish), && (truthy)
+   */
+  generateControl(head, rest, context, sexpr) {
+    const [rawOp, expr, ctrlSexpr] = rest;
+    const op = rawOp instanceof String ? rawOp.valueOf() : rawOp;
+    const isReturn = ctrlSexpr[0] === 'return';
+
+    // Generate expression and control flow statement
+    const exprCode = this.generate(expr, 'value');
+    const ctrlValue = ctrlSexpr.length > 1 ? ctrlSexpr[1] : null;
+    const ctrlCode = isReturn
+      ? (ctrlValue ? `return ${this.generate(ctrlValue, 'value')}` : 'return')
+      : (ctrlValue ? `throw ${this.generate(ctrlValue, 'value')}` : 'throw new Error()');
+
+    // Build condition based on operator:
+    // || → trigger on falsy (!expr)
+    // ?? → trigger on nullish (expr == null)
+    // && → trigger on truthy (expr)
+    const wrappedExpr = this.wrapForCondition(exprCode);
+
+    // Value context: wrap in IIFE
+    if (context === 'value') {
+      if (op === '??') {
+        return `(() => { const __v = ${exprCode}; if (__v == null) ${ctrlCode}; return __v; })()`;
+      } else if (op === '||') {
+        return `(() => { const __v = ${exprCode}; if (!__v) ${ctrlCode}; return __v; })()`;
+      } else {
+        return `(() => { const __v = ${exprCode}; if (__v) ${ctrlCode}; return __v; })()`;
+      }
+    }
+
+    // Statement context
+    if (op === '??') {
+      return `if (${wrappedExpr} == null) ${ctrlCode}`;
+    } else if (op === '||') {
+      return `if (!${wrappedExpr}) ${ctrlCode}`;
+    } else {
+      return `if (${wrappedExpr}) ${ctrlCode}`;
+    }
+  }
+
+  /**
+   * Wrap code for use in a condition (add parens if needed)
+   */
+  wrapForCondition(code) {
+    // If it's a simple identifier or already wrapped, don't add extra parens
+    if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(code)) return code;
+    if (code.startsWith('(') && code.endsWith(')')) return code;
+    return `(${code})`;
+  }
+
   /**
    * Generate switch statement
    * Pattern: ["switch", discriminant, whens, defaultCase]

package/src/grammar/grammar.rip

@@ -778,6 +778,15 @@ grammar =
     o 'Expression & Expression'       , '["&", 1, 3]'
     o 'Expression ^ Expression'       , '["^", 1, 3]'
     o 'Expression | Expression'       , '["|", 1, 3]'
+
+    # Control flow short-circuits (must be before generic && || ?? to take precedence)
+    o 'Expression || Return'          , '["control", 2, 1, 3]'
+    o 'Expression || Throw'           , '["control", 2, 1, 3]'
+    o 'Expression ?? Return'          , '["control", 2, 1, 3]'
+    o 'Expression ?? Throw'           , '["control", 2, 1, 3]'
+    o 'Expression && Return'          , '["control", 2, 1, 3]'
+    o 'Expression && Throw'           , '["control", 2, 1, 3]'
+
     o 'Expression && Expression'      , '["&&", 1, 3]'
     o 'Expression || Expression'      , '["||", 1, 3]'
     o 'Expression ?? Expression'      , '["??", 1, 3]'  # Nullish coalescing