Two languages that
broke the rules

// A Forth stack machine — the entire computational model
// Written in plain JS so the page runner can execute it reliably.

function ForthMachine() {
  this.stack  = [];
  this.rstack = [];
  this.memory = {};
  this.dict   = this.buildDict();
}

ForthMachine.prototype.push = function(v) { this.stack.push(v); };
ForthMachine.prototype.pop = function() {
  if (!this.stack.length) throw new Error("Stack underflow");
  return this.stack.pop();
};
ForthMachine.prototype.peek = function() {
  return this.stack[this.stack.length - 1];
};

ForthMachine.prototype.buildDict = function() {
  var m = this;
  return {
    // Arithmetic — pop two, push result
    '+': function() { m.push(m.pop() + m.pop()); },
    '-': function() { var b = m.pop(), a = m.pop(); m.push(a - b); },
    '*': function() { m.push(m.pop() * m.pop()); },
    '/': function() { var b = m.pop(), a = m.pop(); m.push(Math.floor(a / b)); },
    'MOD': function() { var b = m.pop(), a = m.pop(); m.push(a % b); },
    'NEGATE': function() { m.push(-m.pop()); },
    'ABS': function() { m.push(Math.abs(m.pop())); },
    'MAX': function() { m.push(Math.max(m.pop(), m.pop())); },
    // Stack manipulation — the "no variables" toolkit
    'DUP': function() { m.push(m.peek()); },
    'DROP': function() { m.pop(); },
    'SWAP': function() { var b = m.pop(), a = m.pop(); m.push(b); m.push(a); },
    'OVER': function() { m.push(m.stack[m.stack.length - 2]); },
    'ROT': function() { var c = m.pop(), b = m.pop(), a = m.pop(); m.push(b); m.push(c); m.push(a); },
    '2DUP': function() { var b = m.stack[m.stack.length - 1], a = m.stack[m.stack.length - 2]; m.push(a); m.push(b); },
    // Comparison
    '=': function() { m.push(m.pop() === m.pop() ? -1 : 0); },
    '<': function() { var b = m.pop(), a = m.pop(); m.push(a < b ? -1 : 0); },
    '>': function() { var b = m.pop(), a = m.pop(); m.push(a > b ? -1 : 0); },
    '0=': function() { m.push(m.pop() === 0 ? -1 : 0); },
    // Output
    '.': function() { console.log(m.pop()); },
    '.S': function() { console.log("Stack:", m.stack.slice()); }
  };
};

ForthMachine.prototype.run = function(source) {
  var tokens = source.trim().split(/\s+/);
  for (var i = 0; i < tokens.length; i++) {
    var token = tokens[i];
    if (token === "") continue;
    if (!isNaN(token)) { this.push(Number(token)); continue; }
    var word = this.dict[token.toUpperCase()];
    if (!word) throw new Error("Unknown word: " + token);
    word();
  }
  return this.stack;
};

var forth = new ForthMachine();

// No variables needed! Stack manipulation suffices.
console.log("=== Forth stack computation ===");
console.log("2 3 + 4 * → ",    forth.run("2 3 + 4 *"));          // (2+3)*4 = 20
forth.stack=[];
console.log("5 DUP * → ",      forth.run("5 DUP *"));            // 5*5 = 25
forth.stack=[];
console.log("10 3 MOD → ",     forth.run("10 3 MOD"));           // 10 mod 3 = 1
forth.stack=[];
// Hypotenuse without naming variables: √(a²+b²)
console.log("Hypotenuse: ", forth.run("3 DUP * 4 DUP * + "));  // 3²+4² = 25
console.log("(√25 not implemented, but 3 DUP * 4 DUP * + gives 25)");

forth.stack=[];
// ROT reorders: a b c → b c a
forth.run("1 2 3");
console.log("\nBefore ROT: [1 2 3]"); forth.run("ROT");
console.log("After ROT:  ", forth.stack);

// Forth's dictionary: define new words from old ones
// The language grows from the bottom up — primitives to domain words

class ForthDict {
  constructor() {
    this.words   = {};
    this.stack   = [];
    this.compiling = false;
    this.newWordName = null;
    this.newWordTokens = [];
    this.addPrimitives();
  }

  addPrimitives() {
    const p = (name, fn) => { this.words[name] = { type: 'primitive', fn }; };
    p('+',    ()=>this.stack.push(this.stack.pop()+this.stack.pop()));
    p('*',    ()=>this.stack.push(this.stack.pop()*this.stack.pop()));
    p('-',    ()=>{const b=this.stack.pop(),a=this.stack.pop();this.stack.push(a-b);});
    p('DUP',  ()=>this.stack.push(this.stack.at(-1)));
    p('DROP', ()=>this.stack.pop());
    p('SWAP', ()=>{const b=this.stack.pop(),a=this.stack.pop();this.stack.push(b,a);});
    p('OVER', ()=>this.stack.push(this.stack.at(-2)));
    p('ROT',  ()=>{const[c,b,a]=[this.stack.pop(),this.stack.pop(),this.stack.pop()];this.stack.push(b,c,a);});
  }

  execute(token) {
    if (!isNaN(token)) { this.stack.push(Number(token)); return; }
    const word = this.words[token.toUpperCase()];
    if (!word) throw new Error(`Undefined: ${token}`);
    if (word.type === 'primitive') word.fn();
    else word.tokens.forEach(t => this.execute(t));
  }

  run(source) {
    const tokens = source.trim().split(/\s+/);
    for (const tok of tokens) {
      if (tok === ':') { this.compiling = true; continue; }  // start definition
      if (tok === ';') {                                         // end definition
        this.words[this.newWordName] = { type: 'defined', tokens: this.newWordTokens };
        console.log(`Defined: ${this.newWordName} = [${this.newWordTokens.join(' ')}]`);
        this.compiling = false; this.newWordName = null; this.newWordTokens = [];
        continue;
      }
      if (this.compiling) {
        if (!this.newWordName) { this.newWordName = tok.toUpperCase(); continue; }
        this.newWordTokens.push(tok.toUpperCase()); continue;
      }
      this.execute(tok);
    }
    return [...this.stack];
  }
}

const f = new ForthDict();

// Build up a vocabulary layer by layer
console.log("=== Building a language from primitives ===");

// Layer 1: Basic combinators
f.run(": SQUARE DUP * ;");       // SQUARE: n → n²
f.run(": CUBE DUP SQUARE * ;");  // CUBE: uses SQUARE
f.run(": NIP SWAP DROP ;");       // NIP: a b → b
f.run(": TUCK SWAP OVER ;");      // TUCK: a b → b a b

// Layer 2: Domain words built from layer 1
f.run(": HYPOTENUSE-SQUARED SQUARE SWAP SQUARE + ;");

f.stack=[];
console.log("\n5 SQUARE =", f.run("5 SQUARE"));
f.stack=[];
console.log("3 CUBE =", f.run("3 CUBE"));
f.stack=[];
console.log("3 4 HYPOTENUSE-SQUARED =", f.run("3 4 HYPOTENUSE-SQUARED"));

console.log("\nDictionary:", Object.keys(f.words).join("  "));
console.log("All words are equal — primitives and defined words are indistinguishable.");

// Concatenative programming: programs ARE functions Stack→Stack
// Juxtaposition = function composition. No other syntax needed.

// Model a stack-to-stack function
const word = (name, fn) => ({ name, fn });

// Primitives — each transforms a stack
const DUP   = word('DUP',  s => [...s, s.at(-1)]);
const DROP  = word('DROP', s => s.slice(0,-1));
const SWAP  = word('SWAP', s => [...s.slice(0,-2), s.at(-1), s.at(-2)]);
const OVER  = word('OVER', s => [...s, s.at(-2)]);
const PLUS  = word('+',    s => [...s.slice(0,-2), s.at(-2)+s.at(-1)]);
const TIMES = word('*',    s => [...s.slice(0,-2), s.at(-2)*s.at(-1)]);
const MINUS = word('-',    s => [...s.slice(0,-2), s.at(-2)-s.at(-1)]);
const LIT   = n => word(String(n), s => [...s, n]);

// CONCATENATION = composition. Put words next to each other → compose them.
const concat = (...words) => ({
  name: words.map(w=>w.name).join(' '),
  fn:   stack => words.reduce((s, w) => w.fn(s), stack)
});

// DEFINE higher-level words by concatenating lower-level ones
const SQUARE = concat(DUP, TIMES);        // n → n² (= DUP *)
const CUBE   = concat(DUP, SQUARE, TIMES); // n → n³ (= DUP SQUARE *)
const NIP    = concat(SWAP, DROP);         // a b → b
const TUCK   = concat(SWAP, OVER);         // a b → b a b

// Run a "program" = a composed word on an initial stack
const run = (prog, init=[]) => prog.fn(init);

console.log("SQUARE 5 → ", run(concat(LIT(5), SQUARE)));
console.log("CUBE 3 → ",   run(concat(LIT(3), CUBE)));
console.log("TUCK 2 7 → ", run(concat(LIT(2), LIT(7), TUCK)));

// KEY INSIGHT: program text = just a sequence of names. No parse tree.
// "3 DUP * 4 DUP * +" is literally [LIT(3), DUP, TIMES, LIT(4), DUP, TIMES, PLUS]
const hyp_sq = concat(LIT(3), DUP, TIMES, LIT(4), DUP, TIMES, PLUS);
console.log("3 DUP * 4 DUP * + → ", run(hyp_sq), "(= 3² + 4² = 25)");

// Type-level: every Forth word has stack effect ( before -- after )
// DUP  : ( n -- n n )      ← consumes 1, produces 2
// DROP : ( n -- )           ← consumes 1, produces 0
// SWAP : ( a b -- b a )     ← consumes 2, produces 2
// OVER : ( a b -- a b a )   ← consumes 2, produces 3
// +    : ( a b -- a+b )     ← consumes 2, produces 1
// SQUARE: ( n -- n² )       ← derived: (DUP *)
console.log("\nStack effect notation encodes the type of each word.");
console.log("Factor (modern Forth) uses this to infer types statically.");

// Forth meta-compilation: control structures built from IMMEDIATE words
// In standard Forth: IF, ELSE, THEN, BEGIN, UNTIL are all defined in Forth itself
// Here we simulate the mechanism that makes this possible

class MetaForth {
  constructor() {
    this.dict       = {};
    this.stack      = [];
    this.compiling  = false;
    this.codeBuffer = []; // instructions being compiled
    this.patches    = []; // addresses needing backpatching (for forward jumps)
    this.addPrimitives();
    this.addControlWords();
  }

  addPrimitives() {
    const add = (name, fn, immediate=false) => { this.dict[name] = {fn, immediate}; };
    add('+',   ()=>{ const[b,a]=[this.stack.pop(),this.stack.pop()]; this.stack.push(a+b); });
    add('-',   ()=>{ const[b,a]=[this.stack.pop(),this.stack.pop()]; this.stack.push(a-b); });
    add('*',   ()=>{ const[b,a]=[this.stack.pop(),this.stack.pop()]; this.stack.push(a*b); });
    add('DUP', ()=>this.stack.push(this.stack.at(-1)));
    add('DROP',()=>this.stack.pop());
    add('0=',  ()=>this.stack.push(this.stack.pop()===0?-1:0));
    add('.',   ()=>console.log(this.stack.pop()));
  }

  addControlWords() {
    // IMMEDIATE words run at COMPILE TIME, not runtime
    // They can insert instructions and patch jump addresses
    const add = (name, fn) => { this.dict[name] = {fn, immediate: true}; };

    // IF: ( flag -- ) branch if false
    // Compiles a conditional jump; records address for ELSE/THEN to patch
    add('IF', () => {
      this.codeBuffer.push({ op: 'BRANCH_FALSE', target: null });
      this.patches.push(this.codeBuffer.length - 1); // remember to backpatch
      console.log(`  [compile-time] IF: emitted BRANCH_FALSE at [${this.codeBuffer.length-1}]`);
    });

    // ELSE: patch the IF's branch, emit unconditional jump for THEN
    add('ELSE', () => {
      this.codeBuffer.push({ op: 'JUMP', target: null });
      const elseAddr = this.codeBuffer.length - 1;
      const ifAddr = this.patches.pop();
      this.codeBuffer[ifAddr].target = this.codeBuffer.length; // patch IF to jump here
      this.patches.push(elseAddr);
      console.log(`  [compile-time] ELSE: patched IF[${ifAddr}]→${this.codeBuffer.length}, emitted JUMP[${elseAddr}]`);
    });

    // THEN: patch IF or ELSE's jump to land here
    add('THEN', () => {
      const patchAddr = this.patches.pop();
      this.codeBuffer[patchAddr].target = this.codeBuffer.length;
      console.log(`  [compile-time] THEN: patched [${patchAddr}]→${this.codeBuffer.length}`);
    });

    // BEGIN/UNTIL: loop until condition is true
    add('BEGIN', () => {
      this.patches.push(this.codeBuffer.length); // remember loop start
    });
    add('UNTIL', () => {
      const loopStart = this.patches.pop();
      this.codeBuffer.push({ op: 'BRANCH_FALSE', target: loopStart });
      console.log(`  [compile-time] UNTIL: emit BRANCH_FALSE→${loopStart}`);
    });
  }

  compileWord(name, tokens) {
    console.log(`\nCompiling: ${name} [ ${tokens.join(' ')} ]`);
    this.codeBuffer = [];
    for (const tok of tokens) {
      if (!isNaN(tok)) { this.codeBuffer.push({op:'LIT',val:Number(tok)}); continue; }
      const w = this.dict[tok.toUpperCase()];
      if (!w) throw new Error(`Unknown: ${tok}`);
      if (w.immediate) w.fn();           // IMMEDIATE: run NOW at compile time
      else this.codeBuffer.push({op:'CALL', word: tok.toUpperCase()});
    }
    this.dict[name] = { fn: () => this.executeCode(this.dict[name].code), code: [...this.codeBuffer] };
    console.log("  Compiled bytecode:", this.codeBuffer.map(i=>i.op+(i.val??i.word??('→'+(i.target??'?')))).join(' '));
  }

  executeCode(code) {
    let ip = 0;
    while (ip < code.length) {
      const ins = code[ip];
      if (ins.op === 'LIT') { this.stack.push(ins.val); ip++; continue; }
      if (ins.op === 'CALL') { this.dict[ins.word].fn(); ip++; continue; }
      if (ins.op === 'BRANCH_FALSE') {
        const flag = this.stack.pop();
        ip = flag === 0 ? ins.target : ip + 1;
        continue;
      }
      if (ins.op === 'JUMP') { ip = ins.target; continue; }
      throw new Error(`Unknown opcode: ${ins.op}`);
    }
    return this.stack;
  }
}

const mf = new MetaForth();

// Compile an IF/ELSE/THEN word — the control structure is built by IMMEDIATE words
mf.compileWord('ABS-SIGN', ['DUP','0=','IF','DROP','0','ELSE','DUP','*','THEN']);
mf.stack = [0]; mf.dict['ABS-SIGN'].fn(); console.log("ABS-SIGN on 0  →", mf.stack);
mf.stack = [3]; mf.dict['ABS-SIGN'].fn(); console.log("ABS-SIGN on 3  →", mf.stack);
console.log("\nIF ELSE THEN are not special syntax — they are IMMEDIATE words");
console.log("that run at compile time and emit/patch jump instructions.");
console.log("Any Forth programmer can write their own control structures the same way.");