@fncts/io 0.0.19 → 0.0.21

package/_src/LogLevel.ts

@@ -7,35 +7,43 @@ export class LogLevel {
 }
 
 /**
- * @tsplus fluent fncts.LogLevel lt
- * @tsplus operator fncts.LogLevel <
+ * @tsplus pipeable fncts.LogLevel lt
+ * @tsplus pipeable-operator fncts.LogLevel <
  */
-export function lt(self: LogLevel, that: LogLevel): boolean {
-  return self.ordinal < that.ordinal;
+export function lt(that: LogLevel) {
+  return (self: LogLevel): boolean => {
+    return self.ordinal < that.ordinal;
+  };
 }
 
 /**
- * @tsplus fluent fncts.LogLevel lte
- * @tsplus operator fncts.LogLevel <=
+ * @tsplus pipeable fncts.LogLevel lte
+ * @tsplus pipeable-operator fncts.LogLevel <=
  */
-export function lte(self: LogLevel, that: LogLevel): boolean {
-  return self.ordinal <= that.ordinal;
+export function lte(that: LogLevel) {
+  return (self: LogLevel): boolean => {
+    return self.ordinal <= that.ordinal;
+  };
 }
 
 /**
- * @tsplus fluent fncts.LogLevel gte
- * @tsplus operator fncts.LogLevel >=
+ * @tsplus pipeable fncts.LogLevel gte
+ * @tsplus pipeable-operator fncts.LogLevel >=
  */
-export function gte(self: LogLevel, that: LogLevel): boolean {
-  return self.ordinal >= that.ordinal;
+export function gte(that: LogLevel) {
+  return (self: LogLevel): boolean => {
+    return self.ordinal >= that.ordinal;
+  };
 }
 
 /**
- * @tsplus fluent fncts.LogLevel gt
- * @tsplus operator fncts.LogLevel >
+ * @tsplus pipeable fncts.LogLevel gt
+ * @tsplus pipeable-operator fncts.LogLevel >
  */
-export function gt(self: LogLevel, that: LogLevel): boolean {
-  return self.ordinal > that.ordinal;
+export function gt(that: LogLevel) {
+  return (self: LogLevel): boolean => {
+    return self.ordinal > that.ordinal;
+  };
 }
 
 /**

package/_src/LogSpan.ts

@@ -7,21 +7,21 @@ export class LogSpan {
 }
 
 /**
- * @tsplus fluent fncts.LogSpan render
+ * @tsplus pipeable fncts.LogSpan render
  */
-export function render(self: LogSpan, now: number): string {
-  let s = "";
-  if (self.label.indexOf(" ") < 0) {
-    s += self.label;
-  } else {
-    s += '"';
-    s += self.label;
-    s += '"';
-  }
-
-  s += "=";
-  s += (now - self.startTime).toString();
-  s += "ms";
-
-  return s;
+export function render(now: number) {
+  return (self: LogSpan): string => {
+    let s = "";
+    if (self.label.indexOf(" ") < 0) {
+      s += self.label;
+    } else {
+      s += '"';
+      s += self.label;
+      s += '"';
+    }
+    s += "=";
+    s += (now - self.startTime).toString();
+    s += "ms";
+    return s;
+  };
 }

package/_src/Logger/api.ts

@@ -1,24 +1,25 @@
 /**
- * @tsplus fluent fncts.io.Logger filterLogLevel
+ * @tsplus pipeable fncts.io.Logger filterLogLevel
  */
-export function filterLogLevel_<Message, Output>(
-  self: Logger<Message, Output>,
-  p: Predicate<LogLevel>,
-): Logger<Message, Maybe<Output>> {
-  return new Logger((trace, fiberId, logLevel, message, cause, context, spans, annotations) => {
-    if (p(logLevel)) {
-      return Just(self.log(trace, fiberId, logLevel, message, cause, context, spans, annotations));
-    } else {
-      return Nothing();
-    }
-  });
+export function filterLogLevel(p: Predicate<LogLevel>) {
+  return <Message, Output>(self: Logger<Message, Output>): Logger<Message, Maybe<Output>> => {
+    return new Logger((trace, fiberId, logLevel, message, cause, context, spans, annotations) => {
+      if (p(logLevel)) {
+        return Just(self.log(trace, fiberId, logLevel, message, cause, context, spans, annotations));
+      } else {
+        return Nothing();
+      }
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.Logger map
+ * @tsplus pipeable fncts.io.Logger map
  */
-export function map_<Message, Output, B>(self: Logger<Message, Output>, f: (_: Output) => B): Logger<Message, B> {
-  return new Logger((trace, fiberId, logLevel, message, cause, context, spans, annotations) =>
-    f(self.log(trace, fiberId, logLevel, message, cause, context, spans, annotations)),
-  );
+export function map<Output, B>(f: (_: Output) => B) {
+  return <Message>(self: Logger<Message, Output>): Logger<Message, B> => {
+    return new Logger((trace, fiberId, logLevel, message, cause, context, spans, annotations) =>
+      f(self.log(trace, fiberId, logLevel, message, cause, context, spans, annotations)),
+    );
+  };
 }

package/_src/Logger/constructors.ts

@@ -6,17 +6,15 @@ export const defaultString: Logger<string, string> = new Logger(
     let s           = "";
     const nowMillis = Date.now();
     const now       = new Date(nowMillis);
-
-    s += "timestamp=";
-    s += now.toISOString();
-    s += " level=";
-    s += logLevel.label;
-    s += " thread=#";
-    s += fiberId.threadName;
-    s += ' message="';
-    s += message();
-    s += '"';
-
+    s              += "timestamp=";
+    s              += now.toISOString();
+    s              += " level=";
+    s              += logLevel.label;
+    s              += " thread=#";
+    s              += fiberId.threadName;
+    s              += ' message="';
+    s              += message();
+    s              += '"';
     if (spans.isNonEmpty()) {
       let first = true;
       for (const span of spans) {
@@ -25,18 +23,14 @@ export const defaultString: Logger<string, string> = new Logger(
         } else {
           s += " ";
         }
-
         s += span.render(nowMillis);
       }
     }
-
     if (trace._tag === "SourceLocation") {
       s += " location=";
       s += quoted(trace.show);
     }
-
     // TODO: render Cause, and Annotations
-
     return s;
   },
 );

package/_src/Queue/constructors.ts

@@ -1,33 +1,49 @@
-import type { Queue } from "@fncts/io/Queue/definition";
+import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
+import type { Strategy } from "@fncts/io/Queue/strategy";
 
+import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
 import { bounded, unbounded } from "@fncts/io/internal/MutableQueue";
-import { _makeQueue } from "@fncts/io/Queue/internal";
+import { Queue } from "@fncts/io/Queue/definition";
 import { BackPressureStrategy, DroppingStrategy, SlidingStrategy } from "@fncts/io/Queue/strategy";
 
 /**
  * @tsplus static fncts.io.QueueOps makeSliding
  */
 export function makeSliding<A>(capacity: number, __tsplusTrace?: string): UIO<Queue<A>> {
-  return IO.succeed(bounded<A>(capacity)).flatMap(_makeQueue(new SlidingStrategy()));
+  return IO.succeed(bounded<A>(capacity)).flatMap((queue) => createQueue(queue, new SlidingStrategy()));
 }
 
 /**
  * @tsplus static fncts.io.QueueOps makeUnbounded
  */
 export function makeUnbounded<A>(__tsplusTrace?: string): UIO<Queue<A>> {
-  return IO.succeed(unbounded<A>()).flatMap(_makeQueue(new DroppingStrategy()));
+  return IO.succeed(unbounded<A>()).flatMap((queue) => createQueue(queue, new DroppingStrategy()));
 }
 
 /**
  * @tsplus static fncts.io.QueueOps makeDropping
  */
 export function makeDropping<A>(capacity: number, __tsplusTrace?: string): UIO<Queue<A>> {
-  return IO.succeed(bounded<A>(capacity)).flatMap(_makeQueue(new DroppingStrategy()));
+  return IO.succeed(bounded<A>(capacity)).flatMap((queue) => createQueue(queue, new DroppingStrategy()));
 }
 
 /**
  * @tsplus static fncts.io.QueueOps makeBounded
  */
 export function makeBounded<A>(capacity: number, __tsplusTrace?: string): UIO<Queue<A>> {
-  return IO.succeed(bounded<A>(capacity)).flatMap(_makeQueue(new BackPressureStrategy()));
+  return IO.succeed(bounded<A>(capacity)).flatMap((queue) => createQueue(queue, new BackPressureStrategy()));
+}
+
+function unsafeCreate<A>(
+  queue: MutableQueue<A>,
+  takers: MutableQueue<Future<never, A>>,
+  shutdownHook: Future<never, void>,
+  shutdownFlag: AtomicBoolean,
+  strategy: Strategy<A>,
+): Queue<A> {
+  return new Queue(queue, takers, shutdownHook, shutdownFlag, strategy);
+}
+
+function createQueue<A>(queue: MutableQueue<A>, strategy: Strategy<A>): UIO<Queue<A>> {
+  return Future.make<never, void>().map((p) => unsafeCreate(queue, unbounded(), p, new AtomicBoolean(false), strategy));
 }

package/_src/Queue/definition.ts

@@ -1,69 +1,66 @@
-/**
- * A `PQueue<RA, RB, EA, EB, A, B>` is a lightweight, asynchronous queue into which values of
- * type `A` can be enqueued and of which elements of type `B` can be dequeued. The queue's
- * enqueueing operations may utilize an environment of type `RA` and may fail with errors of
- * type `EA`. The dequeueing operations may utilize an environment of type `RB` and may fail
- * with errors of type `EB`.
- *
- * @tsplus type fncts.io.Queue
- */
-export interface PQueue<RA, RB, EA, EB, A, B> {
-  readonly _RA: () => RA;
-  readonly _RB: () => RB;
-  readonly _EA: () => EA;
-  readonly _EB: () => EB;
-  readonly _A: (_: A) => void;
-  readonly _B: () => B;
-}
+import type { MutableQueue } from "../internal/MutableQueue.js";
+import type { UIO } from "../IO.js";
+import type { Strategy } from "./strategy.js";
+import type { Maybe } from "@fncts/base/data/Maybe";
+import type { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
 
-/**
- * @tsplus type fncts.io.QueueOps
- */
-export interface QueueOps {}
+import { Conc } from "@fncts/base/collection/immutable/Conc";
 
-export const Queue: QueueOps = {};
+import {
+  unsafeCompletePromise,
+  unsafeCompleteTakers,
+  unsafeOfferAll,
+  unsafePollAll,
+  unsafePollN,
+  unsafeRemove,
+} from "./internal.js";
 
-/**
- * @optimize remove
- */
-export function concrete<RA, RB, EA, EB, A, B>(
-  _: PQueue<RA, RB, EA, EB, A, B>,
-): asserts _ is QueueInternal<RA, RB, EA, EB, A, B> {
-  //
-}
+export const QueueTypeId = Symbol.for("fncts.io.Queue");
+export type QueueTypeId = typeof QueueTypeId;
 
-/**
- * A `Queue<RA, RB, EA, EB, A, B>` is a lightweight, asynchronous queue into which values of
- * type `A` can be enqueued and of which elements of type `B` can be dequeued. The queue's
- * enqueueing operations may utilize an environment of type `RA` and may fail with errors of
- * type `EA`. The dequeueing operations may utilize an environment of type `RB` and may fail
- * with errors of type `EB`.
- */
-export abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQueue<RA, RB, EA, EB, A, B> {
-  readonly _RA!: () => RA;
-  readonly _RB!: () => RB;
-  readonly _EA!: () => EA;
-  readonly _EB!: () => EB;
-  readonly _A!: (_: A) => void;
-  readonly _B!: () => B;
+export interface CommonQueue {
+  readonly [QueueTypeId]: QueueTypeId;
+  /**
+   * How many elements can hold in the queue
+   */
+  get capacity(): number;
+  /**
+   * Retrieves the size of the queue, which is equal to the number of elements
+   * in the queue. This may be negative if fibers are suspended waiting for
+   * elements to be added to the queue.
+   */
+  readonly size: UIO<number>;
   /**
    * Waits until the queue is shutdown.
    * The `IO` returned by this method will not resume until the queue has been shutdown.
    * If the queue is already shutdown, the `IO` will resume right away.
    */
-  abstract readonly awaitShutdown: UIO<void>;
+  readonly awaitShutdown: UIO<void>;
   /**
-   * How many elements can hold in the queue
+   * `true` if `shutdown` has been called.
    */
-  abstract readonly capacity: number;
+  readonly isShutdown: UIO<boolean>;
   /**
-   * `true` if `shutdown` has been called.
+   * Interrupts any fibers that are suspended on `offer` or `take`.
+   * Future calls to `offer*` and `take*` will be interrupted immediately.
    */
-  abstract readonly isShutdown: UIO<boolean>;
+  readonly shutdown: UIO<void>;
+  /**
+   * Checks whether the queue is currently full.
+   */
+  readonly isFull: UIO<boolean>;
+  /**
+   * Checks whether the queue is currently empty.
+   */
+  readonly isEmpty: UIO<boolean>;
+}
+
+export interface Enqueue<in A> extends CommonQueue {
+  readonly _In: (_: A) => void;
   /**
    * Places one value in the queue.
    */
-  abstract offer(a: A, __tsplusTrace?: string): IO<RA, EA, boolean>;
+  offer(this: this, a: A, __tsplusTrace?: string): UIO<boolean>;
   /**
    * For Bounded Queue: uses the `BackPressure` Strategy, places the values in the queue and always returns true.
    * If the queue has reached capacity, then
@@ -81,54 +78,206 @@ export abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQueue<RA,
    * It places the values in the queue but if there is no room it will not enqueue them and return false.
    *
    */
-  abstract offerAll(as: Iterable<A>, __tsplusTrace?: string): IO<RA, EA, boolean>;
-  /**
-   * Interrupts any fibers that are suspended on `offer` or `take`.
-   * Future calls to `offer*` and `take*` will be interrupted immediately.
-   */
-  abstract readonly shutdown: UIO<void>;
-  /**
-   * Retrieves the size of the queue, which is equal to the number of elements
-   * in the queue. This may be negative if fibers are suspended waiting for
-   * elements to be added to the queue.
-   */
-  abstract readonly size: UIO<number>;
+  offerAll(this: this, as: Iterable<A>, __tsplusTrace?: string): UIO<boolean>;
+}
+
+export interface Dequeue<out A> extends CommonQueue {
+  readonly _Out: (_: never) => A;
   /**
    * Removes the oldest value in the queue. If the queue is empty, this will
    * return a computation that resumes when an item has been added to the queue.
    */
-  abstract readonly take: IO<RB, EB, B>;
+  readonly take: UIO<A>;
   /**
    * Removes all the values in the queue and returns the list of the values. If the queue
    * is empty returns empty list.
    */
-  abstract readonly takeAll: IO<RB, EB, Conc<B>>;
+  readonly takeAll: UIO<Conc<A>>;
   /**
    * Takes up to max number of values in the queue.
    */
-  abstract takeUpTo(n: number, __tsplusTrace?: string): IO<RB, EB, Conc<B>>;
+  takeUpTo(this: this, max: number, __tsplusTrace?: string): UIO<Conc<A>>;
+  /**
+   * Takes the specified number of elements from the queue. If there are fewer
+   * than the specified number of elements available, it suspends until they
+   * become available.
+   */
+  takeN(this: this, n: number, __tsplusTrace?: string): UIO<Conc<A>>;
+  /**
+   * Takes a number of elements from the queue between the specified minimum and
+   * maximum. If there are fewer than the minimum number of elements available,
+   * suspends until at least the minimum number of elements have been collected.
+   */
+  takeBetween(this: this, min: number, max: number, __tsplusTrace?: string): UIO<Conc<A>>;
+  /**
+   * Take the head option of values in the queue.
+   */
+  readonly poll: UIO<Maybe<A>>;
 }
 
 /**
- * A `Queue<A>` is a lightweight, asynchronous queue into which
- * values of type `A` can be enqueued and dequeued.
+ * A `Queue` is a lightweight, asynchronous queue into which values can be
+ * enqueued and of which elements can be dequeued.
  *
  * @tsplus type fncts.io.Queue
+ * @tsplus companion fncts.io.QueueOps
  */
-export interface Queue<A> extends PQueue<never, never, never, never, A, A> {}
+export class Queue<A> implements Enqueue<A>, Dequeue<A> {
+  readonly [QueueTypeId]: typeof QueueTypeId = QueueTypeId;
+  declare _In: (_: A) => void;
+  declare _Out: (_: never) => A;
+  constructor(
+    readonly queue: MutableQueue<A>,
+    readonly takers: MutableQueue<Future<never, A>>,
+    readonly shutdownHook: Future<never, void>,
+    readonly shutdownFlag: AtomicBoolean,
+    readonly strategy: Strategy<A>,
+  ) {}
 
-export declare namespace Queue {
-  /**
-   * A queue that can only be dequeued.
-   *
-   * @tsplus type fncts.io.Queue
-   */
-  export interface Dequeue<A> extends PQueue<never, never, unknown, never, never, A> {}
+  offer(this: this, a: A, __tsplusTrace?: string): UIO<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);
+          }
+        }
+      }
+    });
+  }
 
-  /**
-   * A queue that can only be enqueued.
-   *
-   * @tsplus type fncts.io.Queue
-   */
-  export interface Enqueue<A> extends PQueue<never, never, never, unknown, A, any> {}
+  offerAll(this: this, as: Iterable<A>, __tsplusTrace?: string): UIO<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);
+        }
+      }
+    });
+  }
+
+  get capacity(): number {
+    return this.queue.capacity;
+  }
+
+  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);
+    }
+  });
+
+  awaitShutdown = this.shutdownHook.await;
+
+  isShutdown: UIO<boolean> = IO(this.shutdownFlag.get);
+
+  shutdown: UIO<void> = IO.deferWith((_, id) => {
+    this.shutdownFlag.set(true);
+    return IO.foreachDiscardC(unsafePollAll(this.takers), (fiber) => fiber.interruptAs(id))
+      .flatMap(() => this.strategy.shutdown)
+      .whenIO(this.shutdownHook.succeed(undefined));
+  }).uninterruptible;
+
+  isFull: UIO<boolean> = this.size.map((size) => size === this.capacity);
+
+  isEmpty: UIO<boolean> = this.size.map((size) => size === 0);
+
+  take: UIO<A> = IO.deferWith((_, fiberId) => {
+    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: UIO<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(this: this, max: number, __tsplusTrace?: string): UIO<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;
+        });
+      }
+    });
+  }
+
+  private takeRemainder(min: number, max: number, acc: Conc<A>, __tsplusTrace?: string): UIO<Conc<A>> {
+    if (max < min) return IO.succeedNow(acc);
+    else {
+      return this.takeUpTo(max).flatMap((bs) => {
+        const remaining = min - bs.length;
+        if (remaining === 1) {
+          return this.take.map((b) => acc.concat(bs).append(b));
+        } else if (remaining > 1) {
+          return this.take.flatMap((b) => this.takeRemainder(remaining - 1, max - bs.length, acc.concat(bs).append(b)));
+        } else {
+          return IO.succeedNow(acc.concat(bs));
+        }
+      });
+    }
+  }
+
+  takeBetween(this: this, min: number, max: number, __tsplusTrace?: string): UIO<Conc<A>> {
+    return this.takeRemainder(min, max, Conc());
+  }
+
+  takeN(this: this, n: number, __tsplusTrace?: string): UIO<Conc<A>> {
+    return this.takeBetween(n, n);
+  }
+
+  poll: UIO<Maybe<A>> = this.takeUpTo(1).map((_) => _.head);
 }