rooklang 0.3.0 → 0.3.2

package/src/runtime/threads.js

@@ -0,0 +1,240 @@
+// What threads share: a channel is data, `{ $$chan: id, size, zero }`, copied to other threads like
+// any value, and what it holds lives in the thread that made it, whose key starts its id. Each
+// thread has a registry of its channels and of its ports to the other threads, shared by its
+// modules; the operations of a thread on the channels of another go straight to that thread
+// through a MessagePort, which the main thread sets up on the first need (go.js).
+
+import { $$Queue } from './queue.js';
+
+// The state of this thread that its modules share: the channels it made, its ports to the other
+// threads by their keys, and the requests that wait for an answer.
+export function $$registry() {
+  return (globalThis[Symbol.for('rook.threads')] ??= {
+    key: Math.random().toString(36).slice(2),
+    channels: 0,
+    states: new Map(),
+    held: new FinalizationRegistry((id) => $$hold(id, -1)),
+    ports: new Map(),
+    pins: new Map(),
+    idle: null,
+    waiting: new Map(),
+    gone: new Set(),
+    main: null,
+    requests: new Map(),
+    asks: 0,
+    selects: new Map(),
+    moved: new WeakSet(),
+    cancels: new WeakMap(),
+    handle: null,
+  });
+}
+
+// The key of the thread that made a channel, which keeps what it holds.
+export function $$ownerOf(id) {
+  return id.slice(0, id.lastIndexOf(':'));
+}
+
+// Sends a message to a thread. The channels in it are counted first, as the thread gets copies,
+// and the buffers of transfer() move there. A message waits for the port of a thread that has just
+// started.
+export function $$post(key, message) {
+  const registry = $$registry();
+
+  if (registry.gone.has(key)) return;
+
+  const { channels, moved } = $$walk(message);
+
+  for (const channel of channels) $$hold(channel.$$chan, 1);
+
+  const port = registry.ports.get(key);
+
+  if (port) return port.postMessage(message, moved);
+  if (!registry.waiting.has(key)) registry.waiting.set(key, []);
+  registry.waiting.get(key).push([message, moved]);
+}
+
+// A request to a thread, answered by a message with its number.
+export function $$ask(key, message) {
+  const registry = $$registry();
+
+  if (registry.gone.has(key)) return Promise.reject($$stopped());
+  $$pin(key, 1);
+
+  return new Promise((resolve, reject) => {
+    const ask = registry.asks++;
+
+    registry.requests.set(ask, { resolve, reject, key });
+    $$post(key, { ...message, ask });
+  });
+}
+
+// A thread that this one waits for keeps the program running: in Node, its worker or port is
+// referenced while some request or select waits for it.
+export function $$pin(key, count) {
+  const registry = $$registry();
+  const pins = (registry.pins.get(key) ?? 0) + count;
+
+  registry.pins.set(key, pins);
+
+  const port = registry.ports.get(key);
+
+  if (pins > 0) port?.ref?.();
+  else if (registry.idle) registry.idle(key);
+  else port?.unref?.();
+}
+
+export function $$stopped() {
+  return new Error('the goroutine that made the channel has stopped');
+}
+
+// A port to a thread: messages that waited for it go now.
+export function $$connect(key, port, listen) {
+  const registry = $$registry();
+
+  registry.ports.set(key, port);
+  if (registry.pins.get(key) > 0) port.ref?.();
+  if (listen) {
+    const receive = (data) => $$incoming(key, data);
+
+    if (port.on) {
+      port.on('message', receive);
+      if (!(registry.pins.get(key) > 0)) port.unref?.();
+    } else {
+      port.onmessage = (event) => receive(event.data);
+    }
+  }
+
+  for (const [message, moved] of registry.waiting.get(key) ?? []) port.postMessage(message, moved);
+  registry.waiting.delete(key);
+}
+
+// A thread has stopped: what waits for it fails, and what it waited for is dropped.
+export function $$gone(key) {
+  const registry = $$registry();
+
+  registry.gone.add(key);
+  registry.ports.get(key)?.close?.();
+  registry.ports.delete(key);
+  registry.waiting.delete(key);
+  for (const [ask, request] of registry.requests) {
+    if (request.key !== key) continue;
+    registry.requests.delete(ask);
+    request.reject($$stopped());
+  }
+
+  for (const [id, state] of registry.states) {
+    const alive = (entry) => (entry.select?.key ?? entry.from) !== key;
+
+    state.receivers.$$keep(alive);
+    state.senders.$$keep(alive);
+    registry.handle?.pump(id);
+  }
+}
+
+// A message from another thread: an answer to a request, or an operation on a channel of this one.
+export function $$incoming(key, data) {
+  const registry = $$registry();
+
+  $$adopt(data);
+  if ('answer' in data) {
+    const request = registry.requests.get(data.answer);
+
+    registry.requests.delete(data.answer);
+    if (request) $$pin(request.key, -1);
+    if ('error' in data) request?.reject(data.error);
+    else request?.resolve(data.value);
+  } else if (data.op === 'hold') {
+    $$hold(data.channel, data.count);
+  } else if ('op' in data) {
+    registry.handle.message(key, data);
+  }
+}
+
+// Each value of a channel, in any thread, holds it: the thread that made it forgets it when none
+// is left. A thread counts the channels of a value before a copy of it goes to another thread, and
+// a copy lets go of them when it is collected.
+export function $$hold(id, count) {
+  const registry = $$registry();
+  const owner = $$ownerOf(id);
+
+  if (owner !== registry.key) return $$post(owner, { op: 'hold', channel: id, count });
+
+  const state = registry.states.get(id);
+
+  if (!state) return;
+  state.holders += count;
+  if (state.holders <= 0) registry.states.delete(id);
+}
+
+export function $$adopt(value) {
+  const { held } = $$registry();
+
+  for (const channel of $$walk(value).channels) held.register(channel, channel.$$chan);
+}
+
+// A copy in this thread. One that `own` the runtime, such as the arguments of `go` that wait for
+// a worker, moves its buffers on.
+export function $$copy(value, own = false) {
+  const { channels, moved } = $$walk(value);
+
+  for (const channel of channels) $$hold(channel.$$chan, 1);
+
+  const copy = structuredClone(value, { transfer: moved });
+  const { held } = $$registry();
+
+  for (const channel of $$walk(copy, own).channels) held.register(channel, channel.$$chan);
+
+  return copy;
+}
+
+// `transfer(x)`: the buffer of x moves to the thread that a value with it goes to, instead of a
+// copy; here it is left empty.
+export function $$transfer(value) {
+  $$registry().moved.add(ArrayBuffer.isView(value) ? value.buffer : value);
+
+  return value;
+}
+
+// The channels in a value, each of which becomes a copy in the thread that gets the value, and the
+// buffers that move there. A copy of a queue is its fields: here it gets its class again.
+export function $$walk(
+  value,
+  own = false,
+  found = { channels: new Set(), moved: [] },
+  seen = new Set(),
+) {
+  if (typeof value !== 'object' || value === null || seen.has(value)) return found;
+  seen.add(value);
+
+  const buffer =
+    value instanceof ArrayBuffer ? value : ArrayBuffer.isView(value) ? value.buffer : null;
+
+  // A SharedArrayBuffer is shared with the other thread, not moved.
+  if (buffer && !(buffer instanceof ArrayBuffer)) return found;
+  if (buffer) {
+    const { moved } = $$registry();
+
+    if (own) moved.add(buffer);
+    if (moved.has(buffer) && !found.moved.includes(buffer)) found.moved.push(buffer);
+
+    return found;
+  }
+
+  if (Array.isArray(value.$$queue)) Object.setPrototypeOf(value, $$Queue.prototype);
+  if (typeof value.$$chan === 'string') {
+    found.channels.add(value);
+
+    return found;
+  }
+
+  const items =
+    value instanceof Map
+      ? [...value.keys(), ...value.values()]
+      : value instanceof Set || Array.isArray(value)
+        ? value
+        : Object.values(value);
+
+  for (const item of items) $$walk(item, own, found, seen);
+
+  return found;
+}

package/src/runtime/timers.js

@@ -0,0 +1,27 @@
+// Channels of time, as in Go: `after(ms)` and `tick(ms)`.
+
+import { $$chan, $$send } from './chan.js';
+import { $$try } from './select.js';
+import { $$registry } from './threads.js';
+
+// `after(ms)`: a channel that gets the time once, after `ms`. `tick(ms)`: one that gets it every
+// `ms` until it is closed; a tick that finds the last one still there is dropped, as in Go.
+export function $$after(ms) {
+  const channel = $$chan(1, 0);
+
+  setTimeout(() => $$send(channel, Date.now()), ms);
+
+  return channel;
+}
+
+export function $$tick(ms) {
+  const channel = $$chan(1, 0);
+  const timer = setInterval(() => {
+    const state = $$registry().states.get(channel.$$chan);
+
+    if (!state || state.closed) clearInterval(timer);
+    else $$try(channel.$$chan, true, Date.now());
+  }, ms);
+
+  return channel;
+}

package/dist/codegen/chan-helpers.d.ts

@@ -1,2 +0,0 @@
-export type ChanHelper = 'chan' | 'timers';
-export declare const CHAN_HELPERS: Readonly<Record<ChanHelper, readonly string[]>>;

package/dist/codegen/chan-helpers.js

@@ -1,253 +0,0 @@
-// The helpers of channels: sending, receiving and closing, here or in the thread that made the
-// channel (thread-helpers.ts), and the queues of a channel. Receiving from a closed channel gives
-// the zero value of its type, as in Go.
-export const CHAN_HELPERS = {
-    chan: [
-        '$$registry().handle ??= { message: $$message, pump: $$pump };',
-        '',
-        'function $$chan(size, zero) {',
-        '  const registry = $$registry();',
-        '  const id = `${registry.key}:${registry.channels++}`;',
-        '  const channel = { $$chan: id, size, zero };',
-        '  registry.states.set(id, {',
-        '    size,',
-        '    zero,',
-        '    buffer: [],',
-        '    receivers: [],',
-        '    senders: [],',
-        '    closed: false,',
-        '    holders: 1,',
-        '    busy: false,',
-        '  });',
-        '  $$adopt(channel);',
-        '  return channel;',
-        '}',
-        '',
-        '// A local operation waits in the queue of its channel; one of another thread asks the thread',
-        '// that made the channel.',
-        'function $$send(channel, value) {',
-        '  const id = channel.$$chan;',
-        '  const owner = $$ownerOf(id);',
-        '  if (owner !== $$registry().key) return $$ask(owner, { op: "send", channel: id, value });',
-        '  return new Promise((resolve, reject) => $$wait(id, "senders", { value, done: resolve, fail: reject }));',
-        '}',
-        '',
-        'function $$receive(channel, withOk = false) {',
-        '  const id = channel.$$chan;',
-        '  const owner = $$ownerOf(id);',
-        '  const received =',
-        '    owner !== $$registry().key',
-        '      ? $$ask(owner, { op: "receive", channel: id })',
-        '      : new Promise((resolve, reject) => $$wait(id, "receivers", { done: resolve, fail: reject }));',
-        '  return withOk ? received : received.then(([value]) => value);',
-        '}',
-        '',
-        '// Closing a channel of another thread fails this one if it was closed already, as a panic would.',
-        'function $$close(channel) {',
-        '  const id = channel.$$chan;',
-        '  const owner = $$ownerOf(id);',
-        '  if (owner === $$registry().key) return $$closeHere(id);',
-        '  $$ask(owner, { op: "close", channel: id }).catch((error) => {',
-        '    setTimeout(() => {',
-        '      throw error;',
-        '    });',
-        '  });',
-        '}',
-        '',
-        'function $$closeHere(id) {',
-        '  const state = $$registry().states.get(id);',
-        '  if (state.closed) throw new Error("close of a closed channel");',
-        '  state.closed = true;',
-        '  $$pump(id);',
-        '}',
-        '',
-        'async function* $$range(channel) {',
-        '  while (true) {',
-        '    const [value, ok] = await $$receive(channel, true);',
-        '    if (!ok) return;',
-        '    yield value;',
-        '  }',
-        '}',
-        '',
-        'function $$wait(id, queue, entry) {',
-        '  const state = $$registry().states.get(id);',
-        '  if (!state) return entry.fail?.($$stopped());',
-        '  state[queue].push(entry);',
-        '  $$pump(id);',
-        '}',
-        '',
-        '// The operations of other threads on the channels of this one.',
-        'function $$message(from, data) {',
-        '  const answer = (value) => $$post(from, { answer: data.ask, value });',
-        '  const fail = (error) => $$post(from, { answer: data.ask, error });',
-        '  const select = { key: from, sid: data.sid };',
-        '  switch (data.op) {',
-        '    case "send":',
-        '      return $$wait(data.channel, "senders", { from, value: data.value, done: answer, fail });',
-        '    case "receive":',
-        '      return $$wait(data.channel, "receivers", { from, done: answer, fail });',
-        '    case "close":',
-        '      try {',
-        '        $$closeHere(data.channel);',
-        '        return answer();',
-        '      } catch (error) {',
-        '        return fail(error);',
-        '      }',
-        '    case "try":',
-        '      try {',
-        '        return answer($$try(data.channel, data.send, data.value));',
-        '      } catch (error) {',
-        '        return fail(error);',
-        '      }',
-        '    case "select":',
-        '      return $$select(data.cases, data.hasDefault).then(answer, fail);',
-        '    case "wait":',
-        '      return $$wait(data.channel, data.send ? "senders" : "receivers", {',
-        '        select,',
-        '        case: data.case,',
-        '        value: data.value,',
-        '      });',
-        '    case "cancel":',
-        '      return $$unwait(select, data.channels);',
-        '    case "lock":',
-        '      return answer($$lock(data.sid));',
-        '    case "unlock":',
-        '      return $$unlock(data.sid);',
-        '    case "commit":',
-        '      return $$commit(data.sid, data.case, data.result, data.error);',
-        '  }',
-        '}',
-        '',
-        '// Matches what waits in a channel: a receiver with a value of the buffer, a sender or the zero value',
-        '// after close; a sender with room in the buffer. A case of a select goes on only if its select',
-        '// has not gone on with another case, which the thread of the select tells.',
-        'function $$pump(id) {',
-        '  const state = $$registry().states.get(id);',
-        '  while (state && !state.busy) {',
-        '    const [receiver] = state.receivers;',
-        '    const [sender] = state.senders;',
-        '    if (receiver && (state.buffer.length > 0 || state.closed)) {',
-        '      if (!$$pair(id, state, receiver, null)) return;',
-        '    } else if (receiver && sender) {',
-        '      if (!$$pair(id, state, receiver, sender)) return;',
-        '    } else if (sender && (state.closed || state.buffer.length < state.size)) {',
-        '      if (!$$pair(id, state, null, sender)) return;',
-        '    } else {',
-        '      return;',
-        '    }',
-        '  }',
-        '}',
-        '',
-        '// Whether the pump can go on at once: a pair whose selects are all in this thread is decided here.',
-        'function $$pair(id, state, receiver, sender) {',
-        '  const entries = [receiver, sender].filter((entry) => entry !== null);',
-        '  const key = $$registry().key;',
-        '  if (entries.some((entry) => entry.select && entry.select.key !== key)) {',
-        '    $$pairLater(id, state, receiver, sender);',
-        '    return false;',
-        '  }',
-        '  const locks = entries.map((entry) => (entry.select ? $$lock(entry.select.sid) : "locked"));',
-        '  if (locks.every((lock) => lock === "locked")) {',
-        '    $$complete(state, receiver, sender);',
-        '    return true;',
-        '  }',
-        '  entries.forEach((entry, i) => locks[i] === "locked" && $$unlockAt(entry.select));',
-        '  return $$settle(id, state, entries, locks);',
-        '}',
-        '',
-        '// A pair with a select of another thread: the channel waits for the answers of that thread.',
-        'async function $$pairLater(id, state, receiver, sender) {',
-        '  state.busy = true;',
-        '  const entries = [receiver, sender].filter((entry) => entry !== null);',
-        '  const locks = [];',
-        '  for (const { select } of entries) {',
-        '    const lock = !select',
-        '      ? "locked"',
-        '      : select.key === $$registry().key',
-        '        ? $$lock(select.sid)',
-        '        : await $$ask(select.key, { op: "lock", sid: select.sid }).catch(() => "done");',
-        '    locks.push(lock);',
-        '    if (lock !== "locked") break;',
-        '  }',
-        '  state.busy = false;',
-        '  if (locks.length === entries.length && locks.every((lock) => lock === "locked")) {',
-        '    $$complete(state, receiver, sender);',
-        '  } else {',
-        '    entries.forEach((entry, i) => locks[i] === "locked" && $$unlockAt(entry.select));',
-        '    if (!$$settle(id, state, entries, locks)) return;',
-        '  }',
-        '  $$pump(id);',
-        '}',
-        '',
-        '// After a pair that could not go on: a select that has gone on leaves the queue; one that another',
-        '// channel is deciding is tried again a little later.',
-        'function $$settle(id, state, entries, locks) {',
-        '  entries.forEach((entry, i) => {',
-        '    if (locks[i] === "done") $$remove(state, entry);',
-        '  });',
-        '  if (locks.includes("done")) return true;',
-        '  setTimeout(() => $$pump(id), 1 + Math.random() * 4);',
-        '  return false;',
-        '}',
-        '',
-        'function $$remove(state, entry) {',
-        '  for (const queue of [state.receivers, state.senders]) {',
-        '    const at = queue.indexOf(entry);',
-        '    if (at >= 0) queue.splice(at, 1);',
-        '  }',
-        '}',
-        '',
-        '// Takes the pair off the queues and passes the value.',
-        'function $$complete(state, receiver, sender) {',
-        '  if (receiver) $$remove(state, receiver);',
-        '  if (sender) $$remove(state, sender);',
-        '  if (receiver) {',
-        '    const result =',
-        '      state.buffer.length > 0',
-        '        ? [state.buffer.shift(), true]',
-        '        : sender',
-        '          ? [sender.value, true]',
-        '          : [Array.isArray(state.zero) ? [] : state.zero, false];',
-        '    $$finish(receiver, result);',
-        '    if (sender) $$finish(sender);',
-        '  } else if (state.closed) {',
-        '    $$finish(sender, undefined, new Error("send on a closed channel"));',
-        '  } else {',
-        '    state.buffer.push(sender.value);',
-        '    $$finish(sender);',
-        '  }',
-        '}',
-        '',
-        'function $$finish(entry, result, error) {',
-        '  const { select } = entry;',
-        '  if (!select) return error ? entry.fail(error) : entry.done(result);',
-        '  if (select.key === $$registry().key) return $$commit(select.sid, entry.case, result, error);',
-        '  $$post(select.key, { op: "commit", sid: select.sid, case: entry.case, result, error });',
-        '}',
-        '',
-        'function $$unlockAt(select) {',
-        '  if (!select) return;',
-        '  if (select.key === $$registry().key) $$unlock(select.sid);',
-        '  else $$post(select.key, { op: "unlock", sid: select.sid });',
-        '}',
-    ],
-    timers: [
-        '// `after(ms)`: a channel that gets the time once, after `ms`. `tick(ms)`: one that gets it every',
-        '// `ms` until it is closed; a tick that finds the last one still there is dropped, as in Go.',
-        'function $$after(ms) {',
-        '  const channel = $$chan(1, 0);',
-        '  setTimeout(() => $$send(channel, Date.now()), ms);',
-        '  return channel;',
-        '}',
-        '',
-        'function $$tick(ms) {',
-        '  const channel = $$chan(1, 0);',
-        '  const timer = setInterval(() => {',
-        '    const state = $$registry().states.get(channel.$$chan);',
-        '    if (!state || state.closed) clearInterval(timer);',
-        '    else $$try(channel.$$chan, true, Date.now());',
-        '  }, ms);',
-        '  return channel;',
-        '}',
-    ],
-};

package/dist/codegen/go-helpers.d.ts

@@ -1,9 +0,0 @@
-export type GoHelper = 'go' | 'goLocal' | 'goFor' | 'shared' | 'serve' | 'cancel';
-export declare const GO_HELPERS: Readonly<Record<GoHelper, readonly string[]>>;
-/**
- * The start of a worker of a module: a Web Worker, or a worker thread of Node. Node takes only the
- * path of a `file:` URL, without the query of `app.rk?goroutines`, so its worker starts with a
- * module that imports the whole URL. An absolute URL, such as the Blob of the playground, is used
- * as it is.
- */
-export declare function startWorker(url: string): string[];