myxo-lang 1.5.0

package/examples/physarum.myx

@@ -0,0 +1,75 @@
+# physarum.myx — the slime mold's law, run properly, in the language named after it.
+#
+# Physarum polycephalum has no brain, yet it rebuilds the Tokyo rail network:
+# it floods every route, then each tube THICKENS with the flow it carries and
+# THINS continuously on its own. Useful paths reinforce; the rest decay and
+# vanish. Tero (2010) showed the network's character is set by HOW flow feeds
+# back into a tube: sharp feedback (flow squared) → one winner survives (lean);
+# soft feedback (sqrt of flow) → the detours stay alive as backups (resilient).
+# One organism, one dial. Myxo's old mesh did a toy version (+1 per read, manual
+# prune); this is the real dynamic, and the dial is passed in as a function.
+#
+# Run:  node myxo.js examples/physarum.myx
+
+# Two food sources (A, B). Each reachable by a short DIRECT route and a longer
+# DETOUR. Shorter tubes conduct more flow, so direct routes win — but how hard
+# they win depends entirely on the feedback shape.
+seed len   = { "A.direct": 1, "A.detour": 3, "B.direct": 1, "B.detour": 4 }
+seed dest  = { "A.direct": "A", "A.detour": "A", "B.direct": "B", "B.detour": "B" }
+seed dests = ["A", "B"]
+seed REINFORCE = 0.9
+seed FADE = 0.92            # gentle continuous decay — same for both runs
+
+agent fresh() {
+  report { "A.direct": 1, "A.detour": 1, "B.direct": 1, "B.detour": 1 }
+}
+
+# One forage cycle. `shape` is the feedback law — the dial Tero found.
+# Flow splits across a destination's routes by conductance (strength / length);
+# each tube thickens by REINFORCE * shape(flow); then EVERY tube thins by FADE.
+agent step(cond, shape) {
+  for each d in dests {
+    seed total = 0
+    for each r in keys(cond) {
+      when dest[r] == d { total = total + (cond[r] / len[r]) }
+    }
+    for each r in keys(cond) {
+      when dest[r] == d {
+        seed flow = (cond[r] / len[r]) / total
+        cond[r] = cond[r] + REINFORCE * shape(flow)
+      }
+    }
+  }
+  for each r in keys(cond) { cond[r] = cond[r] * FADE }
+  report cond
+}
+
+# Run the network to rest, then show each tube's share of its destination.
+agent simulate(shape, cycles, label) {
+  seed cond = fresh()
+  seed t = 0
+  reinforce t < cycles {
+    cond = step(cond, shape)
+    t = t + 1
+  }
+  emit ""
+  emit label
+  for each d in dests {
+    seed tot = 0
+    for each r in keys(cond) { when dest[r] == d { tot = tot + cond[r] } }
+    for each r in keys(cond) {
+      when dest[r] == d {
+        seed pct = floor(cond[r] / tot * 100)
+        seed mark = "pruned"
+        when pct >= 20 { mark = "ALIVE" }
+        emit "  " + r + "   " + str(pct) + "% of route to " + d + "   [" + mark + "]"
+      }
+    }
+  }
+}
+
+emit "Physarum routing in Myxo — same forage, one dial (the feedback shape):"
+simulate(agent(q) { report q * q }, 18, "[ LEAN — sharp feedback (flow squared) ]  one winner, detours starve:")
+simulate(agent(q) { report sqrt(q) }, 18, "[ RESILIENT — soft feedback (sqrt flow) ]  detours kept as live backups:")
+emit ""
+emit "Brainless. One rule. Efficiency or fault-tolerance, by a single dial — exactly what Tero found."

package/examples/polyglot-host.js

@@ -0,0 +1,17 @@
+'use strict';
+// Host: wire the language runners as FENCED capabilities, run the .myx, print the audit ledger.
+const fs = require('fs');
+const path = require('path');
+const { run } = require('../myxo');
+const { pycall, pyeval, jscall, jseval, plcall, pleval, sh } = require('../polyglot');
+
+let audit = [];
+const src = fs.readFileSync(path.join(__dirname, 'polyglot.myx'), 'utf8');
+const out = run(src, {
+  capture: true,
+  natives: { pycall, pyeval, jscall, jseval, plcall, pleval, sh },   // language runners -> fenced capabilities (gated by `needs`)
+  onAudit: (l) => { audit = l; },
+});
+process.stdout.write(out);
+console.log('--- audit ledger (the law saw every cross-language call) ---');
+for (const e of audit) console.log(' ', e.cap, e.ok ? 'OK -> ' + e.result : 'REFUSED (' + e.error + ')');

package/examples/polyglot.myx

@@ -0,0 +1,11 @@
+# Myxo as the connective layer for ALL languages: each language is a FENCED pathway, governed by the one law.
+# Python, Node, and Perl plug in through the SAME contract (defineLang); one audit ledger records every call.
+needs pycall, jscall, plcall, sh
+
+emit "python add =", pycall("examples/mathlib.py", "add", 2, 3)
+emit "node   add =", jscall("examples/mathlib.js", "add", 10, 20)
+emit "perl   add =", plcall("examples/mathlib.pl", "add", 4, 5)
+
+seed s = jscall("examples/mathlib.js", "stats", [10, 4, 7, 2])
+emit "node   stats: sum =", s["sum"], " max =", s["max"], " n =", s["n"]
+emit "shell      =", sh("echo one-contract-many-languages")

package/examples/resilient.myx

@@ -0,0 +1,28 @@
+# resilient.myx — error handling + the expanded stdlib, the Nexus way.
+# Shows: words/split, mesh-as-counter, value-returning `or`, attempt/rescue/fail.
+
+# Rank words by how often they appear (split + mesh + the `or default` idiom).
+agent word_counts(text) {
+  seed counts = {}
+  for each w in words(lower(text)) {
+    counts[w] = (counts[w] or 0) + 1   # missing key is void; void or 0 -> 0
+  }
+  report counts
+}
+
+seed text = "the mesh reinforces the path the mesh keeps"
+emit "counts:", word_counts(text)
+
+# A safe lookup: a pathway that might not exist, handled instead of crashing.
+agent safe_strength(counts, key) {
+  attempt {
+    when not has(counts, key) { fail "no such pathway: " + key }
+    report counts[key]
+  } rescue err {
+    report err["message"]    # turn a failure into a graceful value
+  }
+}
+
+seed counts = word_counts(text)
+emit safe_strength(counts, "mesh")     # present  -> 2
+emit safe_strength(counts, "wallet")   # absent   -> a clean message, no crash

package/examples/scheduler.myx

@@ -0,0 +1,46 @@
+# scheduler.myx — the Physarum scheduler: the reinforce/decay law applied to EXECUTION.
+# `schedule(name, workers, items)` distributes a batch across a learning pool of worker-agents, runs the
+# chunks on real worker threads IN PARALLEL, and updates each worker's conductance from its measured speed —
+# so fast workers pull more of the flux on later calls, and a failed worker decays and its items reroute.
+#
+# A worker takes a CHUNK (a list of items) and returns a results list — one result per item, in order.
+
+# --- a simple homogeneous pool: square every number, across two workers, in parallel ---
+agent square(chunk) {
+  seed out = []
+  for each x in chunk { out = out + [x * x] }
+  report out
+}
+
+emit "squares: " + str(schedule("squares", [square, square], [1, 2, 3, 4, 5, 6, 7, 8]))
+
+# --- a heterogeneous pool: one fast worker, one slow worker; watch the pool LEARN ---
+agent fast(chunk) {
+  seed out = []
+  for each x in chunk { out = out + [x] }
+  report out
+}
+agent slow(chunk) {
+  seed out = []
+  for each x in chunk {
+    seed j = 0
+    reinforce j < 300000 { j = j + 1 }      # this tube is genuinely slower
+    out = out + [x]
+  }
+  report out
+}
+
+# run a few batches so the pool can measure speed and re-balance the flux
+reinforce 4 times {
+  schedule("work", [fast, slow], [1, 2, 3, 4, 5, 6, 7, 8])
+}
+emit "learned conductances (fast should dominate): " + str(flows("work"))
+
+# --- failover: a dead tube; its work reroutes to the survivor, result intact ---
+agent boom(chunk) { fail "this tube is dead" }
+agent ok(chunk) {
+  seed out = []
+  for each x in chunk { out = out + [x * 10] }
+  report out
+}
+emit "failover (boom dies, ok takes over): " + str(schedule("resilient", [boom, ok], [1, 2, 3]))

package/examples/the-law.myx

@@ -0,0 +1,27 @@
+# the-law.myx — the core law of the Nexus, executed.
+# "Agents do not merge. Useful pathways reinforce. Useless pathways decay."
+# Run with --trace to watch the mesh:  node myxo.js examples/the-law.myx --trace
+
+agent reinforce_path(name, pulses) {
+  seed strength = 0
+  reinforce strength < pulses {
+    strength = strength + 1
+  }
+  report name + " reinforced to " + str(strength)
+}
+
+seed telegram = reinforce_path("telegram", 5)
+seed wallet   = reinforce_path("wallet", 3)
+seed bridge   = reinforce_path("bridge", 1)
+
+emit telegram
+emit wallet
+emit bridge
+
+# Useful pathways reinforce through use — reading telegram raises its strength.
+emit telegram
+emit telegram
+
+# A pathway gone quiet is let go.
+decay bridge
+emit "bridge has decayed from the mesh"

package/examples/use-geo.myx

@@ -0,0 +1,9 @@
+# use-geo.myx — weave a strand and use what it exposes (v0.3 modules).
+
+weave "geo.myx"                       # flat: pulls area_circle, area_rect, TAU into scope
+emit round(area_circle(2), 2)        # PI * 4  -> 12.57
+emit area_rect(3, 4)                 # 12
+emit round(TAU, 4)                   # 6.2832
+
+weave "geo.myx" as geo                # namespaced: the exposed names as a mesh
+emit round(geo["area_circle"](1), 2) # PI -> 3.14

package/format.js

@@ -0,0 +1,206 @@
+'use strict';
+// format.js - canonical Myxo source printer. It formats the parsed AST, so invalid code is refused instead of
+// guessed through. Comments ARE preserved: they aren't in the AST, so we collect them from the REAL lexer
+// (string/interpolation-aware) and re-attach by line — own-line comments above the next statement, a trailing
+// comment on its statement's line. v1 scope is statement-granular: none are ever dropped or fabricated, but a
+// comment trailing a one-line block or a multi-line construct, or one inside an inline `agent(){}` expression,
+// may render on its own line / shift to the nearest statement boundary. `--drop-comments` strips them.
+
+const { parse } = require('./parser');
+const { tokenize } = require('./lexer');
+
+const PREC = { or: 1, and: 2, '==': 3, '!=': 3, '>': 4, '<': 4, '>=': 4, '<=': 4, '+': 5, '-': 5, '*': 6, '/': 6, '%': 6 };
+const IND = '  ';
+
+function q(s) { return JSON.stringify(String(s)); }
+function pad(n) { return IND.repeat(n); }
+
+function formatSource(src, opts = {}) {
+  if (opts.dropComments) return formatProgram(parse(src), []);
+  const comments = [];
+  tokenize(src, comments);   // the real, string-aware scanner — never mistakes a '#' inside a string for a comment
+  return formatProgram(parse(src), comments);
+}
+
+function newCtx(comments) { return { comments: comments || [], i: 0 }; }
+function ownLineComments(ctx, beforeLine, level) {   // flush every comment strictly before `beforeLine`, each on its own line
+  let s = '';
+  while (ctx.i < ctx.comments.length && ctx.comments[ctx.i].line < beforeLine) {
+    const c = ctx.comments[ctx.i++];
+    s += pad(level) + (c.text ? '# ' + c.text : '#') + '\n';
+  }
+  return s;
+}
+function trailingComment(ctx, line) {   // a comment that trails code on this exact line
+  if (ctx.i < ctx.comments.length && ctx.comments[ctx.i].line === line && ctx.comments[ctx.i].trailing) {
+    const c = ctx.comments[ctx.i++];
+    return c.text ? '  # ' + c.text : '  #';
+  }
+  return '';
+}
+
+// A statement's LAST source line — its closing `}` for a block statement — so a comment trailing that line
+// attaches to the whole statement, not to whatever inner statement happens to start on the same line.
+function stmtEndLine(s) {
+  const b = (s.elseBlock && s.elseBlock.endLine) || (s.catchBlock && s.catchBlock.endLine)
+    || (s.body && s.body.endLine) || (s.thenBlock && s.thenBlock.endLine) || s.matchEnd;
+  return b || s.line;
+}
+
+function formatProgram(ast, comments = []) {
+  const ctx = newCtx(comments);
+  let out = '';
+  for (const s of ast.body) {
+    out += ownLineComments(ctx, s.line, 0) + fmtStmt(s, 0, ctx) + trailingComment(ctx, stmtEndLine(s)) + '\n';
+  }
+  out += ownLineComments(ctx, Infinity, 0);   // footer / trailing comments after the last statement
+  return out;
+}
+
+function fmtBlock(body, level, ctx = newCtx()) {
+  const tail = body.endLine ? () => ownLineComments(ctx, body.endLine, level + 1).replace(/\n+$/, '') : () => '';
+  if (!body.length) { const t = tail(); return t ? ' {\n' + t + '\n' + pad(level) + '}' : ' {}'; }
+  const parts = body.map(s => ownLineComments(ctx, s.line, level + 1) + fmtStmt(s, level + 1, ctx) + trailingComment(ctx, stmtEndLine(s)));
+  let inner = parts.join('\n');
+  const t = tail();                       // comments after the last statement but before the closing brace stay INSIDE
+  if (t) inner += '\n' + t;
+  return ' {\n' + inner + '\n' + pad(level) + '}';
+}
+
+function fmtParams(params) {
+  return '(' + params.map(p => {
+    if (p.rest) return '...' + p.name;
+    return p.name + (p.paramType ? ': ' + p.paramType : '') + (p.def != null ? ' = ' + fmtExpr(p.def) : '');
+  }).join(', ') + ')';
+}
+
+function fmtNeed(item) {
+  if (!item.limit) return item.name;
+  const parts = [];
+  if (Object.prototype.hasOwnProperty.call(item.limit, 'max')) parts.push('max ' + item.limit.max);
+  if (Object.prototype.hasOwnProperty.call(item.limit, 'total')) parts.push('total ' + item.limit.total);
+  return item.name + '(' + parts.join(', ') + ')';
+}
+
+function fmtStmt(s, level, ctx = newCtx()) {
+  const p = pad(level);
+  switch (s.type) {
+    case 'Seed': return p + `seed ${s.name}${s.declType ? ': ' + s.declType : ''} = ${fmtExpr(s.value)}`;
+    case 'SeedDestructure': return p + `seed ${fmtPattern(s.pattern)} = ${fmtExpr(s.value)}`;
+    case 'Decay': return p + `decay ${fmtExpr(s.target)}`;
+    case 'Emit': return p + 'emit ' + s.args.map(a => fmtExpr(a)).join(', ');
+    case 'When': {
+      let out = p + `when ${fmtExpr(s.cond)}` + fmtBlock(s.thenBlock, level, ctx);
+      if (s.elseBlock) {
+        if (s.elseBlock.length === 1 && s.elseBlock[0].type === 'When') {
+          out += ' otherwise ' + fmtStmt(s.elseBlock[0], 0, ctx);
+        } else {
+          out += ' otherwise' + fmtBlock(s.elseBlock, level, ctx);
+        }
+      }
+      return out;
+    }
+    case 'Reinforce': return p + `reinforce ${fmtExpr(s.cond)}` + fmtBlock(s.body, level, ctx);
+    case 'ReinforceTimes': return p + `reinforce ${fmtExpr(s.count)} times` + fmtBlock(s.body, level, ctx);
+    case 'ForEach': return p + `for each ${s.varName} in ${fmtExpr(s.iterable)}` + fmtBlock(s.body, level, ctx);
+    case 'Agent': return p + `agent ${s.name}${fmtParams(s.params)}${s.returnType ? ': ' + s.returnType : ''}` + fmtBlock(s.body, level, ctx);
+    case 'Report': return p + (s.value && s.value.type !== 'Void' ? 'report ' + fmtExpr(s.value) : 'report');
+    case 'Attempt': return p + 'attempt' + fmtBlock(s.tryBlock, level, ctx) + ` rescue ${s.errName}` + fmtBlock(s.catchBlock, level, ctx);
+    case 'Fail': {
+      const isDefault = s.value && s.value.type === 'String' && s.value.value === 'failed';
+      return p + (isDefault ? 'fail' : 'fail ' + fmtExpr(s.value));
+    }
+    case 'Weave': return p + 'weave ' + fmtExpr(s.path) + (s.alias ? ` as ${s.alias}` : '');
+    case 'Expose': return p + `expose ${s.name}`;
+    case 'Needs': return p + 'needs ' + s.items.map(fmtNeed).join(', ');
+    case 'Assign': return p + `${fmtExpr(s.target)} = ${fmtExpr(s.value)}`;
+    case 'Test': return p + `test ${q(s.name)}` + fmtBlock(s.body, level, ctx);
+    case 'Expect': return p + 'expect ' + fmtMatcher(s);
+    case 'Match': {
+      if (!s.arms.length) return p + `match ${fmtExpr(s.subject)} {}`;
+      const arms = s.arms.map(a => pad(level + 1) + fmtPattern(a.pattern) + fmtBlock(a.body, level + 1, ctx)).join('\n');
+      return p + `match ${fmtExpr(s.subject)} {\n${arms}\n${pad(level)}}`;
+    }
+    case 'Give': return p + `give ${fmtExpr(s.value)} to ${fmtExpr(s.channel)}`;
+    case 'Take': return p + `take ${s.name} from ${fmtExpr(s.channel)}`;
+    case 'Yield': return p + 'yield';
+    case 'ExpressionStatement': return p + fmtExpr(s.expr);
+    default: throw new Error(`cannot format statement type ${s.type}`);
+  }
+}
+
+function fmtMatcher(s) {
+  const a = fmtExpr(s.actual);
+  const m = s.matcher;
+  switch (m.kind) {
+    case 'is': return `${a} is ${fmtExpr(m.expected)}`;
+    case 'isnot': return `${a} is not ${fmtExpr(m.expected)}`;
+    case 'fail': return `${a} to fail`;
+    case 'failwith': return `${a} to fail with ${fmtExpr(m.expected)}`;
+    default: return a;   // truthy
+  }
+}
+
+function fmtPattern(pp) {
+  switch (pp.type) {
+    case 'PWild': return '_';
+    case 'PBind': return pp.name;
+    case 'PLit': return fmtExpr(pp.expr);
+    case 'PList': {
+      const parts = pp.elements.map(fmtPattern);
+      if (pp.rest) parts.push('...' + pp.rest);
+      return '[' + parts.join(', ') + ']';
+    }
+    case 'PMesh': return pp.pairs.length ? '{ ' + pp.pairs.map(pr =>
+      (pr.pattern.type === 'PBind' && pr.pattern.name === pr.key) ? pr.key : `${q(pr.key)}: ${fmtPattern(pr.pattern)}`
+    ).join(', ') + ' }' : '{}';
+    default: throw new Error(`cannot format pattern ${pp.type}`);
+  }
+}
+
+function exprPrec(e) {
+  if (e.type === 'Pipe') return 0;
+  if (e.type === 'Binary') return PREC[e.op] || 0;
+  if (e.type === 'Unary') return 7;
+  if (e.type === 'Call' || e.type === 'Index') return 9;
+  return 10;
+}
+
+function par(s, need) { return need ? '(' + s + ')' : s; }
+
+function fmtExpr(e, parent = 0, side = '') {
+  switch (e.type) {
+    case 'Number': return String(e.value);
+    case 'String': return q(e.value);
+    case 'Bool': return e.value ? 'live' : 'dead';
+    case 'Void': return 'void';
+    case 'Identifier': return e.name;
+    case 'Interp':
+      return '"' + e.parts.map(part => part.type === 'String'
+        ? String(part.value).replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/{/g, '\\{')
+        : '{' + fmtExpr(part) + '}').join('') + '"';
+    case 'Unary': {
+      const mine = exprPrec(e);
+      const out = e.op === 'not' ? `not ${fmtExpr(e.operand, mine)}` : '-' + fmtExpr(e.operand, mine);
+      return par(out, mine < parent);
+    }
+    case 'Binary': {
+      const mine = exprPrec(e);
+      const left = fmtExpr(e.left, mine, 'left');
+      const right = fmtExpr(e.right, mine + (['-', '/', '%'].includes(e.op) ? 1 : 0), 'right');
+      return par(`${left} ${e.op} ${right}`, mine < parent || (mine === parent && side === 'right'));
+    }
+    case 'Pipe': return par(`${fmtExpr(e.left, 0)} | ${fmtExpr(e.right, 1)}`, parent > 0);
+    case 'Call': return fmtExpr(e.callee, 9) + '(' + e.args.map(a => fmtExpr(a)).join(', ') + ')';
+    case 'Index': return fmtExpr(e.object, 9) + '[' + fmtExpr(e.index) + ']';
+    case 'List': return '[' + e.elements.map(x => fmtExpr(x)).join(', ') + ']';
+    case 'Mesh': return e.pairs.length ? '{ ' + e.pairs.map(([k, v]) => `${fmtExpr(k)}: ${fmtExpr(v)}`).join(', ') + ' }' : '{}';
+    case 'AgentExpr': return 'agent' + fmtParams(e.params) + (e.returnType ? ': ' + e.returnType : '') + fmtBlock(e.body, 0);
+    case 'Dispatch': return 'dispatch ' + fmtExpr(e.call);
+    case 'Gather': return 'gather ' + fmtExpr(e.expr, 8);
+    case 'Spawn': return 'spawn ' + fmtExpr(e.call);
+    default: throw new Error(`cannot format expression type ${e.type}`);
+  }
+}
+
+module.exports = { formatSource, formatProgram };