@fncts/io 0.0.1

package/_src/internal/MutableQueue.ts

@@ -0,0 +1,295 @@
+import { assert } from "@fncts/base/util/assert";
+
+/**
+ * @tsplus type fncts.internal.MutableQueue
+ * @tsplus companion fncts.internal.MutableQueueOps
+ */
+export abstract class MutableQueue<A> {
+  /**
+   * The maximum number of elements that a queue can hold.
+   *
+   * @note that unbounded queues can still implement this interface
+   * with `capacity = MAX_NUMBER`.
+   */
+  abstract readonly capacity: number;
+  /**
+   * @return whether the enqueue was successful or not.
+   */
+  abstract enqueue(a: A): boolean;
+  /**
+   * @return elements that were not enqueued
+   */
+  enqueueAll(as: Iterable<A>): Conc<A> {
+    let out        = Conc.empty<A>();
+    const iterator = as[Symbol.iterator]();
+    let result: IteratorResult<A>;
+    while (!(result = iterator.next()).done) {
+      if (!this.enqueue(result.value)) {
+        out = out.append(result.value);
+        break;
+      }
+    }
+    while (!(result = iterator.next()).done) {
+      out = out.append(result.value);
+    }
+    return out;
+  }
+  /**
+   * A non-blocking dequeue.
+   *
+   * @return either an element from the queue, or the `default`
+   * param.
+   *
+   * @note that if there's no meaningful default for your type, you
+   * can always use `poll(undefined)`. Not the best, but reasonable price
+   * to pay for lower heap churn.
+   */
+  abstract dequeue(a: A): A;
+  abstract dequeue(a: A | undefined): A | undefined;
+  abstract dequeue(a: A | undefined): A | undefined;
+  /**
+   * A non-blocking dequeue.
+   *
+   * @return an array of up to `n` elements
+   */
+  dequeueUpTo(n: number): Conc<A> {
+    let result = Conc.empty<A>();
+    for (let i = n; i > 0; i--) {
+      const a = this.dequeue(undefined);
+      if (a === undefined) {
+        break;
+      }
+      result = result.append(a);
+    }
+    return result;
+  }
+  /**
+   * @return the current number of elements inside the queue.
+   *
+   * @note that this method can be non-atomic and return the
+   * approximate number in a concurrent setting.
+   */
+  abstract readonly size: number;
+  /**
+   * @return if the queue is empty
+   */
+  abstract readonly isEmpty: boolean;
+  /**
+   * @return if the queue is full
+   */
+  abstract readonly isFull: boolean;
+
+  forEach(f: (a: A) => void): void {
+    let a: A;
+    while ((a = this.dequeue(undefined)!) !== undefined) {
+      f(a);
+    }
+  }
+}
+
+export class OneElementMutableQueue<A> extends MutableQueue<A> {
+  private ref: A | undefined = undefined;
+
+  capacity = 1;
+
+  get isEmpty() {
+    return this.ref === undefined;
+  }
+
+  get isFull(): boolean {
+    return !this.isEmpty;
+  }
+
+  get size() {
+    return this.isEmpty ? 0 : 1;
+  }
+
+  enqueue(a: A): boolean {
+    if (this.isFull) {
+      return false;
+    } else {
+      this.ref = a;
+      return true;
+    }
+  }
+
+  dequeue(a: A): A;
+  dequeue(a: A | undefined): A | undefined;
+  dequeue(a: A | undefined): A | undefined {
+    if (this.isEmpty) {
+      return a;
+    } else {
+      const res = this.ref;
+      this.ref  = undefined;
+      return res;
+    }
+  }
+}
+
+class Node<A> {
+  item: A;
+  next: Node<A> | null = null;
+  constructor(item: A) {
+    this.item = item;
+  }
+}
+
+export class LinkedQueue<A> extends MutableQueue<A> {
+  private head: Node<A>;
+  private tail: Node<A>;
+  isFull   = false;
+  size     = 0;
+  capacity = Number.MAX_SAFE_INTEGER;
+  constructor() {
+    super();
+    this.head      = new Node<A>(null!);
+    this.tail      = new Node<A>(null!);
+    this.head.next = this.tail;
+  }
+  get isEmpty() {
+    return this.size === 0;
+  }
+  enqueue(a: A): boolean {
+    const newNode = new Node(a);
+    if (this.size === 0) {
+      this.head = newNode;
+    }
+    this.tail.next = newNode;
+    this.tail      = newNode;
+    this.size     += 1;
+    return true;
+  }
+  dequeue(def: A): A;
+  dequeue(def: A | undefined): A | undefined;
+  dequeue(def: A | undefined): A | undefined {
+    if (this.size === 0) {
+      return def;
+    }
+    const elem = this.head.item;
+    this.head  = this.head.next!;
+    this.size -= 1;
+    return elem;
+  }
+}
+
+export abstract class RingBuffer<A> extends MutableQueue<A> {
+  constructor(readonly capacity: number) {
+    super();
+  }
+  private buf: Array<any> = new Array(this.capacity);
+  private head            = 0;
+  private tail            = 0;
+
+  abstract posToIdx(pos: number, capacity: number): number;
+
+  get size(): number {
+    return this.tail - this.head;
+  }
+
+  get enqueuedCount(): number {
+    return this.tail;
+  }
+
+  get dequeuedCount(): number {
+    return this.head;
+  }
+
+  enqueue(a: A): boolean {
+    if (this.tail < this.head + this.capacity) {
+      const curIdx     = this.posToIdx(this.tail, this.capacity);
+      this.buf[curIdx] = a;
+      this.tail       += 1;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  dequeue(def: A): A;
+  dequeue(def: A | undefined): A | undefined;
+  dequeue(def: A): A {
+    if (this.head < this.tail) {
+      const curIdx     = this.posToIdx(this.head, this.capacity);
+      const deqElement = this.buf[curIdx];
+      this.buf[curIdx] = null!;
+      this.head       += 1;
+      return deqElement;
+    } else {
+      return def;
+    }
+  }
+
+  get isEmpty(): boolean {
+    return this.tail === this.head;
+  }
+
+  get isFull(): boolean {
+    return this.tail === this.head + this.capacity;
+  }
+}
+
+function nextPow2(n: number): number {
+  const nextPow = Math.ceil(Math.log(n) / Math.log(2));
+  return Math.max(Math.pow(2, nextPow), 2);
+}
+
+export class RingBufferArb<A> extends RingBuffer<A> {
+  constructor(readonly capacity: number) {
+    super(capacity);
+    assert(capacity >= 2, `RingBufferArb created with capacity ${capacity}`);
+  }
+  posToIdx(pos: number, capacity: number): number {
+    return pos % capacity;
+  }
+}
+
+export class RingBufferPow2<A> extends RingBuffer<A> {
+  constructor(requestedCapacity: number) {
+    super(nextPow2(requestedCapacity));
+    assert(requestedCapacity > 0, `RingBufferPow2 created with capacity ${requestedCapacity}`);
+  }
+  posToIdx(pos: number, capacity: number) {
+    return pos & (capacity - 1);
+  }
+}
+
+export function mkRingBuffer<A>(requestedCapacity: number): RingBuffer<A> {
+  assert(requestedCapacity >= 2, `RingBuffer created with capacity ${requestedCapacity}`);
+  if (nextPow2(requestedCapacity) === requestedCapacity) {
+    return new RingBufferPow2(requestedCapacity);
+  } else {
+    return new RingBufferArb(requestedCapacity);
+  }
+}
+
+/**
+ * @tsplus static fncts.internal.MutableQueueOps bounded
+ */
+export function bounded<A>(capacity: number): MutableQueue<A> {
+  if (capacity === 1) {
+    return new OneElementMutableQueue<A>();
+  } else {
+    return mkRingBuffer<A>(capacity);
+  }
+}
+
+/**
+ * @tsplus static fncts.internal.MutableQueueOps unbounded
+ */
+export function unbounded<A>(): MutableQueue<A> {
+  return new LinkedQueue<A>();
+}
+
+/**
+ * @tsplus getter fncts.internal.MutableQueue unsafeDequeueAll
+ */
+export function unsafeDequeueAll<A>(queue: MutableQueue<A>): Conc<A> {
+  return queue.dequeueUpTo(Number.MAX_SAFE_INTEGER);
+}
+
+/**
+ * @tsplus fluent fncts.internal.MutableQueue unsafeRemove
+ */
+export function unsafeRemove<A>(queue: MutableQueue<A>, a: A): void {
+  queue.enqueueAll(queue.unsafeDequeueAll.filter((_) => _ !== a));
+}

package/_src/internal/Scheduler.ts

@@ -0,0 +1,15 @@
+let isRunning = false;
+const tasks   = new ListBuffer<() => void>();
+
+export const defaultScheduler: (thunk: () => void) => void = (thunk) => {
+  tasks.append(thunk);
+  if (!isRunning) {
+    isRunning = true;
+    Promise.resolve().then(() => {
+      while (tasks.length > 0) {
+        tasks.unprepend()!();
+      }
+      isRunning = false;
+    });
+  }
+};

package/_src/internal/StackTraceBuilder.ts

@@ -0,0 +1,16 @@
+export class StackTraceBuilder {
+  private last: TraceElement | undefined = undefined;
+
+  private builder: ConcBuilder<TraceElement> = Conc.builder();
+
+  append(trace: TraceElement | undefined): void {
+    if (trace != null && trace !== this.last && trace !== TraceElement.NoLocation) {
+      this.builder.append(trace);
+      this.last = trace;
+    }
+  }
+
+  result(): Conc<TraceElement> {
+    return this.builder.result();
+  }
+}

package/collection/immutable/Conc/findIO.d.ts

@@ -0,0 +1,8 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus fluent fncts.Conc findIO
+ * @tsplus location "@fncts/io/collection/immutable/Conc/findIO"
+ */
+export declare function findIO_<R, E, A>(as: Conc<A>, f: (a: A) => IO<R, E, boolean>): IO<R, E, Maybe<A>>;

package/collection/immutable/Conc/mapIO.d.ts

@@ -0,0 +1,7 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus fluent fncts.Conc mapIO
+ * @tsplus location "@fncts/io/collection/immutable/Conc/mapIO"
+ */
+export declare function mapIO_<A, R, E, B>(as: Conc<A>, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>>;

package/collection/immutable/Conc/takeWhileIO.d.ts

@@ -0,0 +1,7 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { IO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus fluent fncts.Conc takeWhileIO
+ * @tsplus location "@fncts/io/collection/immutable/Conc/takeWhileIO"
+ */
+export declare function takeWhileIO_<A, R, E>(as: Conc<A>, p: (a: A) => IO<R, E, boolean>): IO<R, E, Conc<A>>;

package/collection/immutable/Conc.d.ts

@@ -0,0 +1,3 @@
+export * from "./Conc/findIO.js";
+export * from "./Conc/mapIO.js";
+export * from "./Conc/takeWhileIO.js";

package/data/Exit/foreachIO.d.ts

@@ -0,0 +1,9 @@
+import { Exit } from "@fncts/base/data/Exit";
+import { IO, URIO } from "@fncts/io/IO/definition";
+/**
+ * Applies the function `f` to the successful result of the `Exit` and
+ * returns the result in a new `Exit`.
+ * @tsplus fluent fncts.Exit foreachIO
+ * @tsplus location "@fncts/io/data/Exit/foreachIO"
+ */
+export declare function foreachIO_<E2, A2, R, E, A>(exit: Exit<E2, A2>, f: (a: A2) => IO<R, E, A>): IO<R, never, Exit<E | E2, A>>;

package/internal/HashedPair.d.ts

@@ -0,0 +1,9 @@
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+export declare class HashedPair<A, B> implements Hashable, Equatable {
+    readonly first: A;
+    readonly second: B;
+    constructor(first: A, second: B);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}

package/internal/Hub.d.ts

@@ -0,0 +1,121 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+export declare namespace Hub {
+    type Subscription<A> = SubscriptionInternal<A>;
+}
+/**
+ * @tsplus type fncts.internal.Hub.Subscription
+ * @tsplus companion fncts.internal.Hub.SubscriptionOps
+ */
+export declare abstract class SubscriptionInternal<A> {
+    abstract isEmpty(): boolean;
+    abstract poll(def: A): A;
+    abstract pollUpTo(n: number): Conc<A>;
+    abstract size(): number;
+    abstract unsubscribe(): void;
+}
+/**
+ * @tsplus type fncts.internal.Hub
+ * @tsplus companion fncts.internal.Hub
+ */
+export declare abstract class Hub<A> {
+    abstract readonly capacity: number;
+    abstract isEmpty(): boolean;
+    abstract isFull(): boolean;
+    abstract publish(a: A): boolean;
+    abstract publishAll(as: Iterable<A>): Conc<A>;
+    abstract size(): number;
+    abstract slide(): void;
+    abstract subscribe(): SubscriptionInternal<A>;
+}
+export declare class BoundedHubArb<A> extends Hub<A> {
+    array: Array<A>;
+    publisherIndex: number;
+    subscribers: Array<number>;
+    subscriberCount: number;
+    subscribersIndex: number;
+    readonly capacity: number;
+    constructor(requestedCapacity: number);
+    isEmpty(): boolean;
+    isFull(): boolean;
+    publish(a: A): boolean;
+    publishAll(as: Iterable<A>): Conc<A>;
+    size(): number;
+    slide(): void;
+    subscribe(): SubscriptionInternal<A>;
+}
+export declare class BoundedHubPow2<A> extends Hub<A> {
+    array: Array<A>;
+    mask: number;
+    publisherIndex: number;
+    subscribers: Array<number>;
+    subscriberCount: number;
+    subscribersIndex: number;
+    readonly capacity: number;
+    constructor(requestedCapacity: number);
+    isEmpty(): boolean;
+    isFull(): boolean;
+    publish(a: A): boolean;
+    publishAll(as: Iterable<A>): Conc<A>;
+    size(): number;
+    slide(): void;
+    subscribe(): SubscriptionInternal<A>;
+}
+export declare class BoundedHubSingle<A> extends Hub<A> {
+    publisherIndex: number;
+    subscriberCount: number;
+    subscribers: number;
+    value: A;
+    readonly capacity = 1;
+    constructor();
+    isEmpty(): boolean;
+    isFull(): boolean;
+    publish(a: A): boolean;
+    publishAll(as: Iterable<A>): Conc<A>;
+    size(): number;
+    slide(): void;
+    subscribe(): SubscriptionInternal<A>;
+}
+declare class Node<A> {
+    value: A | null;
+    subscribers: number;
+    next: Node<A> | null;
+    constructor(value: A | null, subscribers: number, next: Node<A> | null);
+}
+export declare class UnboundedHub<A> extends Hub<A> {
+    publisherHead: Node<A>;
+    publisherIndex: number;
+    publisherTail: Node<A>;
+    subscribersIndex: number;
+    readonly capacity: number;
+    constructor();
+    isEmpty(): boolean;
+    isFull(): boolean;
+    publish(a: A): boolean;
+    publishAll(as: Iterable<A>): Conc<A>;
+    size(): number;
+    slide(): void;
+    subscribe(): SubscriptionInternal<A>;
+}
+/**
+ * @tsplus static fncts.internal.Hub makeBounded
+ * @tsplus location "@fncts/io/internal/Hub"
+ */
+export declare function makeBounded<A>(requestedCapacity: number): Hub<A>;
+/**
+ * @tsplus static fncts.internal.Hub makeUnbounded
+ * @tsplus location "@fncts/io/internal/Hub"
+ */
+export declare function makeUnbounded<A>(): Hub<A>;
+/**
+ * Unsafely polls all values from a subscription.
+ * @tsplus getter fncts.internal.Hub.Subscription unsafePollAll
+ * @tsplus location "@fncts/io/internal/Hub"
+ */
+export declare function unsafePollAll<A>(subscription: SubscriptionInternal<A>): Conc<A>;
+/**
+ * Unsafely polls the specified number of values from a subscription.
+ * @tsplus fluent fncts.internal.Hub.Subscription unsafePollN
+ * @tsplus location "@fncts/io/internal/Hub"
+ */
+export declare function unsafePollN<A>(subscription: SubscriptionInternal<A>, max: number): Conc<A>;
+export {};

package/internal/MutableQueue.d.ts

@@ -0,0 +1,125 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+/**
+ * @tsplus type fncts.internal.MutableQueue
+ * @tsplus companion fncts.internal.MutableQueueOps
+ */
+export declare abstract class MutableQueue<A> {
+    /**
+     * The maximum number of elements that a queue can hold.
+     *
+     * @note that unbounded queues can still implement this interface
+     * with `capacity = MAX_NUMBER`.
+     */
+    abstract readonly capacity: number;
+    /**
+     * @return whether the enqueue was successful or not.
+     */
+    abstract enqueue(a: A): boolean;
+    /**
+     * @return elements that were not enqueued
+     */
+    enqueueAll(as: Iterable<A>): Conc<A>;
+    /**
+     * A non-blocking dequeue.
+     *
+     * @return either an element from the queue, or the `default`
+     * param.
+     *
+     * @note that if there's no meaningful default for your type, you
+     * can always use `poll(undefined)`. Not the best, but reasonable price
+     * to pay for lower heap churn.
+     */
+    abstract dequeue(a: A): A;
+    abstract dequeue(a: A | undefined): A | undefined;
+    abstract dequeue(a: A | undefined): A | undefined;
+    /**
+     * A non-blocking dequeue.
+     *
+     * @return an array of up to `n` elements
+     */
+    dequeueUpTo(n: number): Conc<A>;
+    /**
+     * @return the current number of elements inside the queue.
+     *
+     * @note that this method can be non-atomic and return the
+     * approximate number in a concurrent setting.
+     */
+    abstract readonly size: number;
+    /**
+     * @return if the queue is empty
+     */
+    abstract readonly isEmpty: boolean;
+    /**
+     * @return if the queue is full
+     */
+    abstract readonly isFull: boolean;
+    forEach(f: (a: A) => void): void;
+}
+export declare class OneElementMutableQueue<A> extends MutableQueue<A> {
+    private ref;
+    capacity: number;
+    get isEmpty(): boolean;
+    get isFull(): boolean;
+    get size(): 1 | 0;
+    enqueue(a: A): boolean;
+    dequeue(a: A): A;
+    dequeue(a: A | undefined): A | undefined;
+}
+export declare class LinkedQueue<A> extends MutableQueue<A> {
+    private head;
+    private tail;
+    isFull: boolean;
+    size: number;
+    capacity: number;
+    constructor();
+    get isEmpty(): boolean;
+    enqueue(a: A): boolean;
+    dequeue(def: A): A;
+    dequeue(def: A | undefined): A | undefined;
+}
+export declare abstract class RingBuffer<A> extends MutableQueue<A> {
+    readonly capacity: number;
+    constructor(capacity: number);
+    private buf;
+    private head;
+    private tail;
+    abstract posToIdx(pos: number, capacity: number): number;
+    get size(): number;
+    get enqueuedCount(): number;
+    get dequeuedCount(): number;
+    enqueue(a: A): boolean;
+    dequeue(def: A): A;
+    dequeue(def: A | undefined): A | undefined;
+    get isEmpty(): boolean;
+    get isFull(): boolean;
+}
+export declare class RingBufferArb<A> extends RingBuffer<A> {
+    readonly capacity: number;
+    constructor(capacity: number);
+    posToIdx(pos: number, capacity: number): number;
+}
+export declare class RingBufferPow2<A> extends RingBuffer<A> {
+    constructor(requestedCapacity: number);
+    posToIdx(pos: number, capacity: number): number;
+}
+export declare function mkRingBuffer<A>(requestedCapacity: number): RingBuffer<A>;
+/**
+ * @tsplus static fncts.internal.MutableQueueOps bounded
+ * @tsplus location "@fncts/io/internal/MutableQueue"
+ */
+export declare function bounded<A>(capacity: number): MutableQueue<A>;
+/**
+ * @tsplus static fncts.internal.MutableQueueOps unbounded
+ * @tsplus location "@fncts/io/internal/MutableQueue"
+ */
+export declare function unbounded<A>(): MutableQueue<A>;
+/**
+ * @tsplus getter fncts.internal.MutableQueue unsafeDequeueAll
+ * @tsplus location "@fncts/io/internal/MutableQueue"
+ */
+export declare function unsafeDequeueAll<A>(queue: MutableQueue<A>): Conc<A>;
+/**
+ * @tsplus fluent fncts.internal.MutableQueue unsafeRemove
+ * @tsplus location "@fncts/io/internal/MutableQueue"
+ */
+export declare function unsafeRemove<A>(queue: MutableQueue<A>, a: A): void;

package/internal/Scheduler.d.ts

@@ -0,0 +1 @@
+export declare const defaultScheduler: (thunk: () => void) => void;

package/internal/StackTraceBuilder.d.ts

@@ -0,0 +1,8 @@
+import { TraceElement } from "@fncts/base/data/TraceElement/definition";
+import { ConcBuilder, Conc } from "@fncts/base/collection/immutable/Conc";
+export declare class StackTraceBuilder {
+    private last;
+    private builder;
+    append(trace: TraceElement | undefined): void;
+    result(): Conc<TraceElement>;
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@fncts/io",
+  "version": "0.0.1",
+  "dependencies": {
+    "@fncts/base": "0.0.1",
+    "@fncts/typelevel": "0.0.1"
+  },
+  "exports": {
+    "./*": {
+      "import": "./_mjs/*",
+      "require": "./_cjs/*"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}