@fncts/io 0.0.19 → 0.0.21

package/_src/Queue/internal.ts

@@ -1,168 +1,8 @@
 import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
-import type { Queue } from "@fncts/io/Queue/definition";
 import type { Strategy } from "@fncts/io/Queue/strategy";
 
-import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
-import { unbounded } from "@fncts/io/internal/MutableQueue";
-import { QueueInternal } from "@fncts/io/Queue/definition";
-
-class UnsafeQueue<A> extends QueueInternal<never, never, never, never, A, A> {
-  constructor(
-    readonly queue: MutableQueue<A>,
-    readonly takers: MutableQueue<Future<never, A>>,
-    readonly shutdownHook: Future<never, void>,
-    readonly shutdownFlag: AtomicBoolean,
-    readonly strategy: Strategy<A>,
-  ) {
-    super();
-  }
-
-  awaitShutdown: UIO<void> = this.shutdownHook.await;
-
-  capacity: number = this.queue.capacity;
-
-  isShutdown: UIO<boolean> = IO.succeed(this.shutdownFlag.get);
-
-  offer(a: A, __tsplusTrace?: string): IO<never, never, boolean> {
-    return IO.defer(() => {
-      if (this.shutdownFlag.get) {
-        return IO.interrupt;
-      } else {
-        const taker = this.takers.dequeue(undefined);
-
-        if (taker != null) {
-          _unsafeCompletePromise(taker, a);
-          return IO.succeedNow(true);
-        } else {
-          const succeeded = this.queue.enqueue(a);
-
-          if (succeeded) {
-            return IO.succeedNow(true);
-          } else {
-            return this.strategy.handleSurplus(Conc.single(a), this.queue, this.takers, this.shutdownFlag);
-          }
-        }
-      }
-    });
-  }
-
-  offerAll(as: Iterable<A>, __tsplusTrace?: string): IO<never, never, boolean> {
-    const arr = Conc.from(as);
-    return IO.defer(() => {
-      if (this.shutdownFlag.get) {
-        return IO.interrupt;
-      } else {
-        const pTakers                = this.queue.isEmpty ? _unsafePollN(this.takers, arr.length) : Conc.empty<Future<never, A>>();
-        const [forTakers, remaining] = arr.splitAt(pTakers.length);
-        pTakers.zip(forTakers).forEach(([taker, item]) => {
-          _unsafeCompletePromise(taker, item);
-        });
-
-        if (remaining.length === 0) {
-          return IO.succeedNow(true);
-        }
-
-        const surplus = _unsafeOfferAll(this.queue, remaining);
-
-        _unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-
-        if (surplus.length === 0) {
-          return IO.succeedNow(true);
-        } else {
-          return this.strategy.handleSurplus(surplus, this.queue, this.takers, this.shutdownFlag);
-        }
-      }
-    });
-  }
-
-  shutdown: UIO<void> = IO.deferWith((_, id) => {
-    this.shutdownFlag.set(true);
-
-    return IO.foreachC(_unsafePollAll(this.takers), (fiber) => fiber.interruptAs(id))
-      .flatMap(() => this.strategy.shutdown)
-      .whenIO(this.shutdownHook.succeed(undefined));
-  });
-
-  size: UIO<number> = IO.defer(() => {
-    if (this.shutdownFlag.get) {
-      return IO.interrupt;
-    } else {
-      return IO.succeedNow(this.queue.size - this.takers.size + this.strategy.surplusSize);
-    }
-  });
-
-  take: IO<never, never, A> = IO.deferWith((_, fiberId) =>
-    IO.defer(() => {
-      if (this.shutdownFlag.get) {
-        return IO.interrupt;
-      }
-
-      const item = this.queue.dequeue(undefined);
-
-      if (item != null) {
-        this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-        return IO.succeedNow(item);
-      } else {
-        const p = Future.unsafeMake<never, A>(fiberId);
-
-        return IO.defer(() => {
-          this.takers.enqueue(p);
-          _unsafeCompleteTakers(this.strategy, this.queue, this.takers);
-          if (this.shutdownFlag.get) {
-            return IO.interrupt;
-          } else {
-            return p.await;
-          }
-        }).onInterrupt(() => IO.succeed(_unsafeRemove(this.takers, p)));
-      }
-    }),
-  );
-
-  takeAll: IO<never, never, Conc<A>> = IO.defer(() => {
-    if (this.shutdownFlag.get) {
-      return IO.interrupt;
-    } else {
-      return IO.succeed(() => {
-        const as = _unsafePollAll(this.queue);
-        this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-        return as;
-      });
-    }
-  });
-
-  takeUpTo(max: number, __tsplusTrace?: string): IO<never, never, Conc<A>> {
-    return IO.defer(() => {
-      if (this.shutdownFlag.get) {
-        return IO.interrupt;
-      } else {
-        return IO.succeed(() => {
-          const as = _unsafePollN(this.queue, max);
-          this.strategy.unsafeOnQueueEmptySpace(this.queue, this.takers);
-          return as;
-        });
-      }
-    });
-  }
-}
-
-function _unsafeQueue<A>(
-  queue: MutableQueue<A>,
-  takers: MutableQueue<Future<never, A>>,
-  shutdownHook: Future<never, void>,
-  shutdownFlag: AtomicBoolean,
-  strategy: Strategy<A>,
-): Queue<A> {
-  return new UnsafeQueue(queue, takers, shutdownHook, shutdownFlag, strategy);
-}
-
-export function _makeQueue<A>(strategy: Strategy<A>): (queue: MutableQueue<A>) => IO<never, never, Queue<A>> {
-  return (queue) =>
-    Future.make<never, void>().map((p) => _unsafeQueue(queue, unbounded(), p, new AtomicBoolean(false), strategy));
-}
-
-export function _unsafeOfferAll<A>(q: MutableQueue<A>, as: Conc<A>): Conc<A> {
+export function unsafeOfferAll<A>(q: MutableQueue<A>, as: Conc<A>): Conc<A> {
   let bs = as;
-
   while (bs.length > 0) {
     if (!q.enqueue(bs.unsafeGet(0))) {
       return bs;
@@ -170,68 +10,57 @@ export function _unsafeOfferAll<A>(q: MutableQueue<A>, as: Conc<A>): Conc<A> {
       bs = bs.drop(1);
     }
   }
-
   return bs;
 }
 
-export function _unsafePollAll<A>(q: MutableQueue<A>): Conc<A> {
+export function unsafePollAll<A>(q: MutableQueue<A>): Conc<A> {
   let as = Conc.empty<A>();
-
   while (!q.isEmpty) {
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     as = as.append(q.dequeue(undefined)!);
   }
-
   return as;
 }
 
-export function _unsafeCompletePromise<A>(p: Future<never, A>, a: A) {
+export function unsafeCompletePromise<A>(p: Future<never, A>, a: A) {
   return p.unsafeDone(IO.succeedNow(a));
 }
 
-export function _unsafeRemove<A>(q: MutableQueue<A>, a: A) {
-  return _unsafeOfferAll(q, _unsafePollAll(q)).filter((b) => a !== b);
+export function unsafeRemove<A>(q: MutableQueue<A>, a: A) {
+  return unsafeOfferAll(q, unsafePollAll(q)).filter((b) => a !== b);
 }
 
-function _unsafePollN<A>(q: MutableQueue<A>, max: number): Conc<A> {
+export function unsafePollN<A>(q: MutableQueue<A>, max: number): Conc<A> {
   let j  = 0;
   let as = Conc.empty<A>();
-
   while (j < max) {
     const p = q.dequeue(undefined);
-
     if (p != null) {
       as = as.append(p);
     } else {
       return as;
     }
-
     j += 1;
   }
-
   return as;
 }
 
-export function _unsafeCompleteTakers<A>(
+export function unsafeCompleteTakers<A>(
   strategy: Strategy<A>,
   queue: MutableQueue<A>,
   takers: MutableQueue<Future<never, A>>,
 ): void {
   let keepPolling = true;
-
   while (keepPolling && !queue.isEmpty) {
     const taker = takers.dequeue(undefined);
-
     if (taker != null) {
       const element = queue.dequeue(undefined);
-
       if (element != null) {
-        _unsafeCompletePromise(taker, element);
+        unsafeCompletePromise(taker, element);
         strategy.unsafeOnQueueEmptySpace(queue, takers);
       } else {
-        _unsafeOfferAll(takers, _unsafePollAll(takers).prepend(taker));
+        unsafeOfferAll(takers, unsafePollAll(takers).prepend(taker));
       }
-
       keepPolling = true;
     } else {
       keepPolling = false;

package/_src/Queue/strategy.ts

@@ -2,12 +2,7 @@ import type { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
 import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
 
 import { unbounded } from "@fncts/io/internal/MutableQueue";
-import {
-  _unsafeCompletePromise,
-  _unsafeCompleteTakers,
-  _unsafeOfferAll,
-  _unsafePollAll,
-} from "@fncts/io/Queue/internal";
+import { unsafeCompletePromise, unsafeCompleteTakers, unsafeOfferAll, unsafePollAll } from "@fncts/io/Queue/internal";
 
 export interface Strategy<A> {
   readonly handleSurplus: (
@@ -31,7 +26,6 @@ export interface Strategy<A> {
 
 export class BackPressureStrategy<A> implements Strategy<A> {
   private putters = unbounded<[A, Future<never, boolean>, boolean]>();
-
   handleSurplus(
     as: Conc<A>,
     queue: MutableQueue<A>,
@@ -42,11 +36,10 @@ export class BackPressureStrategy<A> implements Strategy<A> {
     return IO.descriptorWith((d) =>
       IO.defer(() => {
         const p = Future.unsafeMake<never, boolean>(d.id);
-
         return IO.defer(() => {
           this.unsafeOffer(as, p);
           this.unsafeOnQueueEmptySpace(queue, takers);
-          _unsafeCompleteTakers(this, queue, takers);
+          unsafeCompleteTakers(this, queue, takers);
           if (isShutdown.get) {
             return IO.interrupt;
           } else {
@@ -58,20 +51,18 @@ export class BackPressureStrategy<A> implements Strategy<A> {
   }
 
   unsafeRemove(p: Future<never, boolean>, __tsplusTrace?: string) {
-    _unsafeOfferAll(
+    unsafeOfferAll(
       this.putters,
-      _unsafePollAll(this.putters).filter(([_, __]) => __ !== p),
+      unsafePollAll(this.putters).filter(([_, __]) => __ !== p),
     );
   }
 
   unsafeOffer(as: Conc<A>, p: Future<never, boolean>, __tsplusTrace?: string) {
     let bs = as;
-
     while (bs.length > 0) {
       // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       const head = bs.unsafeGet(0);
       bs         = bs.drop(1);
-
       if (bs.length === 0) {
         this.putters.enqueue([head, p, true]);
       } else {
@@ -82,19 +73,16 @@ export class BackPressureStrategy<A> implements Strategy<A> {
 
   unsafeOnQueueEmptySpace(queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, __tsplusTrace?: string) {
     let keepPolling = true;
-
     while (keepPolling && !queue.isFull) {
       const putter = this.putters.dequeue(undefined);
-
       if (putter != null) {
         const offered = queue.enqueue(putter[0]);
-
         if (offered && putter[2]) {
-          _unsafeCompletePromise(putter[1], true);
+          unsafeCompletePromise(putter[1], true);
         } else if (!offered) {
-          _unsafeOfferAll(this.putters, _unsafePollAll(this.putters).prepend(putter));
+          unsafeOfferAll(this.putters, unsafePollAll(this.putters).prepend(putter));
         }
-        _unsafeCompleteTakers(this, queue, takers);
+        unsafeCompleteTakers(this, queue, takers);
       } else {
         keepPolling = false;
       }
@@ -106,7 +94,7 @@ export class BackPressureStrategy<A> implements Strategy<A> {
     const self = this;
     return Do((_) => {
       const fiberId = _(IO.fiberId);
-      const putters = _(IO.succeed(_unsafePollAll(self.putters)));
+      const putters = _(IO.succeed(unsafePollAll(self.putters)));
       _(IO.foreachC(putters, ([, p, lastItem]) => (lastItem ? p.interruptAs(fiberId).asUnit : IO.unit)));
     });
   }
@@ -150,7 +138,7 @@ export class SlidingStrategy<A> implements Strategy<A> {
   ): UIO<boolean> {
     return IO.succeed(() => {
       this.unsafeSlidingOffer(queue, as);
-      _unsafeCompleteTakers(this, queue, takers);
+      unsafeCompleteTakers(this, queue, takers);
       return true;
     });
   }
@@ -169,14 +157,12 @@ export class SlidingStrategy<A> implements Strategy<A> {
 
   private unsafeSlidingOffer(queue: MutableQueue<A>, as: Conc<A>) {
     let bs = as;
-
     while (bs.length > 0) {
       if (queue.capacity === 0) {
         return;
       }
       // poll 1 and retry
       queue.dequeue(undefined);
-
       if (queue.enqueue(bs.unsafeGet(0))) {
         bs = bs.drop(1);
       }

package/_src/Queue.ts

@@ -1,7 +1,5 @@
-// codegen:start { preset: barrel, include: Queue/*.ts }
-export * from "./Queue/api.js";
+// codegen:start { preset: barrel, include: Queue/*.ts, exclude: Queue/internal.ts }
 export * from "./Queue/constructors.js";
 export * from "./Queue/definition.js";
-export * from "./Queue/internal.js";
 export * from "./Queue/strategy.js";
 // codegen:end

package/_src/Ref/Atomic.ts

@@ -1,4 +1,37 @@
-// codegen:start { preset: barrel, include: Atomic/*.ts }
-export * from "./Atomic/api.js";
-export * from "./Atomic/Atomic.js";
-// codegen:end
+import { Ref } from "./definition.js";
+
+/**
+ * @tsplus type fncts.io.Ref.Atomic
+ */
+export class Atomic<A> extends Ref<A> {
+  readonly _tag = "Atomic";
+
+  constructor(private value: A) {
+    super();
+  }
+
+  get unsafeGet(): A {
+    return this.value;
+  }
+
+  unsafeSet(a: A): void {
+    this.value = a;
+  }
+
+  get: UIO<A> = IO.succeed(this.value);
+
+  set(a: A): UIO<void> {
+    return IO.succeed(() => {
+      this.value = a;
+    });
+  }
+
+  modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string) {
+    return IO.succeed(() => {
+      const v = this.unsafeGet;
+      const o = f(v);
+      this.unsafeSet(o[1]);
+      return o[0];
+    });
+  }
+}

package/_src/Ref/Synchronized.ts

@@ -0,0 +1,107 @@
+import { IO } from "@fncts/io/IO";
+
+import { Ref } from "./definition.js";
+
+/**
+ * @tsplus type fncts.io.Ref.Synchronized
+ * @tsplus companion fncts.io.Ref.SynchronizedOps
+ * @tsplus static fncts.io.RefOps Synchronized
+ */
+export class Synchronized<A> extends Ref<A> {
+  constructor(readonly semaphore: TSemaphore, readonly unsafeGet: UIO<A>, readonly unsafeSet: (a: A) => UIO<void>) {
+    super();
+  }
+
+  /**
+   * Reads the value from the `Ref`.
+   */
+  get get(): UIO<A> {
+    return this.withPermit(this.unsafeGet);
+  }
+  /**
+   * Writes a new value to the `Ref`, with a guarantee of immediate
+   * consistency (at some cost to performance).
+   */
+  set(a: A, __tsplusTrace?: string): UIO<void> {
+    return this.withPermit(this.unsafeSet(a));
+  }
+  /**
+   * Atomically modifies the `Ref.Synchronized` with the specified function,
+   * which computes a return value for the modification. This is a more
+   * powerful version of `update`.
+   */
+  modifyIO<R, E, B>(f: (a: A) => IO<R, E, readonly [B, A]>, __tsplusTrace?: string): IO<R, E, B> {
+    return this.withPermit(this.unsafeGet.flatMap(f).flatMap(([b, a]) => this.unsafeSet(a).as(b)));
+  }
+  modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string | undefined): UIO<B> {
+    return this.modifyIO((a) => IO.succeedNow(f(a)));
+  }
+  /**
+   * Atomically modifies the `Ref.Synchronized` with the specified function,
+   * returning the value immediately before modification.
+   */
+  getAndUpdateIO<R, E>(f: (a: A) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+    return this.modifyIO((v) => f(v).map((result) => [v, result]));
+  }
+  /**
+   * Atomically modifies the `Ref.Synchronized` with the specified partial
+   * function, returning the value immediately before modification. If the
+   * function is undefined on the current value it doesn't change it.
+   */
+  getAndUpdateJustIO<R, E>(f: (a: A) => Maybe<IO<R, E, A>>): IO<R, E, A> {
+    return this.modifyIO((v) =>
+      f(v)
+        .getOrElse(IO.succeedNow(v))
+        .map((result) => [v, result]),
+    );
+  }
+  /**
+   * Atomically modifies the `Ref.Synchronized` with the specified function,
+   * which computes a return value for the modification if the function is
+   * defined in the current value otherwise it returns a default value. This
+   * is a more powerful version of `updateSome`.
+   */
+  modifyJustIO<R, E, B>(orElse: B, f: (a: A) => Maybe<IO<R, E, readonly [B, A]>>, __tsplusTrace?: string): IO<R, E, B> {
+    return this.modifyIO((v) => f(v).getOrElse(IO.succeedNow([orElse, v] as const)));
+  }
+  /**
+   * Atomically modifies the `Ref.Synchronized` with the specified function.
+   */
+  updateIO<R, E>(f: (a: A) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, void> {
+    return this.modifyIO((v) => f(v).map((result) => [undefined, result] as const));
+  }
+  /**
+   * Atomically modifies the `Ref.Synchronized` with the specified function,
+   * returning the value immediately after modification.
+   */
+  updateAndGetIO<R, E>(f: (a: A) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+    return this.modifyIO((v) => f(v).map((result) => [result, result]));
+  }
+  /**
+   * Atomically modifies the `Ref.Synchronized` with the specified partial
+   * function. If the function is undefined on the current value it doesn't
+   * change it.
+   */
+  updateJustIO<R, E>(f: (a: A) => Maybe<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, void> {
+    return this.modifyIO((v) =>
+      f(v)
+        .getOrElse(IO.succeedNow(v))
+        .map((result) => [undefined, result]),
+    );
+  }
+  /**
+   * Atomically modifies the `Ref.Synchronized` with the specified partial
+   * function. If the function is undefined on the current value it returns
+   * the old value without changing it.
+   */
+  updateJustAndGetIO<R, E>(f: (a: A) => Maybe<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A> {
+    return this.modifyIO((v) =>
+      f(v)
+        .getOrElse(IO.succeedNow(v))
+        .map((result) => [result, result]),
+    );
+  }
+  protected withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+    return this.semaphore.withPermit(io);
+  }
+}

package/_src/Ref/constructors.ts

@@ -1,12 +1,27 @@
+import { Synchronized } from "@fncts/io/Ref/Synchronized";
+
 import { Atomic } from "./Atomic.js";
 
 /**
  * @tsplus static fncts.io.RefOps make
+ * @tsplus static fncts.io.RefOps __call
  */
 export function make<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Ref<A>> {
   return IO.succeed(unsafeMake(a()));
 }
 
+/**
+ * @tsplus static fncts.io.Ref.SynchronizedOps make
+ * @tsplus static fncts.io.Ref.SynchronizedOps __call
+ */
+export function makeSynchronized<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Ref.Synchronized<A>> {
+  return Do((_) => {
+    const ref       = _(Ref.make(a));
+    const semaphore = _(TSemaphore.make(1).commit);
+    return new Synchronized(semaphore, ref.get, (a: A) => ref.set(a));
+  });
+}
+
 /**
  * @tsplus static fncts.io.RefOps unsafeMake
  */