ciorent 0.1.2 → 0.1.4

package/README.md

@@ -4,7 +4,7 @@ Semaphore is a concurrency primitive used to control access to a common resource
 
 ```ts
 import * as semaphore from 'ciorent/semaphore';
-import * as cio from 'ciorent';
+import * as co from 'ciorent';
 
 // Only allow 2 task to run concurrently
 const sem = semaphore.init(2);
@@ -16,7 +16,7 @@ const task = async (id: number) => {
   console.log('Task', id, 'started');
 
   // Let the main thread schedules other tasks
-  for (let i = 1; i <= 5; i++) await cio.pause;
+  for (let i = 1; i <= 5; i++) await co.pause;
 
   console.log('Task', id, 'end');
 
@@ -25,41 +25,39 @@ const task = async (id: number) => {
 }
 
 // Try to run 5 tasks concurrently
-cio.concurrent(5, task);
+co.spawn(5, task);
 ```
 
 ## Fibers
 Virtual threads with more controlled execution.
 
 ```ts
-import * as cio from 'ciorent';
+import * as co from 'ciorent';
 import * as fiber from 'ciorent/fiber';
 
-const thread1 = fiber.fn(function* () {
+const f1 = fiber.fn(function* () {
   console.log('Fiber 1 started');
 
-  // Thread1 will be interrupted by thread2
-  // As thread2 will end first
-  yield cio.sleep(1000);
+  // Wait for a promise
+  yield co.sleep(1000);
 
   console.log('Fiber 1 done');
+  return Math.random();
 });
 
-const thread2 = fiber.fn(function* (thread) {
+fiber.spawn(function* (proc) {
   console.log('Fiber 2 started');
 
-  yield;
-  console.log('Fiber 2 resumed');
+  // Start f1, wait for it to finish and get the result
+  const res = yield* fiber.join(fiber.spawn(f1));
+  console.log('Fiber 1 result:', res);
 
-  // Start thread 1 and make thread1
-  // lifetime depends on thread2
-  fiber.mount(fiber.spawn(thread1), thread);
+  // Start f1 and make its lifetime depends on current fiber
+  fiber.mount(fiber.spawn(f1), proc);
 
+  // The runtime will interrupt f1
   console.log('Fiber 2 done');
 });
-
-// Start running the thread
-fiber.spawn(thread2);
 ```
 
 ## Latch
@@ -94,15 +92,15 @@ A fast, simple publish-subscribe API.
 
 ```ts
 import * as topic from 'ciorent/topic';
-import * as cio from 'ciorent';
+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 cio.sleep(100);
-    topic.pub(messages, i);
+    await co.sleep(100);
+    topic.publish(messages, i);
   }
 
   // Resolve all waiting promises
@@ -111,8 +109,8 @@ const publisher = async () => {
 }
 
 // Spawn 3 tasks that recieve messages
-cio.concurrent(3, async (id: number) => {
-  const sub = topic.sub(messages);
+co.spawn(3, async (id: number) => {
+  const sub = topic.subscribe(messages);
 
   while (true) {
     // Block until the value is sent
@@ -130,13 +128,13 @@ Channel is a synchronization primitive via message passing. A message may be sen
 
 ```ts
 import * as channel from 'ciorent/channel';
-import * as cio from 'ciorent';
+import * as co from 'ciorent';
 
 const c = channel.init<number>();
 
 const run = async () => {
   for (let i = 0; i < 5; i++) {
-    await cio.sleep(100);
+    await co.sleep(100);
     channel.send(c, i);
     console.log('Sent', i);
   }
@@ -167,7 +165,7 @@ console.log('Starting...');
 ### Pausing
 Delay the execution of a function for other asynchronous tasks to run.
 ```ts
-import * as cio from 'ciorent';
+import * as co from 'ciorent';
 
 // Expensive sync task
 const task1 = async () => {
@@ -175,7 +173,7 @@ const task1 = async () => {
 
   // Yield control back to the runtime, allowing it to
   // schedule other tasks
-  await cio.pause;
+  await co.pause;
 
   // Simulate heavy operation
   for (let i = 0; i < (Math.random() + 15) * 1e6; i++)
@@ -199,82 +197,82 @@ task2();
 ### Sleep
 Cross-runtime synchronous and asynchronous sleep functions.
 ```ts
-import * as cio from 'ciorent';
+import * as co from 'ciorent';
 
 const logTime = (label: string) => console.log(label + ':', Math.floor(performance.now()) + 'ms');
 
 logTime('Start');
 
 // Non-blocking
-await cio.sleep(500);
+await co.sleep(500);
 logTime('After about 0.5s');
 
 // This blocks the event loop
 // On the browser this only works in workers and blocks the worker thread
-cio.sleepSync(500);
+co.sleepSync(500);
 logTime('After another 0.5s');
 ```
 
 ### Spawning tasks
 Utilities to create and run tasks.
 ```ts
-import * as cio from 'ciorent';
+import * as co from 'ciorent';
 
 const task = async (id: number) => {
-  await cio.sleep((10 - id) * 20 + 50);
+  await co.sleep((10 - id) * 20 + 50);
   console.log('Task', id, 'done');
 }
 
 // Spawn and run 5 tasks sequentially
 console.log('Running 5 tasks sequentially:');
-await cio.sequential(5, task);
+await co.sequential(5, task);
 
 // Spawn and run 5 tasks concurrently
 console.log('Running 5 tasks concurrently:');
-await cio.concurrent(5, task);
+await Promise.all(co.spawn(5, task));
 ```
 
 ### Debounce
 Postpones execution until after an idle period.
 ```ts
-import * as cio from 'ciorent';
+import * as co from 'ciorent';
 
-const fn = cio.debounce((id: number) => {
+const fn = co.debounce((id: number) => {
   console.log('ID:', id);
 }, 500);
 
 fn(1); // fn(1) gets skipped
-await cio.sleep(100);
+await co.sleep(100);
 fn(2); // fn(2) gets executed
 ```
 
 ### Rate Limit
 Limits the number of calls within a time window.
 ```ts
-import * as cio from 'ciorent';
+import * as co from 'ciorent';
 
 // Allow 2 calls in 500ms, other calls are dropped
-const fn = cio.rateLimit((id: number) => {
+const fn = co.rateLimit((id: number) => {
   console.log('Call ' + id + ':', Math.floor(performance.now()) + 'ms');
 }, 500, 2);
 
 // Some calls will be dropped
 for (let i = 0; i < 8; i++) {
   fn(i);
-  await cio.sleep(400);
+  await co.sleep(400);
 }
 ```
 
 ### Throttle
 Executes a function at a regular interval.
 ```ts
-import * as cio from 'ciorent';
+import * as co from 'ciorent';
 
 // Allow 2 calls in 500ms
-const fn = cio.throttle((id: number) => {
+const fn = co.throttle((id: number) => {
   console.log(id + ': ' + Math.floor(performance.now()) + 'ms');
 }, 500, 2);
 
-cio.concurrent(8, fn);
+co.spawn(8, fn);
 ```
 

package/fiber.d.ts

@@ -2,47 +2,51 @@
  * @module Fibers
  */
 /**
- * Check whether the fiber is paused
+ * Describe a fiber process
  */
-export declare const paused: (t: Thread) => boolean;
-/**
- * Check whether the fiber is running
- */
-export declare const running: (t: Thread) => boolean;
-/**
- * Check whether the fiber is done
- */
-export declare const done: (t: Thread) => boolean;
-/**
- * Describe a fiber
- */
-export interface Thread<T = unknown, TReturn = unknown> {
+export interface Process<TReturn = unknown> {
     /**
      * The waiting promise
      */
-    0: Promise<T | TReturn>;
+    0: Promise<TReturn | undefined>;
     /**
      * Fiber status
      */
-    1: 0 | 1 | 2;
+    1: 0 | 1 | 2 | 3;
     /**
      * Callback to continue running the fiber
      */
     2: null | (() => void);
     /**
-     * Bounded threads
+     * Bounded fibers
      */
-    3: Thread[];
+    3: Process[];
 }
 /**
  * Describe a fiber runtime
  */
-export type Runtime = <const T, const TReturn, const Args extends any[]>(gen: (thread: Thread<T, TReturn>, ...args: Args) => Generator<T, TReturn>, ...args: Args) => Thread<T, TReturn>;
+export type Runtime = <const TReturn, const Args extends any[]>(gen: (proc: Process<TReturn>, ...args: Args) => Generator<any, TReturn>, ...args: Args) => Process<TReturn>;
+/**
+ * Check whether the fiber has been paused
+ */
+export declare const paused: (t: Process) => boolean;
+/**
+ * Check whether the fiber is running
+ */
+export declare const resumed: (t: Process) => boolean;
+/**
+ * Check whether the fiber has finished
+ */
+export declare const done: (t: Process) => boolean;
+/**
+ * Check whether the fiber has been interrupted
+ */
+export declare const stopped: (t: Process) => boolean;
 /**
  * Create a fiber function
  * @param f
  */
-export declare const fn: <const Fn extends (thread: Thread, ...args: any[]) => Generator>(f: Fn) => Fn;
+export declare const fn: <const Fn extends (thread: Process, ...args: any[]) => Generator>(f: Fn) => Fn;
 /**
  * A basic fiber runtime
  * @param g
@@ -52,39 +56,39 @@ export declare const spawn: Runtime;
  * Pause the execution of a fiber
  * @param t
  */
-export declare const pause: (t: Thread) => void;
+export declare const pause: (t: Process) => void;
 /**
  * Resume the execution of a fiber
  * @param t
  */
-export declare const resume: (t: Thread) => void;
+export declare const resume: (t: Process) => void;
 /**
  * Stop the execution of a fiber
  * @param t
  */
-export declare const stop: (t: Thread) => void;
+export declare const stop: (t: Process) => void;
 /**
  * Wait for a fiber and retrieve its result
  * @param t
  */
-export declare function join<T extends Thread>(t: T): Generator<Awaited<T[1]>, Awaited<T[1]>>;
+export declare function join<T extends Process>(t: T): Generator<Awaited<T[0]>, Awaited<T[0]>>;
 /**
  * Wait for a fiber to finish and retrieve its result
  * @param t
  */
-export declare const finish: <T extends Thread>(t: T) => T[1];
+export declare const finish: <T extends Process>(t: T) => T[3];
 /**
  * Mount child fiber lifetime to parent lifetime
  * @param child
  * @param parent
  */
-export declare const mount: (child: Thread, parent: Thread) => void;
+export declare const mount: (child: Process, parent: Process) => void;
 /**
  * Control the fiber with an abort signal
  * @param t
  * @param signal
  */
-export declare const control: (t: Thread, signal: AbortSignal) => void;
+export declare const control: (t: Process, signal: AbortSignal) => void;
 /**
  * Unwrap a promise result
  */

package/fiber.js

@@ -1 +1 @@
-export let paused=(t)=>t[1]===0;export let running=(t)=>t[1]===1;export let done=(t)=>t[1]===2;let invoke=async(g,thread)=>{try{let t=g.next();while(!t.done){let v=await t.value;if(thread[1]===0){let r;let p=new Promise((res)=>{r=res});thread[2]=r;await p}if(thread[1]===2)return v;t=g.next(v)}thread[1]=2;return t.value}finally{thread[3].forEach(stop)}};export let fn=(f)=>f;export let spawn=(f,...args)=>{let thread=[null,1,null,[]];thread[0]=invoke(f(thread,...args),thread);return thread};export let pause=(t)=>{if(t[1]===1)t[1]=0};export let resume=(t)=>{if(t[1]===0){t[1]=1;t[2]?.()}};export let stop=(t)=>{if(t[1]===0){t[1]=2;t[2]?.()}else t[1]=2};export function*join(t){return yield t[1]}export let finish=(t)=>t[1];export let mount=(child,parent)=>{parent[3].push(child)};export let control=(t,signal)=>{signal.addEventListener("abort",()=>{stop(t)})};export function*unwrap(t){return yield t}
+export let paused=(t)=>t[1]===0;export let resumed=(t)=>t[1]===1;export let done=(t)=>t[1]===2;export let stopped=(t)=>t[1]===3;let invoke=async(g,thread)=>{try{let t=g.next();while(!t.done){let v=await t.value;if(thread[1]===0){let r;let p=new Promise((res)=>{r=res});thread[2]=r;await p}if(thread[1]===3)return;t=g.next(v)}thread[1]=2;return t.value}finally{thread[3].forEach(stop)}};export let fn=(f)=>f;export let spawn=(f,...args)=>{let thread=[null,1,null,[]];thread[0]=invoke(f(thread,...args),thread);return thread};export let pause=(t)=>{if(t[1]===1)t[1]=0};export let resume=(t)=>{if(t[1]===0){t[1]=1;t[2]?.()}};export let stop=(t)=>{if(t[1]===0)t[2]?.();t[1]=3};export function*join(t){return yield t[0]}export let finish=(t)=>t[3];export let mount=(child,parent)=>{parent[3].push(child)};export let control=(t,signal)=>{signal.addEventListener("abort",()=>{stop(t)})};export function*unwrap(t){return yield t}

package/index.d.ts

@@ -30,11 +30,11 @@ export declare const sleepSync: (ms: number) => void;
  */
 export declare const sequential: <const T extends any[]>(n: number, task: (...args: [...T, id: number]) => Promise<any>, ...args: T) => Promise<void>;
 /**
- * Spawn n tasks that runs concurrently
+ * Spawn n concurrent tasks
  * @param n
  * @param task - The function to run
  */
-export declare const concurrent: <const T extends any[], const R>(n: number, task: (...args: [...T, id: number]) => Promise<R>, ...args: T) => Promise<R[]>;
+export declare const spawn: <const T extends any[], const R>(n: number, task: (...args: [...T, id: number]) => Promise<R>, ...args: T) => Promise<R>[];
 /**
  * Drop function calls until it doesn't get called for a specific period.
  * @param f - The target function to debounce (it must not throw errors)

package/index.js

@@ -1 +1 @@
-export let pause=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 concurrent=(n,task,...args)=>{let arr=new Array(n);for(let i=0;i<n;i++)arr[i]=task(...args,i);return Promise.all(arr)};export let debounce=(f,ms)=>{let id;return(...a)=>{clearTimeout(id);id=setTimeout(f,ms,...a)}};export let rateLimit=(f,ms,limit)=>{let cur=limit;let unlock=()=>{cur=limit};return(...a)=>{if(cur>0){if(cur===1)setTimeout(unlock,ms);cur--;f(...a)}}};export let throttle=(f,ms,limit)=>{let head=[null];let tail=head;let cur=limit;let unlock=()=>{cur=limit;while(cur>0){if(tail===head)return;cur--;tail=tail[0];tail[1](f(...tail[2]))}setTimeout(unlock,ms)};return(...a)=>{if(cur===1){setTimeout(unlock,ms)}else if(cur===0){let r;let p=new Promise((res)=>{r=res});head=head[0]=[null,r,a];return p}cur--;return f(...a)}};
+export let pause=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 rateLimit=(f,ms,limit)=>{let cur=limit;let unlock=()=>{cur=limit};return(...a)=>{if(cur>0){if(cur===1)setTimeout(unlock,ms);cur--;f(...a)}}};export let throttle=(f,ms,limit)=>{let head=[null];let tail=head;let cur=limit;let unlock=()=>{cur=limit;while(cur>0){if(tail===head)return;cur--;tail=tail[0];tail[1](f(...tail[2]))}setTimeout(unlock,ms)};return(...a)=>{if(cur===1){setTimeout(unlock,ms)}else if(cur===0){let r;let p=new Promise((res)=>{r=res});head=head[0]=[null,r,a];return p}cur--;return f(...a)}};

package/latch.d.ts

@@ -18,6 +18,6 @@ export declare const pause: (latch: Latch) => Promise<void>;
  */
 export declare const open: (latch: Latch) => void;
 /**
- * Re-close a latch
+ * Close a latch
  */
-export declare const reset: (latch: Latch) => void;
+export declare const close: (latch: Latch) => void;

package/latch.js

@@ -1 +1 @@
-import{pause as endPromise}from"./index.js";export let init=()=>{let r;return[new Promise((res)=>{r=res}),r]};export let pause=(latch)=>latch[0];export let open=(latch)=>{latch[1]();latch[0]=endPromise};export let reset=(latch)=>{if(latch[0]===endPromise){let r;latch[0]=new Promise((res)=>{r=res});latch[1]=r}};
+import{pause as endPromise}from"./index.js";export let init=()=>{let r;return[new Promise((res)=>{r=res}),r]};export let pause=(latch)=>latch[0];export let open=(latch)=>{latch[1]();latch[0]=endPromise};export let close=(latch)=>{if(latch[0]===endPromise){let r;latch[0]=new Promise((res)=>{r=res});latch[1]=r}};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ciorent",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "A lightweight, low-overhead concurrency library",
   "homepage": "https://ciorent.netlify.app",
   "repository": {
@@ -19,13 +19,13 @@
   "types": "./index.d.ts",
   "exports": {
     "./fixed-queue": "./fixed-queue.js",
-    "./sliding-queue": "./sliding-queue.js",
     "./dropping-queue": "./dropping-queue.js",
-    "./fiber": "./fiber.js",
-    "./channel": "./channel.js",
+    "./sliding-queue": "./sliding-queue.js",
     ".": "./index.js",
     "./topic": "./topic.js",
     "./semaphore": "./semaphore.js",
+    "./channel": "./channel.js",
+    "./fiber": "./fiber.js",
     "./latch": "./latch.js"
   }
 }

package/topic.d.ts

@@ -34,12 +34,12 @@ export interface Subscriber<T extends {}> {
  * Subscribe to a topic
  * @param t
  */
-export declare const sub: <T extends {}>(t: Topic<T>) => Subscriber<T>;
+export declare const subscribe: <T extends {}>(t: Topic<T>) => Subscriber<T>;
 /**
- * Subscribe to a topic
+ * Publish to a topic
  * @param t
  */
-export declare const pub: <T extends {}>(t: Topic<T>, value: T) => void;
+export declare const publish: <T extends {}>(t: Topic<T>, value: T) => void;
 /**
  * Resolve all waiting promises and clear all pending values
  * @param t

package/topic.js

@@ -1 +1 @@
-export let init=()=>[[null],[],[]];export let sub=(t)=>[t,t[0]];export let pub=(t,value)=>{let head=t[0]=t[0][0]=[null,value];for(let i=0,res=t[1],subs=t[2];i<res.length;i++){res[i](value);subs[i][1]=head}t[1]=[];t[2]=[]};export let flush=(t)=>{let head=t[0]=[null];for(let i=0,res=t[1],subs=t[2];i<res.length;i++){res[i]();subs[i][1]=head}t[1]=[];t[2]=[]};export let poll=(t)=>t[1][0]!==null?(t[1]=t[1][0])[1]:undefined;export let recieve=(t)=>{if(t[1][0]!==null)return Promise.resolve((t[1]=t[1][0])[1]);let topic=t[0];topic[2].push(t);return new Promise((res)=>{topic[1].push(res)})};
+export let init=()=>[[null],[],[]];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],subs=t[2];i<res.length;i++){res[i](value);subs[i][1]=head}t[1]=[];t[2]=[]};export let flush=(t)=>{let head=t[0]=[null];for(let i=0,res=t[1],subs=t[2];i<res.length;i++){res[i]();subs[i][1]=head}t[1]=[];t[2]=[]};export let poll=(t)=>t[1][0]!==null?(t[1]=t[1][0])[1]:undefined;export let recieve=(t)=>{if(t[1][0]!==null)return Promise.resolve((t[1]=t[1][0])[1]);let topic=t[0];topic[2].push(t);return new Promise((res)=>{topic[1].push(res)})};