rooklang 0.3.2 → 0.3.4

package/src/runtime/threads.js

@@ -4,6 +4,7 @@
 // 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 { $$classOf, $$reclass } from './classes.js';
 import { $$Queue } from './queue.js';
 
 // The state of this thread that its modules share: the channels it made, its ports to the other
@@ -29,6 +30,12 @@ export function $$registry() {
   });
 }
 
+// Channel.EMPTY, the zero value of channel types, has this id in every thread: it is closed, and
+// no thread keeps it (channel.js).
+export function $$isEmpty(id) {
+  return id === 'empty';
+}
+
 // The key of the thread that made a channel, which keeps what it holds.
 export function $$ownerOf(id) {
   return id.slice(0, id.lastIndexOf(':'));
@@ -42,9 +49,11 @@ export function $$post(key, message) {
 
   if (registry.gone.has(key)) return;
 
-  const { channels, moved } = $$walk(message);
+  const { channels, moved, instances } = $$walk(message);
 
   for (const channel of channels) $$hold(channel.$$chan, 1);
+  // The copies of the instances of data classes are listed in the copy, by reference.
+  if (instances.length > 0) message = { ...message, $$instances: instances };
 
   const port = registry.ports.get(key);
 
@@ -136,6 +145,7 @@ export function $$incoming(key, data) {
   const registry = $$registry();
 
   $$adopt(data);
+  $$reclassed(data);
   if ('answer' in data) {
     const request = registry.requests.get(data.answer);
 
@@ -166,6 +176,11 @@ export function $$hold(id, count) {
   if (state.holders <= 0) registry.states.delete(id);
 }
 
+// A message with copies of the instances of data classes gives them their classes back.
+export function $$reclassed(data) {
+  if (data.$$instances) $$reclass(data.$$instances);
+}
+
 export function $$adopt(value) {
   const { held } = $$registry();
 
@@ -175,11 +190,19 @@ export function $$adopt(value) {
 // 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);
+  const { channels, moved, instances } = $$walk(value);
 
   for (const channel of channels) $$hold(channel.$$chan, 1);
 
-  const copy = structuredClone(value, { transfer: moved });
+  const { copy, $$instances } = structuredClone(
+    { copy: value, $$instances: instances },
+    {
+      transfer: moved,
+    },
+  );
+
+  $$reclass($$instances);
+
   const { held } = $$registry();
 
   for (const channel of $$walk(copy, own).channels) held.register(channel, channel.$$chan);
@@ -200,7 +223,7 @@ export function $$transfer(value) {
 export function $$walk(
   value,
   own = false,
-  found = { channels: new Set(), moved: [] },
+  found = { channels: new Set(), moved: [], instances: [] },
   seen = new Set(),
 ) {
   if (typeof value !== 'object' || value === null || seen.has(value)) return found;
@@ -221,8 +244,12 @@ export function $$walk(
   }
 
   if (Array.isArray(value.$$queue)) Object.setPrototypeOf(value, $$Queue.prototype);
+
+  const id = $$classOf(value);
+
+  if (id !== undefined) found.instances.push([value, id]);
   if (typeof value.$$chan === 'string') {
-    found.channels.add(value);
+    if (!$$isEmpty(value.$$chan)) found.channels.add(value);
 
     return found;
   }

package/src/runtime/topic.js

@@ -0,0 +1,118 @@
+// Topics: values that go to the other tabs of a site, and to its workers, over a BroadcastChannel
+// of their name. A topic is data, `{ $$topic: name, zero }`, so it goes to a worker as its name,
+// and there it is a topic of its own. Each topic listens from its first receive on, into a channel
+// without a limit, so that `<-t`, `for v in t` and `select` are those of channels. `Topic` has
+// what Rook code and the code compiled from it do with topics, by name.
+
+import { $$chan, $$closeHere, $$send } from './chan.js';
+import { $$Channel } from './channel.js';
+import { $$walk } from './threads.js';
+
+export const $$Topic = Object.freeze({
+  // The zero value of topic types: it has no name, it is closed, and what is sent to it goes
+  // nowhere.
+  EMPTY: Object.freeze({ $$topic: null, zero: null }),
+  make: $$topic,
+  publish: $$publish,
+  listen: $$listen,
+  close: $$closeTopic,
+});
+
+// What the modules of a thread share: one BroadcastChannel for each name, so that the topics of
+// this thread do not hear what it sends, as one BroadcastChannel does not hear itself; the channel
+// that each topic listens into, and the topics that are closed.
+function $$topics() {
+  return (globalThis[Symbol.for('rook.topics')] ??= {
+    names: new Map(),
+    channels: new WeakMap(),
+    closed: new WeakSet(),
+  });
+}
+
+export function $$topic(name, zero) {
+  return { $$topic: name, zero };
+}
+
+// `t <- v`: the value goes to the other threads that listen and is not kept here, so nothing waits.
+export function $$publish(topic, value) {
+  if (topic.$$topic === null) return;
+  if ($$topics().closed.has(topic)) throw new Error('send on a closed topic');
+  $$named(topic.$$topic).channel.postMessage(value);
+}
+
+// The channel that a topic listens into, from the first receive on; a closed topic gives a closed
+// one, and Topic.EMPTY gives Channel.EMPTY. A null topic turns off its case of `select`, as a null
+// channel does.
+export function $$listen(topic) {
+  if (topic === null) return null;
+  if (topic.$$topic === null) return $$Channel.EMPTY;
+
+  const { channels, closed } = $$topics();
+  let channel = channels.get(topic);
+
+  if (channel) return channel;
+  channel = $$chan(Infinity, topic.zero);
+  channels.set(topic, channel);
+  if (closed.has(topic)) $$closeHere(channel.$$chan);
+  else $$listening(topic, true);
+
+  return channel;
+}
+
+// `close(t)`: the topic stops listening and sending; what it has received can still be received.
+export function $$closeTopic(topic) {
+  const { channels, closed } = $$topics();
+
+  if (topic.$$topic === null) return;
+  if (closed.has(topic)) throw new Error('close of a closed topic');
+  closed.add(topic);
+
+  const channel = channels.get(topic);
+
+  if (!channel) return;
+  $$closeHere(channel.$$chan);
+  $$listening(topic, false);
+}
+
+// The BroadcastChannel of a name and the topics of this thread that listen to it, each of which
+// gets a copy of its own.
+function $$named(name) {
+  const { names, channels } = $$topics();
+  const found = names.get(name);
+
+  if (found) return found;
+
+  const entry = { channel: new BroadcastChannel(name), listening: new Set() };
+
+  entry.channel.onmessage = ({ data }) => {
+    let first = true;
+
+    for (const topic of entry.listening) {
+      const value = first ? data : structuredClone(data);
+
+      first = false;
+      $$walk(value);
+      $$send(channels.get(topic), value);
+    }
+  };
+
+  names.set(name, entry);
+  $$keepAlive(entry);
+
+  return entry;
+}
+
+function $$listening(topic, on) {
+  const entry = $$named(topic.$$topic);
+
+  if (on) entry.listening.add(topic);
+  else entry.listening.delete(topic);
+  $$keepAlive(entry);
+}
+
+// In Node, a BroadcastChannel keeps the program running only while a topic listens to it, as a
+// `tick` does until it is closed.
+function $$keepAlive({ channel, listening }) {
+  if (listening.size > 0) channel.ref?.();
+  else channel.unref?.();
+}

package/src/runtime/try.js

@@ -0,0 +1,45 @@
+// `try expr`: an exception in the expression becomes the error of `(T, error)`. `results` is how
+// many values the expression gives: 0 for none, and then the error comes alone, 1 for a value, more
+// for several. With `withError` the last of them is an error already, as of `(User, error)` or of a
+// function that returns only an error, and an exception takes its place.
+
+export function $$catch(f, results = 1, withError = false) {
+  let value;
+
+  try {
+    value = f();
+  } catch (error) {
+    return failed(error, results, withError);
+  }
+
+  return succeeded(value, results, withError);
+}
+
+/** `try` of an expression that waits: a rejected Promise is caught as an exception is. */
+export async function $$catchAsync(f, results = 1, withError = false) {
+  let value;
+
+  try {
+    value = await f();
+  } catch (error) {
+    return failed(error, results, withError);
+  }
+
+  return succeeded(value, results, withError);
+}
+
+function succeeded(value, results, withError) {
+  if (results === 0) return null;
+  if (withError) return value;
+
+  return results === 1 ? [value, null] : [...value, null];
+}
+
+/** JS can throw anything; what is not an Error becomes one, so that the error has a message. */
+function failed(thrown, results, withError) {
+  const error = thrown instanceof Error ? thrown : new Error(String(thrown));
+
+  if (results === 0 || (withError && results === 1)) return error;
+
+  return [...Array(withError ? results - 1 : results).fill(null), error];
+}