ciorent 0.3.7 → 0.3.9

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);
-  }
+const numbers = topic.init<number>();
 
-  // Resolve all waiting promises
-  // And clear the value queue
-  topic.flush(messages);
-}
-
-// 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,71 +170,32 @@ const task = async (id: number) => {
 co.spawn(5, task);
 ```
 
-### Defer
-Wait for a value to be resolved.
+### Stream
+Send and recieve data asynchronously through streams.
 
 ```ts
-import * as defer from 'ciorent/defer';
-
-const logTime = (label: string) => console.log(`${label}: ${Math.floor(performance.now())}ms`);
-
-const deferredUrl = defer.init<string>();
-
-const task = async () => {
-  // Blocks until the defer is resolved
-  const url = await defer.wait(deferredUrl);
-
-  logTime('Start fetching');
-  await fetch(url).catch(() => {});
-  logTime('Done fetching');
-}
-
-const prepare = () => {
-  // This always run first as task is waiting
-  logTime('Run before fetch');
-  defer.resolve(deferredUrl, 'http://localhost:3000');
-}
-
-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 stream from 'ciorent/stream';
 import * as co from 'ciorent';
 
-const chan = channel.init<number>();
+const numbers = stream.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 () => {
+// Spawn 3 tasks that read from the stream
+co.spawn(3, async (id) => {
   while (true) {
-    // Wait until a value is sent to the channel
-    const x = await channel.recieve(chan);
-    if (x == null) break;
+    const msg = await stream.read(numbers);
+    if (msg == null) return;
+    console.log('Task', id, 'recieved:', msg);
+  }
+});
 
-    console.log('Recieved', x);
-  };
+// Write messages to the stream
+for (let i = 0; i < 3; i++) {
+  stream.write(numbers, i);
+  await co.nextTick;
 }
 
-log();
-run();
-
-// This runs first
-console.log('Starting...');
+// Send undefined to every stream
+stream.flush(numbers);
 ```
 
 ### Fibers

package/dropping-queue.d.ts

@@ -1,7 +1,7 @@
 /**
  * @module Dropping queues
  */
-import type { Fixed } from './queue.js';
+import type { FixedQueue } from './queue.js';
 export { fixed as init } from './queue.js';
 export { pop } from './sliding-queue.js';
 /**
@@ -9,4 +9,4 @@ export { pop } from './sliding-queue.js';
  * @param q - The queue to push to
  * @param item
  */
-export declare const push: <T extends {}>(q: Fixed<T>, item: T) => boolean;
+export declare const push: <T extends {}>(q: FixedQueue<T>, item: T) => boolean;

package/fiber.d.ts

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

package/index.js

@@ -1 +1 @@
-export let nextTick=Promise.resolve();export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.("timers/promises").setTimeout??((ms)=>new Promise((res)=>{setTimeout(res,ms)}));let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??((ms)=>{Atomics.wait(sharedBuf,0,0,ms)});export let sequential=async(n,task,...args)=>{for(let i=0;i<n;i++)await task(...args,i)};export let spawn=(n,task,...args)=>{let arr=new Array(n);for(let i=0;i<n;i++)arr[i]=task(...args,i);return arr};export let debounce=(f,ms)=>{let id;return(...a)=>{clearTimeout(id);id=setTimeout(f,ms,...a)}};export let throttle=(ms,limit)=>{let head=[null];let tail=head;let promiseCb=(res)=>{head=head[0]=[null,res]};let cur=limit;let scheduled=false;let unlock=()=>{cur=limit;if(tail===head){scheduled=false;return}do{cur--;(tail=tail[0])[1]()}while(cur>0&&tail!==head);setTimeout(unlock,ms)};return()=>{if(cur===0)return new Promise(promiseCb);if(!scheduled){scheduled=true;setTimeout(unlock,ms)}cur--;return nextTick}};
+export let nextTick=Promise.resolve();export let sleep=globalThis.Bun?.sleep??globalThis.process?.getBuiltinModule?.("timers/promises").setTimeout??((ms)=>new Promise((res)=>{setTimeout(res,ms)}));let sharedBuf=new Int32Array(new SharedArrayBuffer(4));export let sleepSync=globalThis.Bun?.sleepSync??((ms)=>{Atomics.wait(sharedBuf,0,0,ms)});export let sequential=async(n,task,...args)=>{for(let i=0;i<n;i++)await task(...args,i)};export let spawn=(n,task,...args)=>{let arr=new Array(n);for(let i=0;i<n;i++)arr[i]=task(...args,i);return arr};export let debounce=(f,ms)=>{let id;return(...a)=>{clearTimeout(id);id=setTimeout(f,ms,...a)}};export let throttle=(ms,limit)=>{let head=[null];let tail=head;let promiseCb=(res)=>{head=head[0]=[null,res]};let cur=limit;let scheduled=false;let unlock=()=>{cur=limit;if(tail===head){scheduled=false;return}do{cur--;(tail=tail[0])[1]()}while(cur>0&&tail!==head);setTimeout(unlock,ms)};return async()=>{if(cur===0)return new Promise(promiseCb);if(!scheduled){scheduled=true;setTimeout(unlock,ms)}cur--}};

package/package.json

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

package/queue.d.ts

@@ -4,33 +4,25 @@
 /**
  * Describe a fixed-sized queue
  */
-export interface Fixed<T extends {}> {
-    /**
-     * Pre-allocated queue
-     */
-    readonly 0: (T | undefined | null)[];
-    /**
-     * Queue capacity
-     */
-    readonly 1: number;
-    /**
-     * Head pointer
-     */
-    2: number;
-    /**
-     * Tail pointer
-     */
-    3: number;
-}
+export type FixedQueue<T extends {} = {}> = [
+    buffer: (T | undefined | null)[],
+    capacity: number,
+    head: number,
+    tail: number
+];
 /**
  * Describe a queue node (singly linked list node)
  */
-export interface Node<T> {
-    0: Node<T> | null;
-    1: T;
-}
+export type QueueNode<T> = [next: QueueNode<T> | null, value: T];
+/**
+ * Describe an unbounded queue
+ */
+export type UnboundedQueue<T> = [
+    head: QueueNode<T>,
+    tail: QueueNode<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) => FixedQueue<T>;

package/semaphore.d.ts

@@ -1,16 +1,14 @@
 /**
  * @module Semaphores
  */
-import { type Lock } from './lock.js';
+import type { UnboundedQueue } from './queue.js';
 /**
  * Describe a semaphore
  */
-export interface Semaphore extends Lock<void> {
-    /**
-     * Current remaining process allowed
-     */
-    3: number;
-}
+export type Semaphore = [
+    ...UnboundedQueue<() => void>,
+    remain: number
+];
 /**
  * Create a semaphore that allows n accesses
  */

package/semaphore.js

@@ -1 +1 @@
-import{nextTick as resolvedPromise}from"./index.js";import{release as lockRelease}from"./lock.js";export let init=(n)=>{let root=[null];let sem=[root,root,(res)=>{sem[0]=sem[0][0]=[null,res]},n];return sem};export let acquire=(s)=>{s[3]--;return s[3]>=0?resolvedPromise:new Promise(s[2])};export let release=(s)=>{if(s[3]<0)lockRelease(s);s[3]++};export let bind=(f,s)=>async(...a)=>{s[3]--;if(s[3]<0)await new Promise(s[2]);try{return await f(...a)}finally{if(s[3]<0)release(s);s[3]++}};
+export let init=(n)=>{let root=[null];let sem=[root,root,(res)=>{sem[0]=sem[0][0]=[null,res]},n];return sem};export let acquire=async(s)=>{s[3]--;if(s[3]<0)return new Promise(s[2])};export let release=(s)=>{if(s[3]<0)(s[1]=s[1][0])[1]();s[3]++};export let bind=(f,s)=>async(...a)=>{s[3]--;if(s[3]<0)await new Promise(s[2]);try{return await f(...a)}finally{if(s[3]<0)(s[1]=s[1][0])[1]();s[3]++}};

package/sliding-queue.d.ts

@@ -1,16 +1,16 @@
 /**
  * @module Sliding queues
  */
-import type { Fixed } from './queue.js';
+import type { FixedQueue } from './queue.js';
 export { fixed as init } from './queue.js';
 /**
  * Push an item to a sliding queue
  * @param q - The queue to push to
  * @param item
  */
-export declare const push: <T extends {}>(q: Fixed<T>, item: T) => void;
+export declare const push: <T extends {}>(q: FixedQueue<T>, item: T) => void;
 /**
  * Pop an item from the queue
  * @param q - The queue to pop from
  */
-export declare const pop: <T extends {}>(q: Fixed<T>) => T | undefined;
+export declare const pop: <T extends {}>(q: FixedQueue<T>) => T | undefined;

package/stream.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @module Streams
+ */
+import type { UnboundedQueue } from './queue.js';
+/**
+ * Describe a stream
+ */
+export type Stream<T extends {} = {}> = [
+    ...UnboundedQueue<T | ((val?: T) => void)>,
+    queueing: boolean
+];
+/**
+ * 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,(res)=>{s[0]=s[0][0]=[null,res]},false];return s};export let write=(s,v)=>{if(!s[3]){if(s[1][0]!==null){(s[1]=s[1][0])[1](v);return}s[3]=true}s[0]=s[0][0]=[null,v]};export let read=async(s)=>{if(s[3]){s[1]=s[1][0];if(s[1][0]===null)s[3]=false;return s[1][1]}return new Promise(s[2])};export let flush=(s)=>{if(!s[3])while(s[1][0]!==null)(s[1]=s[1][0])[1]()};

package/topic.d.ts

@@ -1,57 +1,44 @@
 /**
  * @module Pubsub
  */
-import type { Node as QueueNode } from './queue.js';
+import type { 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>,
+    resolve: (() => void) | null,
+    pending: Promise<void> | null
+];
 /**
- * Create a topic
+ * Describe a subscriber
  */
-export declare const init: <T extends {}>() => Topic<T>;
+export type Subscriber<T extends {} = {}> = [
+    topic: Topic<T>,
+    tail: QueueNode<T>
+];
 /**
- * Describe a topic
+ * Create a topic
  */
-export interface Subscriber<T extends {}> {
-    0: Topic<T>;
-    1: QueueNode<T>;
-}
+export declare const init: <T extends {} = {}>() => Topic<T>;
 /**
- * Subscribe to a topic
- * @param t
+ * Publish a message to the topic
+ * @param t - The topic
+ * @param m - The message to publish
  */
-export declare const subscribe: <T extends {}>(t: Topic<T>) => Subscriber<T>;
+export declare const publish: <T extends {} = {}>(t: Topic<T>, m: T) => void;
 /**
- * Publish to a topic
- * @param t
+ * Resolve all pending dispatch
  */
-export declare const publish: <T extends {}>(t: Topic<T>, value: T) => void;
+export declare const flush: (t: Topic) => void;
 /**
- * Resolve all waiting promises and clear all pending values
- * @param t
- */
-export declare const flush: <T extends {}>(t: Topic<T>) => 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
- * @param t
+ * Wait for messages from the topic
+ * @param s
  */
-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";

package/defer.d.ts

@@ -1,22 +0,0 @@
-/**
- * @module Deferred values
- */
-/**
- * Describe a defer
- */
-export type Defer<T = any> = [
-    wait: Promise<T>,
-    open: (value: T | PromiseLike<T>) => void
-];
-/**
- * Create a latch
- */
-export declare const init: <T>() => Defer<T>;
-/**
- * Wait until a deferred is resolved
- */
-export declare const wait: <T>(d: Defer<T>) => Promise<T>;
-/**
- * Resolve the defer
- */
-export declare const resolve: (<T extends {}>(d: Defer<T>, p: T | PromiseLike<T>) => void) & ((d: Defer<void>) => void);

package/defer.js

@@ -1 +0,0 @@
-export let init=()=>{let r;return[new Promise((res)=>{r=res}),r]};export let wait=(d)=>d[0];export let resolve=(d,p)=>{d[1](p)};

package/lock.d.ts

@@ -1,33 +0,0 @@
-/**
- * @module Lock utilities
- */
-import type { Node as QueueNode } from './queue.js';
-/**
- * Describe a lock
- */
-export interface Lock<T = any> {
-    /**
-     * The head of the Promise resolve queue
-     */
-    0: QueueNode<(value?: T) => void>;
-    /**
-     * The tail of the Promise resolve queue
-     */
-    1: QueueNode<(value?: T) => void>;
-}
-/**
- * Release an item
- * @param lock
- * @param value
- */
-export declare const release: <T>(lock: Lock<T>, value?: T) => void;
-/**
- * Return true if all items are released
- * @param lock
- */
-export declare const released: (lock: Lock) => boolean;
-/**
- * Release all items of a lock
- * @param lock
- */
-export declare const flush: (lock: Lock) => void;

package/lock.js

@@ -1 +0,0 @@
-export let release=(lock,value)=>{(lock[1]=lock[1][0])[1](value)};export let released=(lock)=>lock[1][0]===null;export let flush=(lock)=>{while(lock[1][0]!==null)(lock[1]=lock[1][0])[1]()};