@fncts/io 0.0.1

package/_src/LogLevel.ts

@@ -0,0 +1,79 @@
+/**
+ * @tsplus type fncts.LogLevel
+ * @tsplus companion fncts.LogLevelOps
+ */
+export class LogLevel {
+  constructor(readonly ordinal: number, readonly label: string, readonly syslog: number) {}
+}
+
+/**
+ * @tsplus fluent fncts.LogLevel lt
+ * @tsplus operator fncts.LogLevel <
+ */
+export function lt(self: LogLevel, that: LogLevel): boolean {
+  return self.ordinal < that.ordinal;
+}
+
+/**
+ * @tsplus fluent fncts.LogLevel lte
+ * @tsplus operator fncts.LogLevel <=
+ */
+export function lte(self: LogLevel, that: LogLevel): boolean {
+  return self.ordinal <= that.ordinal;
+}
+
+/**
+ * @tsplus fluent fncts.LogLevel gte
+ * @tsplus operator fncts.LogLevel >=
+ */
+export function gte(self: LogLevel, that: LogLevel): boolean {
+  return self.ordinal >= that.ordinal;
+}
+
+/**
+ * @tsplus fluent fncts.LogLevel gt
+ * @tsplus operator fncts.LogLevel >
+ */
+export function gt(self: LogLevel, that: LogLevel): boolean {
+  return self.ordinal > that.ordinal;
+}
+
+/**
+ * @tsplus static fncts.LogLevelOps All
+ */
+export const All = new LogLevel(Number.MIN_SAFE_INTEGER, "ALL", 0);
+
+/**
+ * @tsplus static fncts.LogLevelOps Fatal
+ */
+export const Fatal = new LogLevel(50000, "FATAL", 2);
+
+/**
+ * @tsplus static fncts.LogLevelOps Error
+ */
+export const Error = new LogLevel(40000, "ERROR", 3);
+
+/**
+ * @tsplus static fncts.LogLevelOps Warning
+ */
+export const Warning = new LogLevel(30000, "WARN", 4);
+
+/**
+ * @tsplus static fncts.LogLevelOps Info
+ */
+export const Info = new LogLevel(20000, "INFO", 6);
+
+/**
+ * @tsplus static fncts.LogLevelOps Debug
+ */
+export const Debug = new LogLevel(10000, "DEBUG", 7);
+
+/**
+ * @tsplus static fncts.LogLevelOps Trace
+ */
+export const Trace = new LogLevel(0, "TRACE", 7);
+
+/**
+ * @tsplus static fncts.LogLevelOps None
+ */
+export const None = new LogLevel(Number.MAX_SAFE_INTEGER, "NONE", 7);

package/_src/LogSpan.ts

@@ -0,0 +1,27 @@
+/**
+ * @tsplus type fncts.LogSpan
+ * @tsplus companion fncts.LogSpanOps
+ */
+export class LogSpan {
+  constructor(readonly label: string, readonly startTime: number) {}
+}
+
+/**
+ * @tsplus fluent 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;
+}

package/_src/Logger/api.ts

@@ -0,0 +1,24 @@
+/**
+ * @tsplus fluent 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();
+    }
+  });
+}
+
+/**
+ * @tsplus fluent 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)),
+  );
+}

package/_src/Logger/constructors.ts

@@ -0,0 +1,59 @@
+/**
+ * @tsplus static fncts.io.LoggerOps defaultString
+ */
+export const defaultString: Logger<string, string> = new Logger(
+  (trace, fiberId, logLevel, message, cause, context, spans, annotations) => {
+    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 += '"';
+
+    if (spans.isNonEmpty()) {
+      let first = true;
+      for (const span of spans) {
+        if (first) {
+          first = false;
+        } else {
+          s += " ";
+        }
+
+        s += span.render(nowMillis);
+      }
+    }
+
+    if (trace._tag === "SourceLocation") {
+      s += " location=";
+      s += quoted(trace.show);
+    }
+
+    // TODO: render Cause, and Annotations
+
+    return s;
+  },
+);
+
+/**
+ * @tsplus fncts.io.Logger none
+ */
+export const none: Logger<unknown, void> = new Logger(() => undefined);
+
+function quoted(label: string): string {
+  if (label.indexOf(" ") < 0) {
+    return label;
+  } else {
+    let s = "";
+    s    += '"';
+    s    += label;
+    s    += '"';
+    return s;
+  }
+}

package/_src/Logger/definition.ts

@@ -0,0 +1,22 @@
+import type { LogSpan } from "@fncts/io/LogSpan";
+
+/**
+ * @tsplus type fncts.io.Logger
+ * @tsplus companion fncts.io.LoggerOps
+ */
+export class Logger<Message, Output> {
+  readonly _Message!: (_: Message) => void;
+  readonly _Output!: () => Output;
+  constructor(
+    readonly log: (
+      trace: TraceElement,
+      fiberId: FiberId,
+      logLevel: LogLevel,
+      message: () => Message,
+      cause: Cause<any>,
+      context: HashMap<FiberRef<unknown>, unknown>,
+      spans: List<LogSpan>,
+      annotations: HashMap<string, string>,
+    ) => Output,
+  ) {}
+}

package/_src/Logger.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: barrel, include: Logger/*.ts }
+export * from "./Logger/api.js";
+export * from "./Logger/constructors.js";
+export * from "./Logger/definition.js";
+// codegen:end

package/_src/Queue/api/dimapIO.ts

@@ -0,0 +1,120 @@
+import { concrete, QueueInternal } from "@fncts/io/Queue/definition";
+
+class DimapIO<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D> extends QueueInternal<
+  RC & RA,
+  RD & RB,
+  EC | EA,
+  ED | EB,
+  C,
+  D
+> {
+  constructor(
+    readonly queue: QueueInternal<RA, RB, EA, EB, A, B>,
+    readonly f: (c: C) => IO<RC, EC, A>,
+    readonly g: (b: B) => IO<RD, ED, D>,
+  ) {
+    super();
+  }
+
+  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+
+  capacity: number = this.queue.capacity;
+
+  isShutdown: UIO<boolean> = this.queue.isShutdown;
+
+  offer(c: C): IO<RC & RA, EA | EC, boolean> {
+    return this.f(c).flatMap((a) => this.queue.offer(a));
+  }
+
+  offerAll(cs: Iterable<C>): IO<RC & RA, EC | EA, boolean> {
+    return IO.foreach(cs, this.f).flatMap((as) => this.queue.offerAll(as));
+  }
+
+  shutdown: UIO<void> = this.queue.shutdown;
+
+  size: UIO<number> = this.queue.size;
+
+  take: IO<RD & RB, ED | EB, D> = this.queue.take.flatMap(this.g);
+
+  takeAll: IO<RD & RB, ED | EB, Conc<D>> = this.queue.takeAll.flatMap((bs) => IO.foreach(bs, this.g));
+
+  takeUpTo(n: number): IO<RD & RB, ED | EB, Conc<D>> {
+    return this.queue.takeUpTo(n).flatMap((bs) => IO.foreach(bs, this.g));
+  }
+}
+
+/**
+ * Transforms elements enqueued into and dequeued from this queue with the
+ * specified effectual functions.
+ *
+ * @tsplus fluent fncts.io.Queue dimap
+ */
+export function dimap_<RA, RB, EA, EB, A, B, C, D>(self: PQueue<RA, RB, EA, EB, A, B>, f: (c: C) => A, g: (b: B) => D) {
+  return self.dimapIO(
+    (c: C) => IO.succeedNow(f(c)),
+    (b) => IO.succeedNow(g(b)),
+  );
+}
+
+/**
+ * Transforms elements enqueued into and dequeued from this queue with the
+ * specified effectual functions.
+ *
+ * @tsplus fluent fncts.io.Queue dimapIO
+ */
+export function dimapIO_<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  f: (c: C) => IO<RC, EC, A>,
+  g: (b: B) => IO<RD, ED, D>,
+): PQueue<RC & RA, RD & RB, EC | EA, ED | EB, C, D> {
+  concrete(queue);
+  return new DimapIO(queue, f, g);
+}
+
+/**
+ * Transforms elements enqueued into this queue with an effectful function.
+ *
+ * @tsplus fluent fncts.io.Queue contramapIO
+ */
+export function contramapIO_<RA, RB, EA, EB, A, B, RC, EC, C>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  f: (c: C) => IO<RC, EC, A>,
+): PQueue<RA & RC, RB, EA | EC, EB, C, B> {
+  return queue.dimapIO(f, IO.succeedNow);
+}
+
+/**
+ * Transforms elements enqueued into this queue with an effectful function.
+ *
+ * @tsplus fluent fncts.io.Queue contramap
+ */
+export function contramap_<RA, RB, EA, EB, A, B, C>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  f: (c: C) => A,
+): PQueue<RA, RB, EA, EB, C, B> {
+  return queue.contramapIO((c) => IO.succeedNow(f(c)));
+}
+
+/**
+ * Transforms elements dequeued from this queue with an effectful function.
+ *
+ * @tsplus fluent fncts.io.Queue mapIO
+ */
+export function mapIO_<RA, RB, EA, EB, A, B, R2, E2, C>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  f: (b: B) => IO<R2, E2, C>,
+): PQueue<RA, R2 & RB, EA, EB | E2, A, C> {
+  return queue.dimapIO(IO.succeedNow, f);
+}
+
+/**
+ * Transforms elements dequeued from this queue with a function.
+ *
+ * @tsplus fluent fncts.io.Queue map
+ */
+export function map_<RA, RB, EA, EB, A, B, C>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  f: (b: B) => C,
+): PQueue<RA, RB, EA, EB, A, C> {
+  return queue.mapIO((b) => IO.succeedNow(f(b)));
+}

package/_src/Queue/api/filterInputIO.ts

@@ -0,0 +1,73 @@
+import { concrete, QueueInternal } from "@fncts/io/Queue/definition";
+
+export class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInternal<
+  RA & R2,
+  RB,
+  EA | E2,
+  EB,
+  A1,
+  B
+> {
+  constructor(readonly queue: QueueInternal<RA, RB, EA, EB, A, B>, readonly f: (_: A1) => IO<R2, E2, boolean>) {
+    super();
+  }
+
+  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+
+  capacity: number = this.queue.capacity;
+
+  isShutdown: UIO<boolean> = this.queue.isShutdown;
+
+  offer(a: A1): IO<RA & R2, EA | E2, boolean> {
+    return this.f(a).flatMap((b) => (b ? this.queue.offer(a) : IO.succeedNow(false)));
+  }
+
+  offerAll(as: Iterable<A1>): IO<RA & R2, EA | E2, boolean> {
+    return IO.foreach(as, (a) => this.f(a).map((b) => (b ? Just(a) : Nothing()))).flatMap((ms) => {
+      const filtered = ms.compact;
+      if (filtered.isEmpty) {
+        return IO.succeedNow(false);
+      } else {
+        return this.queue.offerAll(filtered);
+      }
+    });
+  }
+
+  shutdown: UIO<void> = this.queue.shutdown;
+
+  size: UIO<number> = this.queue.size;
+
+  take: IO<RB, EB, B> = this.queue.take;
+
+  takeAll: IO<RB, EB, Conc<B>> = this.queue.takeAll;
+
+  takeUpTo(max: number): IO<RB, EB, Conc<B>> {
+    return this.queue.takeUpTo(max);
+  }
+}
+
+/**
+ * Like `filterInput`, but uses an effectful function to filter the elements.
+ *
+ * @tsplus fluent fncts.io.Queue filterInputIO
+ */
+export function filterInputIO_<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  f: (_: A1) => IO<R2, E2, boolean>,
+): PQueue<RA & R2, RB, EA | E2, EB, A1, B> {
+  concrete(queue);
+  return new FilterInputIO(queue, f);
+}
+
+/**
+ * Applies a filter to elements enqueued into this queue. Elements that do not
+ * pass the filter will be immediately dropped.
+ *
+ * @tsplus fluent fncts.io.Queue filterInput
+ */
+export function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  f: (_: A1) => boolean,
+): PQueue<RA, RB, EA, EB, A1, B> {
+  return queue.filterInputIO((a) => IO.succeedNow(f(a)));
+}

package/_src/Queue/api/filterOutputIO.ts

@@ -0,0 +1,74 @@
+import { concrete, QueueInternal } from "@fncts/io/Queue/definition";
+
+export class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, RB & RB1, EA, EB | EB1, A, B> {
+  constructor(readonly queue: QueueInternal<RA, RB, EA, EB, A, B>, readonly f: (b: B) => IO<RB1, EB1, boolean>) {
+    super();
+  }
+
+  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+
+  capacity: number = this.queue.capacity;
+
+  isShutdown: UIO<boolean> = this.queue.isShutdown;
+
+  offer(a: A): IO<RA, EA, boolean> {
+    return this.queue.offer(a);
+  }
+
+  offerAll(as: Iterable<A>): IO<RA, EA, boolean> {
+    return this.queue.offerAll(as);
+  }
+
+  shutdown: UIO<void> = this.queue.shutdown;
+
+  size: UIO<number> = this.queue.size;
+
+  take: IO<RB & RB1, EB1 | EB, B> = this.queue.take.flatMap((b) =>
+    this.f(b).flatMap((p) => (p ? IO.succeedNow(b) : this.take)),
+  );
+
+  takeAll: IO<RB & RB1, EB | EB1, Conc<B>> = this.queue.takeAll.flatMap((bs) => IO.filter(bs, this.f));
+
+  loop(max: number, acc: Conc<B>): IO<RB & RB1, EB | EB1, Conc<B>> {
+    return this.queue.takeUpTo(max).flatMap((bs) => {
+      if (bs.isEmpty) {
+        return IO.succeedNow(acc);
+      }
+
+      return IO.filter(bs, this.f).flatMap((filtered) => {
+        const length = filtered.length;
+
+        if (length === max) {
+          return IO.succeedNow(acc.concat(filtered));
+        } else {
+          return this.loop(max - length, acc.concat(filtered));
+        }
+      });
+    });
+  }
+
+  takeUpTo(n: number): IO<RB & RB1, EB | EB1, Conc<B>> {
+    return IO.defer(this.loop(n, Conc.empty()));
+  }
+}
+
+/**
+ * @tsplus fluent fncts.io.Queue filterOutputIO
+ */
+export function filterOutputIO_<RA, RB, EA, EB, A, B, RB1, EB1>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  f: (b: B) => IO<RB1, EB1, boolean>,
+): PQueue<RA, RB & RB1, EA, EB | EB1, A, B> {
+  concrete(queue);
+  return new FilterOutputIO(queue, f);
+}
+
+/**
+ * @tsplus fluent fncts.io.Queue filterOutput
+ */
+export function filterOutput_<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  p: Predicate<B>,
+): PQueue<RA, RB, EA, EB, A, B> {
+  return queue.filterOutputIO((b) => IO.succeedNow(p(b)));
+}

package/_src/Queue/api/operations.ts

@@ -0,0 +1,121 @@
+import { concrete } from "@fncts/io/Queue/definition";
+
+/**
+ * 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.
+ *
+ * @tsplus getter fncts.io.Queue awaitShutdown
+ */
+export function awaitShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): UIO<void> {
+  concrete(queue);
+  return queue.awaitShutdown;
+}
+
+/**
+ * How many elements can hold in the queue
+ *
+ * @tsplus getter fncts.io.Queue capacity
+ */
+export function capacity<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): number {
+  concrete(queue);
+  return queue.capacity;
+}
+
+/**
+ * `true` if `shutdown` has been called.
+ *
+ * @tsplus getter fncts.io.Queue isShutdown
+ */
+export function isShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): UIO<boolean> {
+  concrete(queue);
+  return queue.isShutdown;
+}
+
+/**
+ * Places one value in the queue.
+ *
+ * @tsplus fluent fncts.io.Queue offer
+ */
+export function offer_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, a: A): IO<RA, EA, boolean> {
+  concrete(queue);
+  return queue.offer(a);
+}
+
+/**
+ * For Bounded Queue: uses the `BackPressure` Strategy, places the values in the queue and always returns true.
+ * If the queue has reached capacity, then
+ * the fiber performing the `offerAll` will be suspended until there is room in
+ * the queue.
+ *
+ * For Unbounded Queue:
+ * Places all values in the queue and returns true.
+ *
+ * For Sliding Queue: uses `Sliding` Strategy
+ * If there is room in the queue, it places the values otherwise it removes the old elements and
+ * enqueues the new ones. Always returns true.
+ *
+ * For Dropping Queue: uses `Dropping` Strategy,
+ * It places the values in the queue but if there is no room it will not enqueue them and return false.
+ *
+ * @tsplus fluent fncts.io.Queue offerAll
+ */
+export function offerAll_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, as: Iterable<A>) {
+  concrete(queue);
+  return queue.offerAll(as);
+}
+
+/**
+ * Interrupts any fibers that are suspended on `offer` or `take`.
+ * Future calls to `offer*` and `take*` will be interrupted immediately.
+ *
+ * @tsplus getter fncts.io.Queue shutdown
+ */
+export function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>) {
+  concrete(queue);
+  return queue.shutdown;
+}
+
+/**
+ * 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.
+ *
+ * @tsplus getter fncts.io.Queue size
+ */
+export function size<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>) {
+  concrete(queue);
+  return queue.size;
+}
+
+/**
+ * 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.
+ *
+ * @tsplus getter fncts.io.Queue take
+ */
+export function take<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>) {
+  concrete(queue);
+  return queue.take;
+}
+
+/**
+ * Removes all the values in the queue and returns the list of the values. If the queue
+ * is empty returns empty list.
+ *
+ * @tsplus getter fncts.io.Queue takeAll
+ */
+export function takeAll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>) {
+  concrete(queue);
+  return queue.takeAll;
+}
+
+/**
+ * Takes up to max number of values in the queue.
+ *
+ * @tsplus fluent fncts.io.Queue takeAllUpTo
+ */
+export function takeAllUpTo_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, n: number) {
+  concrete(queue);
+  return queue.takeUpTo(n);
+}

package/_src/Queue/api/poll.ts

@@ -0,0 +1,11 @@
+import { concrete } from "@fncts/io/Queue/definition";
+
+/**
+ * Take the head option of values in the queue.
+ *
+ * @tsplus getter fncts.io.Queue poll
+ */
+export function poll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>): IO<RB, EB, Maybe<B>> {
+  concrete(queue);
+  return queue.takeUpTo(1).map((bs) => bs.head);
+}

package/_src/Queue/api/takeBetween.ts

@@ -0,0 +1,40 @@
+import { concrete } from "@fncts/io/Queue/definition";
+
+function takeRemainderLoop<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, n: number): IO<RB, EB, Conc<B>> {
+  concrete(queue);
+  if (n <= 0) {
+    return IO.succeedNow(Conc.empty());
+  } else {
+    return queue.take.flatMap((b) => takeRemainderLoop(queue, n - 1).map((out) => out.prepend(b)));
+  }
+}
+
+/**
+ * Takes between min and max number of values from the queue. If there
+ * is less than min items available, it'll block until the items are
+ * collected.
+ *
+ * @tsplus fluent fncts.io.Queue takeBetween
+ */
+export function takeBetween_<RA, RB, EA, EB, A, B>(
+  queue: PQueue<RA, RB, EA, EB, A, B>,
+  min: number,
+  max: number,
+): IO<RB, EB, Conc<B>> {
+  concrete(queue);
+  if (max < min) {
+    return IO.succeedNow(Conc.empty());
+  } else {
+    return queue.takeUpTo(max).flatMap((bs) => {
+      const remaining = min - bs.length;
+
+      if (remaining === 1) {
+        return queue.take.map((b) => bs.prepend(b));
+      } else if (remaining > 1) {
+        return takeRemainderLoop(queue, remaining - 1).map((list) => bs.concat(list));
+      } else {
+        return IO.succeedNow(bs);
+      }
+    });
+  }
+}