ciorent 0.2.0 → 0.2.1

package/README.md

@@ -7,127 +7,141 @@ A lightweight, low-overhead concurrency library.
 - Fully type-safe.
 
 ## Examples
-### Semaphore
-Semaphore is a concurrency primitive used to control access to a common resource by multiple processes.
-
+### Utilities
+#### Spawning tasks
+Utilities to create and run tasks.
 ```ts
-import * as semaphore from 'ciorent/semaphore';
 import * as co from 'ciorent';
 
-// Only allow 2 task to run concurrently
-const sem = semaphore.init(2);
-
 const task = async (id: number) => {
-  // Acquire the semaphore or wait for the semaphore to be available
-  await semaphore.pause(sem);
+  await co.sleep((10 - id) * 20 + 50);
+  console.log('Task', id, 'done');
+}
 
-  console.log('Task', id, 'started');
+// Spawn and run 5 tasks sequentially
+console.log('Running 5 tasks sequentially:');
+await co.sequential(5, task);
 
-  // Let the main thread schedules other tasks
-  for (let i = 1; i <= 5; i++) await co.pause;
+// Spawn and run 5 tasks concurrently
+console.log('Running 5 tasks concurrently:');
+await Promise.all(co.spawn(5, task));
+```
 
-  console.log('Task', id, 'end');
+#### Sleep
+Cross-runtime synchronous and asynchronous sleep functions.
+```ts
+import * as co from 'ciorent';
 
-  // Release the semaphore
-  semaphore.signal(sem);
-}
+const logTime = (label: string) => console.log(label + ':', Math.floor(performance.now()) + 'ms');
 
-// Try to run 5 tasks concurrently
-co.spawn(5, task);
-```
+logTime('Start');
 
-### Fibers
-Virtual threads with more controlled execution.
+// Non-blocking
+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
+co.sleepSync(500);
+logTime('After another 0.5s');
+```
 
+#### Debounce
+Postpones execution until after an idle period.
 ```ts
 import * as co from 'ciorent';
-import * as fiber from 'ciorent/fiber';
-
-const f1 = fiber.fn(function* () {
-  // Wait for a promise
-  yield co.sleep(1000);
 
-  // Wait for a promise and return its result
-  const res = yield* fiber.unwrap(Promise.resolve(1));
-  console.log('Fiber 1 recieved:', res);
+const fn = co.debounce((id: number) => {
+  console.log('ID:', id);
+}, 500);
 
-  return Math.random();
-});
+fn(1); // fn(1) gets skipped
+await co.sleep(100);
+fn(2); // fn(2) gets executed
+```
 
-{
-  const main = fiber.spawn(function* (proc) {
-    // Start f1, wait for it to finish and get the result
-    const res = yield* fiber.join(fiber.spawn(f1));
-    console.log('Fiber 2 recieved:', res);
+#### Throttle
+Executes a function at a regular interval.
+```ts
+import * as co from 'ciorent';
 
-    // Start f1 and make its lifetime depends on current fiber
-    const childProc = fiber.spawn(f1);
-    fiber.mount(childProc, proc);
-  });
+// Allow 2 calls in 500ms
+const throttle = co.throttle(500, 2);
 
-  console.log('Fiber 2 started:', fiber.resumed(main));
+co.spawn(8, async (id) => {
+  await throttle();
+  console.log(id + ': ' + Math.floor(performance.now()) + 'ms');
+});
+```
 
-  // Pause the current fiber process
-  fiber.pause(main);
-  console.log('Fiber 2 is paused:', fiber.paused(main));
+#### Pausing
+Delay the execution of a function for other asynchronous tasks to run.
+```ts
+import * as co from 'ciorent';
 
-  // Resume the fiber
-  fiber.resume(main);
-  console.log('Fiber 2 is resumed:', fiber.resumed(main));
+// Expensive sync task
+const task1 = async () => {
+  let x = 0;
 
-  // Wait for the fiber process to finish
-  await fiber.done(main);
+  // Yield control back to the runtime, allowing it to
+  // schedule other tasks
+  await co.pause;
 
-  // Check finish status
-  console.log('Fiber 2 completed', fiber.completed(main));
-}
+  // Simulate heavy operation
+  for (let i = 0; i < (Math.random() + 15) * 1e6; i++)
+    x += Math.random() * 32 + i * Math.round(Math.random() * 16);
 
-{
-  console.log('------------------------');
+  console.log('Finish task 1:', x);
+};
 
-  const main = fiber.spawn(f1);
-  console.log('Fiber 1 started:', fiber.resumed(main));
+// Short async task
+const task2 = async () => {
+  console.log('Start fetching...');
+  const txt = await fetch('http://example.com');
+  console.log('Fetch status', txt.status);
+};
 
-  // Stop a fiber
-  fiber.stop(main);
-  console.log('Fiber 1 stopped:', fiber.stopped(main));
-}
+// Task 2 will not get blocked by task 1
+task1();
+task2();
 ```
 
-### Pubsub
-A fast, simple publish-subscribe API.
+### 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 topic from 'ciorent/topic';
+import * as channel from 'ciorent/channel';
 import * as co from 'ciorent';
 
-const messages = topic.init<number>();
+const c = channel.init<number>();
 
-// A task that publish messages
-const publisher = async () => {
-  for (let i = 0; i < 3; i++) {
+const run = async () => {
+  for (let i = 0; i < 5; i++) {
     await co.sleep(100);
-    topic.publish(messages, i);
+    channel.send(c, i);
+    console.log('Sent', i);
   }
 
-  // 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);
+  // Resolve all waiting promises with `undefined`
+  // This is a way to tell the reciever to not listen to more data
+  channel.flush(c);
+};
 
+const log = async () => {
   while (true) {
-    // Block until the value is sent
-    const x = await topic.recieve(sub);
+    // Wait until a value is sent to the channel
+    const x = await channel.recieve(c);
     if (x == null) break;
-    console.log(`Task ${id} recieved: ${x}`);
-  }
-});
 
-publisher();
+    console.log('Recieved', x);
+  };
+}
+
+log();
+run();
+
+// This runs first
+console.log('Starting...');
 ```
 
 ### Latch
@@ -157,140 +171,137 @@ 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.
+### Semaphore
+Semaphore is a concurrency primitive used to control access to a common resource by multiple processes.
 
 ```ts
-import * as channel from 'ciorent/channel';
+import * as semaphore from 'ciorent/semaphore';
 import * as co from 'ciorent';
 
-const c = channel.init<number>();
+// Only allow 2 task to run concurrently
+const sem = semaphore.init(2);
 
-const run = async () => {
-  for (let i = 0; i < 5; i++) {
-    await co.sleep(100);
-    channel.send(c, i);
-    console.log('Sent', i);
-  }
+const task = async (id: number) => {
+  // Acquire the semaphore or wait for the semaphore to be available
+  await semaphore.pause(sem);
 
-  // Resolve all waiting promises with `undefined`
-  // This is a way to tell the reciever to not listen to more data
-  channel.flush(c);
-};
+  console.log('Task', id, 'started');
 
-const log = async () => {
-  while (true) {
-    // Wait until a value is sent to the channel
-    const x = await channel.recieve(c);
-    if (x == null) break;
+  // Let the main thread schedules other tasks
+  for (let i = 1; i <= 5; i++) await co.pause;
 
-    console.log('Recieved', x);
-  };
-}
+  console.log('Task', id, 'end');
 
-log();
-run();
+  // Release the semaphore
+  semaphore.signal(sem);
+}
 
-// This runs first
-console.log('Starting...');
+// Try to run 5 tasks concurrently
+co.spawn(5, task);
 ```
 
-### Utilities
-#### Pausing
-Delay the execution of a function for other asynchronous tasks to run.
+### Pubsub
+A fast, simple publish-subscribe API.
+
 ```ts
+import * as topic from 'ciorent/topic';
 import * as co from 'ciorent';
 
-// Expensive sync task
-const task1 = async () => {
-  let x = 0;
+const messages = topic.init<number>();
 
-  // Yield control back to the runtime, allowing it to
-  // schedule other tasks
-  await co.pause;
+// A task that publish messages
+const publisher = async () => {
+  for (let i = 0; i < 3; i++) {
+    await co.sleep(100);
+    topic.publish(messages, i);
+  }
 
-  // Simulate heavy operation
-  for (let i = 0; i < (Math.random() + 15) * 1e6; i++)
-    x += Math.random() * 32 + i * Math.round(Math.random() * 16);
+  // Resolve all waiting promises
+  // And clear the value queue
+  topic.flush(messages);
+}
 
-  console.log('Finish task 1:', x);
-};
+// Spawn 3 tasks that recieve messages
+co.spawn(3, async (id: number) => {
+  const sub = topic.subscribe(messages);
 
-// Short async task
-const task2 = async () => {
-  console.log('Start fetching...');
-  const txt = await fetch('http://example.com');
-  console.log('Fetch status', txt.status);
-};
+  while (true) {
+    // Block until the value is sent
+    const x = await topic.recieve(sub);
+    if (x == null) break;
+    console.log(`Task ${id} recieved: ${x}`);
+  }
+});
 
-// Task 2 will not get blocked by task 1
-task1();
-task2();
+publisher();
 ```
 
-#### Sleep
-Cross-runtime synchronous and asynchronous sleep functions.
+### Fibers
+Virtual threads with more controlled execution.
+
 ```ts
 import * as co from 'ciorent';
+import * as fiber from 'ciorent/fiber';
 
-const logTime = (label: string) => console.log(label + ':', Math.floor(performance.now()) + 'ms');
+const f1 = fiber.fn(function* () {
+  // Wait for a promise
+  yield co.sleep(1000);
 
-logTime('Start');
+  // Wait for a promise and return its result
+  const res = yield* fiber.unwrap(Promise.resolve(1));
+  console.log('Fiber 1 recieved:', res);
 
-// Non-blocking
-await co.sleep(500);
-logTime('After about 0.5s');
+  return Math.random();
+});
 
-// This blocks the event loop
-// On the browser this only works in workers and blocks the worker thread
-co.sleepSync(500);
-logTime('After another 0.5s');
-```
+{
+  const main = fiber.spawn(function* (proc) {
+    // Start f1, wait for the process to complete and get the result
+    const res = yield* fiber.join(fiber.spawn(f1));
+    console.log('Fiber 2 recieved:', res);
 
-#### Spawning tasks
-Utilities to create and run tasks.
-```ts
-import * as co from 'ciorent';
+    // Start f1 and make its lifetime depends on current fiber
+    const childProc = fiber.spawn(f1);
+    fiber.mount(childProc, proc);
+  });
 
-const task = async (id: number) => {
-  await co.sleep((10 - id) * 20 + 50);
-  console.log('Task', id, 'done');
-}
+  console.log('Fiber 2 started:', fiber.resumed(main));
 
-// Spawn and run 5 tasks sequentially
-console.log('Running 5 tasks sequentially:');
-await co.sequential(5, task);
+  // Pause the current fiber process
+  fiber.pause(main);
+  console.log('Fiber 2 is paused:', fiber.paused(main));
 
-// Spawn and run 5 tasks concurrently
-console.log('Running 5 tasks concurrently:');
-await Promise.all(co.spawn(5, task));
-```
+  // Resume the fiber
+  fiber.resume(main);
+  console.log('Fiber 2 is resumed:', fiber.resumed(main));
 
-#### Debounce
-Postpones execution until after an idle period.
-```ts
-import * as co from 'ciorent';
+  // Wait for the fiber process to finish
+  await fiber.done(main);
 
-const fn = co.debounce((id: number) => {
-  console.log('ID:', id);
-}, 500);
+  // Check finish status
+  console.log('Fiber 2 completed:', fiber.completed(main));
+}
 
-fn(1); // fn(1) gets skipped
-await co.sleep(100);
-fn(2); // fn(2) gets executed
-```
+{
+  console.log('------------------------');
 
-#### Throttle
-Executes a function at a regular interval.
-```ts
-import * as co from 'ciorent';
+  const main = fiber.spawn(f1);
+  console.log('Fiber 1 started:', fiber.resumed(main));
 
-// Allow 2 calls in 500ms
-const throttle = co.throttle(500, 2);
+  // Stop a fiber
+  fiber.interrupt(main);
+  console.log('Fiber 1 interrupted:', fiber.interrupted(main));
+}
 
-co.spawn(8, async (id) => {
-  await throttle();
-  console.log(id + ': ' + Math.floor(performance.now()) + 'ms');
-});
+{
+  console.log('------------------------');
+
+  const main = fiber.spawn(f1);
+  console.log('Fiber 1 started:', fiber.resumed(main));
+
+  // Timeout a fiber
+  await fiber.timeout(main, 500);
+  console.log('Fiber 1 stopped:', fiber.interrupted(main));
+}
 ```
 

package/fiber.d.ts

@@ -41,11 +41,7 @@ export declare const completed: (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 interrupted: (t: Process) => boolean;
 export declare const fn: <const Fn extends (thread: Process, ...args: any[]) => Generator>(f: Fn) => Fn;
 /**
  * A basic fiber runtime
@@ -63,10 +59,16 @@ export declare const pause: (t: Process) => void;
  */
 export declare const resume: (t: Process) => void;
 /**
- * Stop the execution of a fiber
+ * Interrupt the execution of a fiber
+ * @param t
+ */
+export declare const interrupt: (t: Process) => void;
+/**
+ * Timeout a fiber
  * @param t
+ * @param ms
  */
-export declare const stop: (t: Process) => void;
+export declare const timeout: (t: Process, ms: number) => Promise<void>;
 /**
  * Wait for a fiber and retrieve its result
  * @param t

package/fiber.js

@@ -1 +1 @@
-export let paused=(t)=>t[1]===0;export let resumed=(t)=>t[1]===1;export let completed=(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{if(thread[1]!==2)thread[1]=3;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]!==2){if(t[1]===0)t[2]?.();t[1]=3}};export function*join(t){return yield t[0]}export let done=(t)=>t[0];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}
+import{sleep}from"./index.js";export let paused=(t)=>t[1]===0;export let resumed=(t)=>t[1]===1;export let completed=(t)=>t[1]===2;export let interrupted=(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{if(thread[1]!==2)thread[1]=3;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 interrupt=(t)=>{if(t[1]!==2){if(t[1]===0)t[2]?.();t[1]=3}};export let timeout=async(t,ms)=>{await sleep(ms);interrupt(t)};export function*join(t){return yield t[0]}export let done=(t)=>t[0];export let mount=(child,parent)=>{parent[3].push(child)};export let control=(t,signal)=>{signal.addEventListener("abort",()=>{interrupt(t)})};export function*unwrap(t){return yield t}

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 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 cur=limit;let scheduled=false;let unlock=()=>{cur=limit;while(cur>0){if(tail===head){scheduled=false;return}cur--;(tail=tail[0])[1]()}setTimeout(unlock,ms)};return()=>{if(cur===0){let r;let p=new Promise((res)=>{r=res});head=head[0]=[null,r];return p}if(!scheduled){scheduled=true;setTimeout(unlock,ms)}cur--;return pause}};
+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 throttle=(ms,limit)=>{let head=[null];let tail=head;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){let r;let p=new Promise((res)=>{r=res});head=head[0]=[null,r];return p}if(!scheduled){scheduled=true;setTimeout(unlock,ms)}cur--;return pause}};

package/package.json

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