ciorent 0.3.7 → 0.3.8

package/README.md

@@ -32,7 +32,7 @@ Cross-runtime synchronous and asynchronous sleep functions.
 ```ts
 import * as co from 'ciorent';
 
-const logTime = (label: string) => console.log(`${label}: ${Math.floor(performance.now())}ms`);;
+const logTime = (label: string) => console.log(`${label}: ${Math.floor(performance.now())}ms`);
 
 logTime('Start');
 
@@ -112,39 +112,33 @@ co.spawn(5, task2);
 ```
 
 ### Pubsub
-A fast, simple publish-subscribe API.
+Pubsub allows broadcasting messages to topics that can be recieved by subscribers.
 
 ```ts
 import * as topic from 'ciorent/topic';
 import * as co from 'ciorent';
 
-const messages = topic.init<number>();
-
-// A task that publish messages
-const publisher = async () => {
-  for (let i = 0; i < 3; i++) {
-    await co.sleep(100);
-    topic.publish(messages, i);
-  }
-
-  // Resolve all waiting promises
-  // And clear the value queue
-  topic.flush(messages);
-}
+const numbers = topic.init();
 
-// Spawn 3 tasks that recieve messages
-co.spawn(3, async (id: number) => {
-  const sub = topic.subscribe(messages);
+// Spawn 3 tasks that subscribe to the topic
+co.spawn(3, async (id) => {
+  const subscriber = topic.subscribe(numbers);
 
   while (true) {
-    // Block until the value is sent
-    const x = await topic.dispatch(sub);
-    if (x == null) break;
-    console.log(`Task ${id} recieved: ${x}`);
+    const msg = await topic.dispatch(subscriber);
+    if (msg == null) return;
+    console.log('Task', id, 'recieved:', msg);
   }
 });
 
-publisher();
+// Publish messages to the topic
+for (let i = 0; i < 3; i++) {
+  topic.publish(numbers, i);
+  await co.nextTick;
+}
+
+// Send undefined to every topic
+topic.flush(numbers);
 ```
 
 ### Semaphore
@@ -176,6 +170,34 @@ const task = async (id: number) => {
 co.spawn(5, task);
 ```
 
+### Pubsub
+Pubsub allows broadcasting messages to topics that can be recieved by subscribers.
+
+```ts
+import * as stream from 'ciorent/stream';
+import * as co from 'ciorent';
+
+const numbers = stream.init();
+
+// Spawn 3 tasks that read from the stream
+co.spawn(3, async (id) => {
+  while (true) {
+    const msg = await stream.read(numbers);
+    if (msg == null) return;
+    console.log('Task', id, 'recieved:', msg);
+  }
+});
+
+// Write messages to the stream
+for (let i = 0; i < 3; i++) {
+  stream.write(numbers, i);
+  await co.nextTick;
+}
+
+// Send undefined to every stream
+stream.flush(numbers);
+```
+
 ### Defer
 Wait for a value to be resolved.
 
@@ -205,44 +227,6 @@ task();
 prepare();
 ```
 
-### Channel
-Channel is a synchronization primitive via message passing. A message may be sent over a channel, and another process is able to receive messages sent over a channel it has a reference to.
-
-```ts
-import * as channel from 'ciorent/channel';
-import * as co from 'ciorent';
-
-const chan = channel.init<number>();
-
-const run = async () => {
-  for (let i = 0; i < 5; i++) {
-    await co.sleep(100);
-    channel.send(chan, i);
-    console.log('Sent', i);
-  }
-
-  // Resolve all waiting promises with `undefined`
-  // This is a way to tell the reciever to not listen to more data
-  channel.flush(chan);
-};
-
-const log = async () => {
-  while (true) {
-    // Wait until a value is sent to the channel
-    const x = await channel.recieve(chan);
-    if (x == null) break;
-
-    console.log('Recieved', x);
-  };
-}
-
-log();
-run();
-
-// This runs first
-console.log('Starting...');
-```
-
 ### Fibers
 Virtual threads with more controlled execution.
 

package/fiber.d.ts

@@ -4,24 +4,24 @@
 /**
  * Describe a fiber process
  */
-export interface Process<TReturn = unknown> {
+export type Process<TReturn = unknown> = [
     /**
      * The waiting promise
      */
-    0: Promise<TReturn | undefined>;
+    proc: Promise<TReturn | undefined>,
     /**
      * Fiber status
      */
-    1: 0 | 1 | 2 | 3;
+    status: 0 | 1 | 2 | 3,
     /**
-     * Callback to continue running the fiber
+     * Callback to resume the fiber
      */
-    2: null | ((state: 1 | 3) => void);
+    resume: null | ((state: 1 | 3) => void),
     /**
      * Bounded fibers
      */
-    3: Process[];
-}
+    children: Process[]
+];
 /**
  * Describe a fiber runtime
  */

package/lock.d.ts

@@ -5,16 +5,16 @@ import type { Node as QueueNode } from './queue.js';
 /**
  * Describe a lock
  */
-export interface Lock<T = any> {
+export type Lock<T = any> = [
     /**
      * The head of the Promise resolve queue
      */
-    0: QueueNode<(value?: T) => void>;
+    head: QueueNode<(value?: T) => void>,
     /**
      * The tail of the Promise resolve queue
      */
-    1: QueueNode<(value?: T) => void>;
-}
+    tail: QueueNode<(value?: T) => void>
+];
 /**
  * Release an item
  * @param lock

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ciorent",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "description": "A lightweight, low-overhead concurrency library",
   "homepage": "https://ciorent.netlify.app",
   "repository": {
@@ -19,14 +19,14 @@
   "types": "./index.d.ts",
   "exports": {
     "./queue": "./queue.js",
-    "./channel": "./channel.js",
     "./sliding-queue": "./sliding-queue.js",
-    "./topic": "./topic.js",
-    "./lock": "./lock.js",
-    ".": "./index.js",
+    "./dropping-queue": "./dropping-queue.js",
     "./semaphore": "./semaphore.js",
+    "./lock": "./lock.js",
     "./defer": "./defer.js",
-    "./dropping-queue": "./dropping-queue.js",
+    ".": "./index.js",
+    "./stream": "./stream.js",
+    "./topic": "./topic.js",
     "./fiber": "./fiber.js"
   }
 }

package/queue.d.ts

@@ -4,33 +4,30 @@
 /**
  * Describe a fixed-sized queue
  */
-export interface Fixed<T extends {}> {
+export type Fixed<T extends {} = {}> = [
     /**
      * Pre-allocated queue
      */
-    readonly 0: (T | undefined | null)[];
+    buffer: (T | undefined | null)[],
     /**
      * Queue capacity
      */
-    readonly 1: number;
+    capacity: number,
     /**
      * Head pointer
      */
-    2: number;
+    head: number,
     /**
      * Tail pointer
      */
-    3: number;
-}
+    tail: number
+];
 /**
  * Describe a queue node (singly linked list node)
  */
-export interface Node<T> {
-    0: Node<T> | null;
-    1: T;
-}
+export type Node<T> = [next: Node<T> | null, value: T];
 /**
  * Create a fixed queue
  * @param n - The queue size
  */
-export declare const fixed: <T extends {}>(n: number) => Fixed<T>;
+export declare const fixed: <T extends {} = {}>(n: number) => Fixed<T>;

package/semaphore.d.ts

@@ -5,12 +5,12 @@ import { type Lock } from './lock.js';
 /**
  * Describe a semaphore
  */
-export interface Semaphore extends Lock<void> {
+export type Semaphore = Lock<void, [
     /**
      * Current remaining process allowed
      */
-    3: number;
-}
+    remain: number
+]>;
 /**
  * Create a semaphore that allows n accesses
  */

package/stream.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @module Streams
+ */
+import type { Node as QueueNode } from './queue.js';
+import type { AcquireCallback } from './lock.js';
+/**
+ * Describe a stream
+ */
+export type Stream<T extends {} = {}> = [
+    /**
+     * Queue head
+     */
+    head: QueueNode<T | ((val?: T) => void)>,
+    /**
+     * Queue tail
+     */
+    tail: QueueNode<T | ((val?: T) => void)>,
+    /**
+     * Whether the queue is containing items
+     */
+    queueing: boolean,
+    /**
+     * Cached callback
+     */
+    callback: AcquireCallback<T>
+];
+/**
+ * Create a stream
+ */
+export declare const init: <T extends {} = {}>() => Stream<T>;
+/**
+ * Write a value to the stream
+ * @param s
+ * @param v
+ */
+export declare const write: <T extends {} = {}>(s: Stream<T>, v: T) => void;
+/**
+ * Read a value from the stream
+ * @param s
+ */
+export declare const read: <T extends {} = {}>(s: Stream<T>) => Promise<T | undefined>;
+/**
+ * Release all pending read with undefined
+ */
+export declare const flush: (s: Stream) => void;

package/stream.js

@@ -0,0 +1 @@
+export let init=()=>{let queue=[null];let s=[queue,queue,false,(res)=>{s[0]=s[0][0]=[null,res]}];return s};export let write=(s,v)=>{if(!s[2]){if(s[1][0]!==null){(s[1]=s[1][0])[1](v);return}s[2]=true}s[0]=s[0][0]=[null,v]};export let read=(s)=>{if(s[2]){s[1]=s[1][0];if(s[1][0]===null)s[2]=false;return Promise.resolve(s[1][1])}return new Promise(s[3])};export let flush=(s)=>{if(!s[2])while(s[1][0]!==null)(s[1]=s[1][0])[1]()};

package/topic.d.ts

@@ -1,57 +1,46 @@
 /**
  * @module Pubsub
  */
-import type { Node as QueueNode } from './queue.js';
+import type { AcquireCallback } from "./lock.js";
+import type { Node as QueueNode } from "./queue.js";
 /**
  * Describe a topic
  */
-export interface Topic<T extends {}> {
-    /**
-     * The head node of the value queue
-     */
-    0: QueueNode<T>;
-    /**
-     * The waiting subscriber resolves
-     */
-    1: ((res: QueueNode<T>) => void)[];
-}
+export type Topic<T extends {} = {}> = [
+    head: QueueNode<T>,
+    callback: AcquireCallback<void>,
+    resolve: (() => void) | null,
+    pending: Promise<void> | null
+];
 /**
- * Create a topic
- */
-export declare const init: <T extends {}>() => Topic<T>;
-/**
- * Describe a topic
+ * Describe a subscriber
  */
-export interface Subscriber<T extends {}> {
-    0: Topic<T>;
-    1: QueueNode<T>;
-}
+export type Subscriber<T extends {} = {}> = [
+    topic: Topic<T>,
+    tail: QueueNode<T>
+];
 /**
- * Subscribe to a topic
- * @param t
+ * Create a topic
  */
-export declare const subscribe: <T extends {}>(t: Topic<T>) => Subscriber<T>;
+export declare const init: <T extends {} = {}>() => Topic<T>;
 /**
- * Publish to a topic
- * @param t
+ * Publish a message to the topic
+ * @param t - The topic
+ * @param m - The message to publish
  */
-export declare const publish: <T extends {}>(t: Topic<T>, value: T) => void;
+export declare const publish: <T extends {} = {}>(t: Topic<T>, m: T) => void;
 /**
- * Resolve all waiting promises and clear all pending values
- * @param t
+ * Resolve all pending dispatch
  */
-export declare const flush: <T extends {}>(t: Topic<T>) => void;
+export declare const flush: (t: Topic) => void;
 /**
- * Get the next value in the message queue.
- *
- * Returns `undefined` if the message queue is empty
+ * Subscribe to a topic
  * @param t
+ * @returns A subscriber object
  */
-export declare const poll: <T extends {}>(t: Subscriber<T>) => T | undefined;
+export declare const subscribe: <T extends {}>(t: Topic<T>) => Subscriber<T>;
 /**
- * Get the next value in the message queue
- *
- * Returns a promise that resolves when the message queue is not empty
+ * Wait for messages from the topic
  * @param t
  */
-export declare const dispatch: <T extends {}>(t: Subscriber<T>) => Promise<T | undefined>;
+export declare const dispatch: <T extends {}>(s: Subscriber<T>) => Promise<T | undefined>;

package/topic.js

@@ -1 +1 @@
-export let init=()=>{let t=[[null],[],(res)=>{t[1].push(res)}];return t};export let subscribe=(t)=>[t,t[0]];export let publish=(t,value)=>{let head=t[0]=t[0][0]=[null,value];for(let i=0,res=t[1];i<res.length;i++)res[i](head);t[1]=[]};export let flush=(t)=>{let head=t[0]=t[0][0]=[null,undefined];for(let i=0,res=t[1];i<res.length;i++)res[i](head);t[1]=[]};export let poll=(t)=>t[1][0]!==null?(t[1]=t[1][0])[1]:undefined;export let dispatch=async(t)=>t[1][0]!==null?(t[1]=t[1][0])[1]:(t[1]=await new Promise(t[0][2]))[1];
+export let init=()=>{let t=[[null],(res)=>{t[2]=res},null,null];return t};export let publish=(t,m)=>{t[0]=t[0][0]=[null,m];t[2]?.();t[2]=null};export let flush=publish;export let subscribe=(t)=>[t,t[0]];export let dispatch=async(s)=>{if(s[1][0]===null)await(s[0][2]!==null?s[0][3]:s[0][3]=new Promise(s[0][1]));return(s[1]=s[1][0])[1]};

package/channel.d.ts

@@ -1,39 +0,0 @@
-/**
- * @module Channels
- */
-import type { Node as QueueNode } from './queue.js';
-import { type Lock } from './lock.js';
-/**
- * Describe a channel
- */
-export interface Channel<T = any> extends Lock<T> {
-    /**
-     * The head of the value queue
-     */
-    3: QueueNode<T>;
-    /**
-     * The tail of the value queue
-     */
-    4: QueueNode<T>;
-}
-/**
- * Create a channel
- */
-export declare const init: <T extends {}>() => Channel<T>;
-/**
- * Send a message to a channel
- * @param c - The channel to send to
- * @param t - The message to send
- */
-export declare const send: <T>(c: Channel<T>, t: T) => void;
-/**
- * Recieve a message from a channel, return null if the channel is closed
- * @param c
- */
-export declare const recieve: <T>(c: Channel<T>) => Promise<T | undefined>;
-/**
- * Recieve a message from a channel, return undefined if no message is currently in queue
- * @param c
- */
-export declare const poll: <T>(c: Channel<T>) => T | undefined;
-export { flush } from './lock.js';

package/channel.js

@@ -1 +0,0 @@
-import{release as lockRelease,released as lockReleased}from"./lock.js";export let init=()=>{let resolveQu=[null];let qu=[null];let chan=[resolveQu,resolveQu,(res)=>{chan[0]=chan[0][0]=[null,res]},qu,qu];return chan};export let send=(c,t)=>{if(lockReleased(c))c[3]=c[3][0]=[null,t];else lockRelease(c,t)};export let recieve=(c)=>c[4][0]!==null?Promise.resolve((c[4]=c[4][0])[1]):new Promise(c[2]);export let poll=(c)=>c[4][0]!==null?(c[4]=c[4][0])[1]:undefined;export{flush}from"./lock.js";