rooklang 0.3.2 → 0.3.4

package/dist/walk.js

@@ -30,7 +30,7 @@ export function forEachChild(node, visit) {
             visit(node.name);
             each(node.params);
             each(node.results);
-            visit(node.body);
+            optional(node.body);
             break;
         case 'Parameter':
             visit(node.name);
@@ -111,11 +111,16 @@ export function forEachChild(node, visit) {
             visit(node.element);
             optional(node.items);
             break;
+        case 'TopicExpression':
+            visit(node.element);
+            visit(node.name);
+            break;
         case 'MakeExpression':
             visit(node.type);
             visit(node.length);
             break;
         case 'ConversionExpression':
+        case 'DecodeExpression':
             visit(node.type);
             visit(node.argument);
             break;
@@ -123,6 +128,7 @@ export function forEachChild(node, visit) {
             each(node.values);
             break;
         case 'IfStatement':
+            optional(node.init);
             visit(node.condition);
             visit(node.consequent);
             optional(node.alternate);
@@ -140,6 +146,7 @@ export function forEachChild(node, visit) {
             visit(node.body);
             break;
         case 'SwitchStatement':
+            optional(node.init);
             optional(node.discriminant);
             each(node.cases);
             break;
@@ -204,6 +211,7 @@ export function forEachChild(node, visit) {
             visit(node.body);
             break;
         case 'UnaryExpression':
+        case 'TryExpression':
             visit(node.argument);
             break;
         case 'GoExpression':
@@ -265,6 +273,7 @@ export function forEachChild(node, visit) {
         case 'ArrayType':
         case 'ChanType':
         case 'QueueType':
+        case 'TopicType':
         case 'NullableType':
         case 'FuncType':
         case 'ComponentType':
@@ -287,6 +296,7 @@ export function forEachChild(node, visit) {
         case 'NumberLiteral':
         case 'BigIntLiteral':
         case 'StringLiteral':
+        case 'RegExpLiteral':
         case 'TemplateElement':
         case 'BooleanLiteral':
         case 'NullLiteral':
@@ -295,30 +305,3 @@ export function forEachChild(node, visit) {
             break;
     }
 }
-/** Whether a `break` in these statements leaves the enclosing loop or switch. */
-export function containsBreak(statements) {
-    let found = false;
-    const visit = (node) => {
-        switch (node.kind) {
-            case 'BreakStatement':
-                found = true;
-                return;
-            // A `break` inside these belongs to them.
-            case 'ForStatement':
-            case 'ForInStatement':
-            case 'SwitchStatement':
-            case 'SelectStatement':
-            case 'FuncDeclaration':
-            case 'FuncExpression':
-            case 'ArrowFunction':
-            case 'ClassDeclaration':
-            case 'MountStatement':
-            case 'EffectStatement':
-                return;
-            default:
-                forEachChild(node, visit);
-        }
-    };
-    statements.forEach(visit);
-    return found;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rooklang",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "A language with JavaScript semantics, Go-style syntax, goroutines on real threads and static types that compiles to readable JavaScript",
   "keywords": [
     "rooklang",

package/src/runtime/chan.js

@@ -1,10 +1,11 @@
 // Channels: sending, receiving and closing, here or in the thread that made the channel
 // (threads.js), and the queues of a channel. Receiving from a closed channel gives
-// the zero value of its type, as in Go.
+// the zero value of its type, as in Go. Channel.EMPTY is closed and belongs to no thread: a send to
+// it goes nowhere, and receiving gives the zero value that the code that receives passes.
 
 import { $$Queue } from './queue.js';
 import { $$commit, $$lock, $$select, $$try, $$unlock, $$unwait } from './select.js';
-import { $$adopt, $$ask, $$ownerOf, $$post, $$registry, $$stopped } from './threads.js';
+import { $$adopt, $$ask, $$isEmpty, $$ownerOf, $$post, $$registry, $$stopped } from './threads.js';
 
 $$registry().handle ??= { message: $$message, pump: $$pump };
 
@@ -32,6 +33,9 @@ export function $$chan(size, zero) {
 // that made the channel.
 export function $$send(channel, value) {
   const id = channel.$$chan;
+
+  if ($$isEmpty(id)) return Promise.resolve();
+
   const owner = $$ownerOf(id);
 
   if (owner !== $$registry().key) return $$ask(owner, { op: 'send', channel: id, value });
@@ -41,11 +45,12 @@ export function $$send(channel, value) {
   );
 }
 
-export function $$receive(channel, withOk = false) {
+export function $$receive(channel, withOk = false, zero = null) {
   const id = channel.$$chan;
   const owner = $$ownerOf(id);
-  const received =
-    owner !== $$registry().key
+  const received = $$isEmpty(id)
+    ? Promise.resolve([zero, false])
+    : owner !== $$registry().key
       ? $$ask(owner, { op: 'receive', channel: id })
       : new Promise((resolve, reject) => $$wait(id, 'receivers', { done: resolve, fail: reject }));
 
@@ -55,6 +60,9 @@ export function $$receive(channel, withOk = false) {
 // Closing a channel of another thread fails this one if it was closed already, as a panic would.
 export function $$close(channel) {
   const id = channel.$$chan;
+
+  if ($$isEmpty(id)) return;
+
   const owner = $$ownerOf(id);
 
   if (owner === $$registry().key) return $$closeHere(id);
@@ -70,6 +78,8 @@ export function $$closeHere(id) {
 
   if (state.closed) throw new Error('close of a closed channel');
   state.closed = true;
+  // What made the channel stops with it, as signal() does (signals.js).
+  state.onClose?.();
   $$pump(id);
 }
 

package/src/runtime/channel.js

@@ -0,0 +1,28 @@
+// `Channel`: what Rook code and the code compiled from it do with channels, by name. The functions
+// themselves are in chan.js, select.js, signals.js, streams.js and timers.js.
+
+import { $$chan, $$close, $$range, $$receive, $$send } from './chan.js';
+import { $$select, $$try } from './select.js';
+import { $$abortSignal, $$done, $$signal } from './signals.js';
+import { $$fromStream, $$stream } from './streams.js';
+import { $$after, $$tick } from './timers.js';
+
+export const $$Channel = Object.freeze({
+  // The zero value of channel types: closed, and the same in every thread (threads.js).
+  EMPTY: Object.freeze({ $$chan: 'empty', size: 0, zero: null }),
+  make: $$chan,
+  send: $$send,
+  receive: $$receive,
+  close: $$close,
+  range: $$range,
+  select: $$select,
+  // [] for a send and [value, ok] for a receive that goes on at once, else null.
+  try: (channel, send, value) => $$try(channel.$$chan, send, value),
+  fromStream: $$fromStream,
+  stream: $$stream,
+  after: $$after,
+  tick: $$tick,
+  signal: $$signal,
+  done: $$done,
+  abortSignal: $$abortSignal,
+});

package/src/runtime/classes.js

@@ -0,0 +1,32 @@
+// Data classes: `data class Point` registers its class with an id of its own, the name and a hash
+// of its code, the same in a module and in its worker module, which has a copy of the class. A copy
+// of a value that goes to another thread loses the class of its instances (structuredClone); the
+// thread that sends lists them with their ids (threads.js), and the one that gets the copy gives
+// them their class again.
+
+function registry() {
+  return (globalThis[Symbol.for('rook.classes')] ??= { byId: new Map(), ids: new WeakMap() });
+}
+
+export function $$dataClass(cls, id) {
+  const { byId, ids } = registry();
+
+  byId.set(id, cls.prototype);
+  ids.set(cls.prototype, id);
+}
+
+/** The id of the data class of an instance, or undefined. */
+export function $$classOf(value) {
+  return registry().ids.get(Object.getPrototypeOf(value));
+}
+
+/** Gives the copies of instances their classes back: `[object, id]` pairs of a copied message. */
+export function $$reclass(instances) {
+  const { byId } = registry();
+
+  for (const [object, id] of instances) {
+    const prototype = byId.get(id);
+
+    if (prototype) Object.setPrototypeOf(object, prototype);
+  }
+}

package/src/runtime/core.js

@@ -1,4 +1,5 @@
-// What the code of any module may need: `for` over a value of unknown type, and `defer`.
+// What the code of any module may need: `for` over a value of unknown type, `defer`, and wrapped
+// errors.
 
 // `for v in x` over an untyped value: a Map gives its values, as a typed one does.
 export function $$values(iterable) {
@@ -21,3 +22,11 @@ export function $$runDeferred(deferred) {
 
   if (failure) throw failure.error;
 }
+
+// `error("load user", err)`: an error whose message ends with that of its cause, as `%w` of Go
+// gives "load user: not found", and whose `cause` is the error itself, for code that looks at it.
+export function $$wrap(message, cause) {
+  const reason = cause instanceof Error ? cause.message : String(cause);
+
+  return new Error(`${message}: ${reason}`, { cause });
+}

package/src/runtime/decode.js

@@ -0,0 +1,190 @@
+// `decode<T>(x)`: JSON text, or a value from JS, checked against the type T, which the compiler
+// writes as data: "number", "string", "bool", "any", { literal: [values] }, { nullable: T },
+// { array: T }, { record: T }, { union: [types] } and $$type(name, fields) for an object. A value
+// that fits is returned as it is, with the fields that T does not have; a nullable field may be
+// missing. The error says where the value does not fit: `decode User: tags[1]: expected string,
+// got 42`.
+
+/** An object type. Its fields come from a function, so that types can refer to each other. */
+export function $$type(name, fields) {
+  let resolved = null;
+
+  return {
+    name,
+    get fields() {
+      return (resolved ??= fields());
+    },
+  };
+}
+
+/** `decode<T>(text)` of a string: the JSON text is parsed, then checked. */
+export function $$decodeJson(text, type) {
+  let value;
+
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    return [null, new Error(`decode ${describe(type)}: invalid JSON: ${error.message}`)];
+  }
+
+  return $$decode(value, type);
+}
+
+/**
+ * `decode<T>(value)` of a value from JS. Without the types of the checker (`rook build --no-check`)
+ * the type is null: then a string is parsed as JSON text, and nothing is checked.
+ */
+export function $$decode(value, type) {
+  if (type === null) return typeof value === 'string' ? $$decodeJson(value, 'any') : [value, null];
+
+  const problem = check(value, type, []);
+
+  if (problem === null) return [value, null];
+
+  const where = problem.path.length > 0 ? `${pathText(problem.path)}: ` : '';
+
+  return [null, new Error(`decode ${describe(type)}: ${where}${problem.message}`)];
+}
+
+const PRIMITIVES = { number: 'number', string: 'string', bool: 'boolean' };
+
+/** Where and how the value does not fit the type, or null if it does. */
+function check(value, type, path) {
+  if (typeof type === 'string') {
+    return type === 'any' || typeof value === PRIMITIVES[type] ? null : mismatch(value, type, path);
+  }
+
+  if ('literal' in type) return type.literal.includes(value) ? null : mismatch(value, type, path);
+
+  if ('nullable' in type) {
+    if (value == null) return null;
+
+    const problem = check(value, type.nullable, path);
+
+    // The value itself is of another type: the message names ?T, not T.
+    return problem !== null && problem.path.length === path.length
+      ? mismatch(value, type, path)
+      : problem;
+  }
+
+  if ('array' in type) {
+    if (!Array.isArray(value)) return mismatch(value, type, path);
+
+    for (let i = 0; i < value.length; i++) {
+      const problem = check(value[i], type.array, [...path, i]);
+
+      if (problem !== null) return problem;
+    }
+
+    return null;
+  }
+
+  if ('union' in type) return checkUnion(value, type, path);
+  if (!isObject(value)) return mismatch(value, type, path);
+
+  if ('record' in type) {
+    for (const key of Object.keys(value)) {
+      const problem = check(value[key], type.record, [...path, key]);
+
+      if (problem !== null) return problem;
+    }
+
+    return null;
+  }
+
+  for (const [name, field] of Object.entries(type.fields)) {
+    // Only own fields: a field named `toString` is not the method of every object.
+    if (!Object.hasOwn(value, name)) {
+      if (isOptional(field)) continue;
+
+      return { path: [...path, name], message: 'missing' };
+    }
+
+    const problem = check(value[name], field, [...path, name]);
+
+    if (problem !== null) return problem;
+  }
+
+  return null;
+}
+
+/**
+ * The value fits one of the types. If none fits, the type whose check went deepest into the value
+ * is most likely the one meant, `{ kind: "circle", r: "2" }` of `Circle | Square`, so its problem
+ * is the one reported.
+ */
+function checkUnion(value, type, path) {
+  let deepest = null;
+
+  for (const member of type.union) {
+    const problem = check(value, member, path);
+
+    if (problem === null) return null;
+    if (problem.path.length > (deepest?.path.length ?? path.length)) deepest = problem;
+  }
+
+  return deepest ?? mismatch(value, type, path);
+}
+
+function isObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function isOptional(type) {
+  return type === 'any' || (typeof type === 'object' && 'nullable' in type);
+}
+
+function mismatch(value, type, path) {
+  return { path, message: `expected ${describe(type)}, got ${shown(value)}` };
+}
+
+/** The type as Rook writes it: `[]string`, `?User`, `"admin" | "user"`. */
+function describe(type) {
+  if (typeof type === 'string') return type;
+  if ('literal' in type) return type.literal.map((value) => JSON.stringify(value)).join(' | ');
+  if ('nullable' in type) return `?${grouped(type.nullable)}`;
+  if ('array' in type) return `[]${grouped(type.array)}`;
+  if ('record' in type) return `{ [key string]: ${describe(type.record)} }`;
+  if ('union' in type) return type.union.map(describe).join(' | ');
+
+  return type.name;
+}
+
+function grouped(type) {
+  const several = typeof type === 'object' && ('union' in type || type.literal?.length > 1);
+
+  return several ? `(${describe(type)})` : describe(type);
+}
+
+/** The value in a message: a primitive itself, a long string cut, and the kind of anything else. */
+function shown(value) {
+  if (value === null) return 'null';
+  if (Array.isArray(value)) return 'an array';
+
+  switch (typeof value) {
+    case 'string':
+      return JSON.stringify(value.length > 40 ? `${value.slice(0, 40)}…` : value);
+
+    case 'number':
+    case 'boolean':
+      return String(value);
+
+    case 'object':
+      return 'an object';
+
+    default:
+      return typeof value;
+  }
+}
+
+/** `tags[1]`, `boss.name`, `["first name"]`. */
+function pathText(path) {
+  return path
+    .map((key, i) => {
+      if (typeof key === 'number') return `[${key}]`;
+      if (/^[A-Za-z_$][\w$]*$/.test(key)) return i === 0 ? key : `.${key}`;
+
+      return `[${JSON.stringify(key)}]`;
+    })
+    .join('');
+}

package/src/runtime/go.js

@@ -9,6 +9,7 @@ import {
   $$gone,
   $$incoming,
   $$post,
+  $$reclassed,
   $$registry,
   $$transfer,
 } from './threads.js';
@@ -142,6 +143,7 @@ export function $$pool() {
       worker.owns = data.owns;
     } else if ('returned' in data) {
       $$adopt(data);
+      $$reclassed(data);
 
       const call = calls.get(data.returned);
 
@@ -238,12 +240,18 @@ export function $$goHere(functions, fn, args) {
   return task;
 }
 
-// `go for`: the array is split into parts, one per processor, each part runs as a goroutine of `go`
-// of the module, and
-// the loop waits for all of them. A typed array on a SharedArrayBuffer is shared with the workers,
-// which write into it; other parts are copies, moved to the workers and back into the array.
+// `go for`: the array is split into parts, each part runs as a goroutine of `go` of the module, and
+// the loop waits for all of them. The pool gives a part to the first worker that is free, so with
+// several parts per processor the workers end at about the same time, also when some elements take
+// longer than others or some processors are slower. The names that the body uses are copied with
+// each part: if one of them is an object, which may be large, there is one part per processor. A
+// typed array on a SharedArrayBuffer is shared with the workers, which write into it; other parts
+// are copies, moved to the workers and back into the array.
 export async function $$goFor(go, name, items, ...captured) {
-  const count = Math.min(globalThis.navigator?.hardwareConcurrency ?? 4, items.length);
+  const partsPerProcessor = 4;
+  const processors = globalThis.navigator?.hardwareConcurrency ?? 4;
+  const small = captured.every((value) => typeof value !== 'object' || value === null);
+  const count = Math.min(small ? processors * partsPerProcessor : processors, items.length);
   const shared =
     typeof SharedArrayBuffer === 'function' && items.buffer instanceof SharedArrayBuffer;
   const parts = [];
@@ -305,6 +313,7 @@ export async function $$serve(functions) {
     if ('gone' in data) return $$gone(data.gone);
     setTimeout(free);
     $$adopt(data.args);
+    $$reclassed(data);
 
     const { main } = registry;
 

package/src/runtime/index.js

@@ -3,11 +3,17 @@
 // The compiler can also put the parts that a module needs into the module itself (runtime.ts).
 
 export * from './chan.js';
+export * from './channel.js';
+export * from './classes.js';
 export * from './core.js';
+export * from './decode.js';
 export * from './go.js';
 export * from './markup.js';
 export * from './queue.js';
 export * from './select.js';
+export * from './signals.js';
 export * from './streams.js';
 export * from './threads.js';
 export * from './timers.js';
+export * from './topic.js';
+export * from './try.js';

package/src/runtime/select.js

@@ -3,12 +3,13 @@
 // channels of a select.
 
 import { $$finish, $$pump, $$zero } from './chan.js';
-import { $$ask, $$ownerOf, $$pin, $$post, $$registry, $$stopped } from './threads.js';
+import { $$ask, $$isEmpty, $$ownerOf, $$pin, $$post, $$registry, $$stopped } from './threads.js';
 
 // `select`: the index of the case that went on, and what it received. A case is { channel } to
-// receive or { channel, value } to send; from another thread, { channel, send, value }. One that
-// can go on at once wins, a random one as in Go; else `default`, -1, if there is one; else the
-// first that can go on later. A case with a null channel never goes on.
+// receive or { channel, value } to send, with the zero value that Channel.EMPTY gives, if it is
+// not null; from another thread, { channel, send, value }. One that can go on at once wins, a
+// random one as in Go; else `default`, -1, if there is one; else the first that can go on later.
+// A case with a null channel never goes on, and one with Channel.EMPTY always can.
 export async function $$select(cases, hasDefault) {
   const registry = $$registry();
   const all = cases.map((each, i) => ({
@@ -16,12 +17,13 @@ export async function $$select(cases, hasDefault) {
     id: typeof each.channel === 'string' ? each.channel : (each.channel?.$$chan ?? null),
     send: each.send ?? 'value' in each,
     value: each.value,
+    zero: each.zero ?? null,
   }));
   const live = all.filter(({ id }) => id !== null);
-  const owners = new Set(live.map(({ id }) => $$ownerOf(id)));
+  const owners = new Set(live.filter(({ id }) => !$$isEmpty(id)).map(({ id }) => $$ownerOf(id)));
 
   // The channels of one other thread: the select runs there.
-  if (owners.size === 1 && !owners.has(registry.key)) {
+  if (owners.size === 1 && !owners.has(registry.key) && live.every(({ id }) => !$$isEmpty(id))) {
     const [owner] = owners;
 
     return $$ask(owner, {
@@ -34,10 +36,13 @@ export async function $$select(cases, hasDefault) {
   const order = live.map(({ i }) => i).sort(() => Math.random() - 0.5);
 
   for (const i of order) {
-    const { id, send, value } = all[i];
+    const { id, send, value, zero } = all[i];
     const owner = $$ownerOf(id);
-    const ready =
-      owner === registry.key
+    const ready = $$isEmpty(id)
+      ? send
+        ? []
+        : [zero, false]
+      : owner === registry.key
         ? $$try(id, send, value)
         : await $$ask(owner, { op: 'try', channel: id, send, value });
 

package/src/runtime/signals.js

@@ -0,0 +1,59 @@
+// Signals of the process and AbortSignal as channels: `signal(...names)`, `done(abortSignal)` and
+// `abortSignal(ch)`, as signal.Notify and the Done() of a context are in Go.
+
+import { $$chan, $$closeHere, $$receive } from './chan.js';
+import { $$try } from './select.js';
+import { $$registry } from './threads.js';
+
+// `signal("SIGINT", "SIGTERM")`: a channel that gets the name of each signal that comes. While it
+// listens, the signals do not end the process, and it keeps the program running, as a tick does;
+// `close(ch)` stops it, and the signals do what they did before. A signal that finds the last one
+// not received yet is dropped. Only the main thread of Node gets the signals of the process.
+export function $$signal(...names) {
+  // Node's own, which a browser does not have.
+  const { process } = globalThis;
+
+  if (process === undefined) throw new Error('signal() needs Node: a browser has no signals');
+
+  const channel = $$chan(1, '');
+  const listener = (name) => $$try(channel.$$chan, true, name);
+  // A listener of a signal does not keep the program running, and a timer that never fires does.
+  const timer = setInterval(() => {}, 2 ** 31 - 1);
+
+  for (const name of names) process.on(name, listener);
+  $$registry().states.get(channel.$$chan).onClose = () => {
+    clearInterval(timer);
+    for (const name of names) process.off(name, listener);
+  };
+
+  return channel;
+}
+
+// `done(signal)`: a channel that gets the reason of an AbortSignal when it aborts, and is closed
+// then, so that `case <-done(request.signal):` goes on once the request is cancelled.
+export function $$done(signal) {
+  const channel = $$chan(1, null);
+  const abort = () => {
+    $$try(channel.$$chan, true, signal.reason);
+    $$closeHere(channel.$$chan);
+  };
+
+  if (signal.aborted) abort();
+  else signal.addEventListener('abort', abort, { once: true });
+
+  return channel;
+}
+
+// `abortSignal(ch)`: an AbortSignal that aborts when the channel gets a value, with the value as
+// its reason, or is closed, for `fetch(url, { signal: abortSignal(stop) })`. It receives that one
+// value, as any receiver of the channel would.
+export function $$abortSignal(channel) {
+  const controller = new AbortController();
+
+  $$receive(channel, true).then(
+    ([value, ok]) => controller.abort(ok ? value : undefined),
+    (error) => controller.abort(error),
+  );
+
+  return controller.signal;
+}