ciorent 0.0.18 → 0.0.21

package/README.md

@@ -30,70 +30,74 @@ Virtual threads with more controlled execution.
 import * as cio from 'ciorent';
 import * as fiber from 'ciorent/fiber';
 
-function* thread1() {
+const thread1 = fiber.fn(function* () {
   console.log('Fiber 1 started');
-  yield;
+
+  // Thread1 will be interrupted by thread2
+  // As thread2 will end first
+  yield cio.sleep(1000);
+
   console.log('Fiber 1 done');
-}
+});
 
-function* thread2() {
+const thread2 = fiber.fn(function* (thread) {
   console.log('Fiber 2 started');
 
   yield;
   console.log('Fiber 2 resumed');
 
-  // Wait for a promise
-  yield* fiber.wait(cio.sleep(1000));
-  console.log('Fiber 2 waited for 1s');
-
-  // Start task 1 and wait for it to be done
-  yield* fiber.join(
-    fiber.start(thread1())
-  );
+  // Start thread 1 and make thread1
+  // lifetime depends on thread2
+  fiber.mount(fiber.start(thread1), thread);
 
   console.log('Fiber 2 done');
-}
+});
 
 // Start running the thread
-fiber.start(thread2());
+fiber.start(thread2);
 ```
 
-## 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.
+## Latch
+Latch is a synchronization primitive that allows one process to wait until another completes an operation before continuing execution.
 
 ```ts
-import * as channel from 'ciorent/channel';
+import * as latch from 'ciorent/latch';
 import * as cio from 'ciorent';
 
-const c = channel.init<number>();
+const fetchLatch = latch.init();
 
-const run = async () => {
-  for (let i = 0; i < 10; i++) {
-    await cio.sleep(10);
-    channel.send(c, i);
-    console.log('Sent', i);
-  }
+const task = async () => {
+  // Blocks until the latch is open
+  await latch.pause(fetchLatch);
 
-  // Resolve all waiting promises with `undefined`
-  // This is a way to tell the reciever to not listen to more data
-  channel.flush(c);
-};
+  const res = await fetch('http://example.com');
+  console.log('Fetch status:', res.status);
+}
 
-const log = async () => {
-  while (true) {
-    // Wait until a value is sent
-    const x = await channel.recieve(c);
-    if (x == null) break;
+const prepare = () => {
+  console.log('Run before fetch:', performance.now().toFixed(2));
+}
 
-    console.log('Recieved', x);
-  };
+const main = async () => {
+  const p = task();
+  await cio.sleep(500);
+  prepare();
+
+  // Allows all previously blocked tasks to run
+  latch.open(fetchLatch);
+
+  // Reclose the latch
+  // Tasks that aren't blocked yet will be blocked
+  latch.reset(fetchLatch);
+
+  return p;
 }
 
-run();
-log();
+// Run fetch after 500ms
+await main();
 
-// This runs first
-console.log('Starting...');
+// Run fetch after another 500ms
+await main();
 ```
 
 ## Pubsub
@@ -132,47 +136,42 @@ cio.concurrent(5, async (id: number) => {
 publisher();
 ```
 
-## Latch
-Latch is a synchronization primitive that allows one process to wait until another completes an operation before continuing execution.
+## 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 latch from 'ciorent/latch';
+import * as channel from 'ciorent/channel';
 import * as cio from 'ciorent';
 
-const fetchLatch = latch.init();
-
-const task = async () => {
-  // Blocks until the latch is open
-  await latch.pause(fetchLatch);
-
-  const res = await fetch('http://example.com');
-  console.log('Fetch status:', res.status);
-}
-
-const prepare = () => {
-  console.log('Run before fetch:', performance.now().toFixed(2));
-}
+const c = channel.init<number>();
 
-const main = async () => {
-  const p = task();
-  await cio.sleep(500);
-  prepare();
+const run = async () => {
+  for (let i = 0; i < 10; i++) {
+    await cio.sleep(10);
+    channel.send(c, i);
+    console.log('Sent', i);
+  }
 
-  // Allows all previously blocked tasks to run
-  latch.open(fetchLatch);
+  // Resolve all waiting promises with `undefined`
+  // This is a way to tell the reciever to not listen to more data
+  channel.flush(c);
+};
 
-  // Reclose the latch
-  // Tasks that aren't blocked yet will be blocked
-  latch.reset(fetchLatch);
+const log = async () => {
+  while (true) {
+    // Wait until a value is sent
+    const x = await channel.recieve(c);
+    if (x == null) break;
 
-  return p;
+    console.log('Recieved', x);
+  };
 }
 
-// Run fetch after 500ms
-await main();
+run();
+log();
 
-// Run fetch after another 500ms
-await main();
+// This runs first
+console.log('Starting...');
 ```
 
 ## Utilities
@@ -207,13 +206,15 @@ task2();
 ```
 
 ### Sleep
-A cross-runtime sleep function.
+Cross-runtime synchronous and asynchronous sleep functions.
 ```ts
 import { sleep, sleepSync } from 'ciorent';
 
 await sleep(500);
 console.log('Hi');
 
+// This blocks the current thread
+// On the browser this only works in workers
 sleepSync(500);
 console.log('Hi');
 ```

package/fiber.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @module Fibers
+ */
+/**
+ * Check whether the fiber is paused
+ */
+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> {
+    /**
+     * The waiting promise
+     */
+    0: Promise<T | TReturn>;
+    /**
+     * Fiber status
+     */
+    1: 0 | 1 | 2;
+    /**
+     * Callback to continue running the fiber
+     */
+    2: null | (() => void);
+    /**
+     * Bounded threads
+     */
+    3: Thread[];
+}
+/**
+ * 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>;
+/**
+ * Create a fiber function
+ * @param f
+ */
+export declare const fn: <const Fn extends (thread: Thread, ...args: any[]) => Generator>(f: Fn) => Fn;
+/**
+ * A basic fiber runtime
+ * @param g
+ */
+export declare const start: Runtime;
+/**
+ * Pause the execution of a fiber
+ * @param t
+ */
+export declare const pause: (t: Thread) => void;
+/**
+ * Resume the execution of a fiber
+ * @param t
+ */
+export declare const resume: (t: Thread) => void;
+/**
+ * Stop the execution of a fiber
+ * @param t
+ */
+export declare const stop: (t: Thread) => 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]>>;
+/**
+ * Wait for a fiber to finish and retrieve its result
+ * @param t
+ */
+export declare const finish: <T extends Thread>(t: T) => T[1];
+/**
+ * Mount child fiber lifetime to parent lifetime
+ * @param child
+ * @param parent
+ */
+export declare const mount: (child: Thread, parent: Thread) => void;
+/**
+ * Control the fiber with an abort signal
+ * @param t
+ * @param signal
+ */
+export declare const control: (t: Thread, signal: AbortSignal) => void;
+/**
+ * Unwrap a promise result
+ */
+export declare function unwrap<T extends Promise<any>>(t: T): Generator<Awaited<T>, Awaited<T>>;

package/fiber.js

@@ -0,0 +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)=>{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){thread[3].forEach(stop);return v}t=g.next(v)}thread[1]=2;thread[3].forEach(stop);return t.value};export let fn=(f)=>f;export let start=(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}

package/package.json

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

package/concurrent.d.ts

@@ -1,11 +0,0 @@
-/**
- * @module Concurrency controls
- */
-/**
- * Describe an async task
- */
-export type Task<T = unknown> = () => Promise<T>;
-/**
- * Describe a concurrency controller
- */
-export type Controller = <T>(task: Task<T>) => Promise<T>;

package/fiber/index.d.ts

@@ -1,74 +0,0 @@
-/**
- * @module Fiber
- */
-/**
- * When the fiber is paused
- */
-export declare const paused: (t: Thread) => boolean;
-/**
- * When the fiber is running
- */
-export declare const running: (t: Thread) => boolean;
-/**
- * When the fiber is done
- */
-export declare const done: (t: Thread) => boolean;
-/**
- * Describe a fiber
- */
-export interface Thread<T = unknown, TReturn = unknown> {
-    /**
-     * The original generator
-     */
-    0: Generator<T, TReturn>;
-    /**
-     * The waiting promise
-     */
-    1: Promise<T | TReturn>;
-    /**
-     * Fiber status
-     */
-    2: 0 | 1 | 2;
-    /**
-     * Callback to continue running the fiber
-     */
-    3: null | (() => void);
-}
-/**
- * Describe a fiber runtime
- */
-export type Runtime = <const T, const TReturn>(gen: Generator<T, TReturn>) => Thread<T, TReturn>;
-/**
- * A basic fiber runtime
- * @param g
- */
-export declare const start: Runtime;
-/**
- * Pause the execution of a fiber
- * @param t
- */
-export declare const pause: (t: Thread) => void;
-/**
- * Resume the execution of a fiber
- * @param t
- */
-export declare const resume: (t: Thread) => void;
-/**
- * Stop the execution of a fiber and retrieve the result
- * @param t
- */
-export declare const stop: <T extends Thread>(t: T) => T[1];
-/**
- * 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]>>;
-/**
- * Wait for a fiber to finish and retrieve its result
- * @param t
- */
-export declare const finish: <T extends Thread>(t: T) => T[1];
-/**
- * Wait for a promise to resolve then retrieve its result
- */
-export declare function wait<T extends Promise<any>>(t: T): Generator<Awaited<T>, Awaited<T>>;

package/fiber/index.js

@@ -1 +0,0 @@
-export let paused=(t)=>t[2]===0;export let running=(t)=>t[2]===1;export let done=(t)=>t[2]===2;let invoke=async(g,thread)=>{let t=g.next();while(!t.done){let v=await t.value;if(thread[2]===0){let r;let p=new Promise((res)=>{r=res});thread[3]=r;await p}if(thread[2]===2)return v;t=g.next(v)}thread[2]=2;return t.value};export let start=(g)=>{let thread=[g,null,1,null];thread[1]=invoke(g,thread);return thread};export let pause=(t)=>{if(t[2]===1)t[2]=0};export let resume=(t)=>{if(t[2]===0){t[2]=1;t[3]?.()}};export let stop=(t)=>{if(t[2]===0){t[2]=2;t[3]()}else t[2]=2;return t[1]};export function*join(t){return yield t[1]}export let finish=(t)=>t[1];export function*wait(t){return yield t}