@fncts/io 0.0.20 → 0.0.21

package/_src/Queue/api/filterOutputIO.ts

@@ -1,76 +0,0 @@
-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>,
-  __tsplusTrace?: string,
-): 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>,
-  __tsplusTrace?: string,
-): PQueue<RA, RB, EA, EB, A, B> {
-  return queue.filterOutputIO((b) => IO.succeedNow(p(b)));
-}

package/_src/Queue/api/operations.ts

@@ -1,139 +0,0 @@
-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>,
-  __tsplusTrace?: string,
-): 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>, __tsplusTrace?: string): 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>,
-  __tsplusTrace?: string,
-): 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,
-  __tsplusTrace?: string,
-): 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>,
-  __tsplusTrace?: string,
-) {
-  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>, __tsplusTrace?: string) {
-  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>, __tsplusTrace?: string) {
-  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>, __tsplusTrace?: string): IO<RB, EB, 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>, __tsplusTrace?: string) {
-  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,
-  __tsplusTrace?: string,
-) {
-  concrete(queue);
-  return queue.takeUpTo(n);
-}

package/_src/Queue/api/poll.ts

@@ -1,14 +0,0 @@
-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>,
-  __tsplusTrace?: string,
-): IO<RB, EB, Maybe<B>> {
-  concrete(queue);
-  return queue.takeUpTo(1).map((bs) => bs.head);
-}

package/_src/Queue/api/takeBetween.ts

@@ -1,45 +0,0 @@
-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,
-  __tsplusTrace?: string,
-): 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,
-  __tsplusTrace?: string,
-): 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);
-      }
-    });
-  }
-}

package/_src/Queue/api/zipWithIO.ts

@@ -1,99 +0,0 @@
-import { tuple } from "@fncts/base/data/function";
-import { concrete, QueueInternal } from "@fncts/io/Queue/definition";
-
-export class ZipWithIO<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A> extends QueueInternal<
-  RA | RA1,
-  RB | RB1 | R3,
-  EA | EA1,
-  E3 | EB | EB1,
-  A1,
-  D
-> {
-  constructor(
-    readonly fa: QueueInternal<RA, RB, EA, EB, A, B>,
-    readonly fb: QueueInternal<RA1, RB1, EA1, EB1, A1, C>,
-    readonly f: (b: B, c: C) => IO<R3, E3, D>,
-  ) {
-    super();
-  }
-
-  awaitShutdown: UIO<void> = this.fa.awaitShutdown.flatMap(() => this.fb.awaitShutdown);
-
-  capacity: number = Math.min(this.fa.capacity, this.fb.capacity);
-
-  isShutdown: UIO<boolean> = this.fa.isShutdown;
-
-  offer(a: A1): IO<RA | RA1, EA1 | EA, boolean> {
-    return this.fa.offer(a).zipWithC(this.fb.offer(a), (x, y) => x && y);
-  }
-
-  offerAll(as: Iterable<A1>): IO<RA | RA1, EA1 | EA, boolean> {
-    return this.fa.offerAll(as).zipWithC(this.fb.offerAll(as), (x, y) => x && y);
-  }
-
-  shutdown: UIO<void> = this.fa.shutdown.zipWithC(this.fb.shutdown, () => undefined);
-
-  size: UIO<number> = this.fa.size.zipWithC(this.fb.size, (x, y) => Math.max(x, y));
-
-  take: IO<RB | RB1 | R3, E3 | EB | EB1, D> = this.fa.take.zipC(this.fb.take).flatMap(([b, c]) => this.f(b, c));
-
-  takeAll: IO<RB | RB1 | R3, E3 | EB | EB1, Conc<D>> = this.fa.takeAll
-    .zipC(this.fb.takeAll)
-    .flatMap(([bs, cs]) => IO.foreach(bs.zip(cs), ([b, c]) => this.f(b, c)));
-
-  takeUpTo(max: number): IO<RB | RB1 | R3, E3 | EB | EB1, Conc<D>> {
-    return this.fa
-      .takeUpTo(max)
-      .zipC(this.fb.takeUpTo(max))
-      .flatMap(([bs, cs]) => IO.foreach(bs.zip(cs), ([b, c]) => this.f(b, c)));
-  }
-}
-
-/**
- * Creates a new queue from this queue and another. Offering to the composite queue
- * will broadcast the elements to both queues; taking from the composite queue
- * will dequeue elements from both queues and apply the function point-wise.
- *
- * Note that using queues with different strategies may result in surprising behavior.
- * For example, a dropping queue and a bounded queue composed together may apply `f`
- * to different elements.
- *
- * @tsplus fluent fncts.io.Queue zipWithIO
- */
-export function zipWithIO_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A>(
-  fa: PQueue<RA, RB, EA, EB, A, B>,
-  fb: PQueue<RA1, RB1, EA1, EB1, A1, C>,
-  f: (b: B, c: C) => IO<R3, E3, D>,
-  __tsplusTrace?: string,
-): PQueue<RA | RA1, RB | RB1 | R3, EA | EA1, E3 | EB | EB1, A1, D> {
-  concrete(fa);
-  concrete(fb);
-  return new ZipWithIO(fa, fb, f);
-}
-
-/**
- * Like `zipWithM`, but uses a pure function.
- *
- * @tsplus fluent fncts.io.Queue zipWith
- */
-export function zipWith_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, D, A>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
-  that: PQueue<RA1, RB1, EA1, EB1, A1, C>,
-  f: (b: B, c: C) => D,
-  __tsplusTrace?: string,
-): PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, D> {
-  return zipWithIO_(queue, that, (b, c) => IO.succeedNow(f(b, c)));
-}
-
-/**
- * Like `zipWith`, but tuples the elements instead of applying a function.
- *
- * @tsplus fluent fncts.io.Queue zip
- */
-export function zip_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, A>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
-  that: PQueue<RA1, RB1, EA1, EB1, A1, C>,
-  __tsplusTrace?: string,
-): PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, readonly [B, C]> {
-  return zipWith_(queue, that, tuple);
-}

package/_src/Queue/api.ts

@@ -1,9 +0,0 @@
-// codegen:start { preset: barrel, include: api/*.ts }
-export * from "./api/dimapIO.js";
-export * from "./api/filterInputIO.js";
-export * from "./api/filterOutputIO.js";
-export * from "./api/operations.js";
-export * from "./api/poll.js";
-export * from "./api/takeBetween.js";
-export * from "./api/zipWithIO.js";
-// codegen:end

package/_src/Ref/Atomic/Atomic.ts

@@ -1,56 +0,0 @@
-import type { PRef } from "../definition.js";
-
-import { RefInternal } from "../definition.js";
-import { Derived } from "../Derived.js";
-import { DerivedAll } from "../DerivedAll.js";
-
-/**
- * @tsplus type fncts.io.Ref.Atomic
- */
-export class Atomic<A> extends RefInternal<never, never, never, never, A, A> {
-  readonly _tag = "Atomic";
-
-  constructor(private value: A) {
-    super();
-    this.match    = this.match.bind(this);
-    this.matchAll = this.matchAll.bind(this);
-    this.set      = this.set.bind(this);
-  }
-
-  match<EC, ED, C, D>(
-    _ea: (_: never) => EC,
-    _eb: (_: never) => ED,
-    ca: (_: C) => Either<EC, A>,
-    bd: (_: A) => Either<ED, D>,
-  ): PRef<never, never, EC, ED, C, D> {
-    return new Derived<EC, ED, C, D>((f) => f(this, bd, ca));
-  }
-
-  matchAll<EC, ED, C, D>(
-    _ea: (_: never) => EC,
-    _eb: (_: never) => ED,
-    _ec: (_: never) => EC,
-    ca: (_: C) => (_: A) => Either<EC, A>,
-    bd: (_: A) => Either<ED, D>,
-  ): PRef<never, never, EC, ED, C, D> {
-    return new DerivedAll<EC, ED, C, D>((f) => f(this, bd, ca));
-  }
-
-  get unsafeGet(): A {
-    return this.value;
-  }
-
-  unsafeSet(a: A): void {
-    this.value = a;
-  }
-
-  get get(): UIO<A> {
-    return IO.succeed(this.value);
-  }
-
-  set(a: A): UIO<void> {
-    return IO.succeed(() => {
-      this.value = a;
-    });
-  }
-}

package/_src/Ref/Atomic/api.ts

@@ -1,124 +0,0 @@
-import type { Atomic } from "./Atomic.js";
-
-/**
- * @tsplus fluent fncts.io.Ref.Atomic getAndSet
- */
-export function getAndSet<A>(self: Atomic<A>, a: A, __tsplusTrace?: string): UIO<A> {
-  return IO.succeed(() => {
-    const v = self.unsafeGet;
-    self.unsafeSet(a);
-    return v;
-  });
-}
-
-/**
- * @tsplus fluent fncts.io.Ref.Atomic getAndUpdate
- */
-export function getAndUpdate<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string) {
-  return IO.succeed(() => {
-    const v = self.unsafeGet;
-    self.unsafeSet(f(v));
-    return v;
-  });
-}
-
-/**
- * @tsplus fluent fncts.io.Ref.Atomic getAndUpdateJust
- */
-export function getAndUpdateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
-  return IO.succeed(() => {
-    const v = self.unsafeGet;
-    const o = f(v);
-    Maybe.concrete(o);
-    if (o._tag === "Just") {
-      self.unsafeSet(o.value);
-    }
-    return v;
-  });
-}
-
-/**
- * @tsplus fluent fncts.io.Ref.Atomic modify
- */
-export function modify<A, B>(self: Atomic<A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string) {
-  return IO.succeed(() => {
-    const v = self.unsafeGet;
-    const o = f(v);
-    self.unsafeSet(o[1]);
-    return o[0];
-  });
-}
-
-/**
- * @tsplus fluent fncts.io.Ref.Atomic modifyJust
- */
-export function modifyJust<A, B>(self: Atomic<A>, def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string) {
-  return IO.succeed(() => {
-    const v = self.unsafeGet;
-    const o = f(v);
-
-    Maybe.concrete(o);
-    if (o._tag === "Just") {
-      self.unsafeSet(o.value[1]);
-      return o.value[0];
-    }
-
-    return def;
-  });
-}
-
-/**
- * @tsplus fluent fncts.io.Ref.Atomic update
- */
-export function update<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string) {
-  return IO.succeed(() => {
-    self.unsafeSet(f(self.unsafeGet));
-  });
-}
-
-/**
- * @tsplus fluent fncts.io.Ref.Atomic updateAndGet
- */
-export function updateAndGet<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string) {
-  return IO.succeed(() => {
-    self.unsafeSet(f(self.unsafeGet));
-    return self.unsafeGet;
-  });
-}
-
-/**
- * @tsplus fluent fncts.io.Ref.Atomic updateJust
- */
-export function updateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
-  return IO.succeed(() => {
-    const o = f(self.unsafeGet);
-
-    Maybe.concrete(o);
-    if (o._tag === "Just") {
-      self.unsafeSet(o.value);
-    }
-  });
-}
-
-/**
- * @tsplus fluent fncts.io.Ref.Atomic updateJustAndGet
- */
-export function updateJustAndGet<A>(self: Atomic<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
-  return IO.succeed(() => {
-    const o = f(self.unsafeGet);
-
-    Maybe.concrete(o);
-    if (o._tag === "Just") {
-      self.unsafeSet(o.value);
-    }
-
-    return self.unsafeGet;
-  });
-}
-
-/**
- * @tsplus fluent fncts.io.Ref.Atomic unsafeUpdate
- */
-export function unsafeUpdate<A>(self: Atomic<A>, f: (a: A) => A, __tsplusTrace?: string) {
-  return self.unsafeSet(f(self.unsafeGet));
-}

package/_src/Ref/Derived.ts

@@ -1,71 +0,0 @@
-import type { Atomic } from "./Atomic/Atomic.js";
-import type { PRef } from "./definition.js";
-
-import { RefInternal } from "./definition.js";
-import { DerivedAll } from "./DerivedAll.js";
-
-export class Derived<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A, B> {
-  readonly _tag = "Derived";
-
-  constructor(
-    readonly use: <X>(
-      f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>) => X,
-    ) => X,
-  ) {
-    super();
-    this.match    = this.match.bind(this);
-    this.matchAll = this.matchAll.bind(this);
-    this.set      = this.set.bind(this);
-  }
-
-  match<EC, ED, C, D>(
-    ea: (_: EA) => EC,
-    eb: (_: EB) => ED,
-    ca: (_: C) => Either<EC, A>,
-    bd: (_: B) => Either<ED, D>,
-  ): PRef<never, never, EC, ED, C, D> {
-    return this.use(
-      (value, getEither, setEither) =>
-        new Derived<EC, ED, C, D>((f) =>
-          f(
-            value,
-            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
-            (c) => ca(c).flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
-          ),
-        ),
-    );
-  }
-
-  matchAll<EC, ED, C, D>(
-    ea: (_: EA) => EC,
-    eb: (_: EB) => ED,
-    ec: (_: EB) => EC,
-    ca: (_: C) => (_: B) => Either<EC, A>,
-    bd: (_: B) => Either<ED, D>,
-  ): PRef<never, never, EC, ED, C, D> {
-    return this.use(
-      (value, getEither, setEither) =>
-        new DerivedAll<EC, ED, C, D>((f) =>
-          f(
-            value,
-            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
-            (c) => (s) =>
-              getEither(s)
-                .match(
-                  (eb) => Either.left(ec(eb)),
-                  (b) => ca(c)(b),
-                )
-                .flatMap((a) => setEither(a).match((e) => Either.left(ea(e)), Either.right)),
-          ),
-        ),
-    );
-  }
-
-  get get(): FIO<EB, B> {
-    return this.use((value, getEither) => value.get.flatMap((s) => getEither(s).match(IO.failNow, IO.succeedNow)));
-  }
-
-  set(a: A): FIO<EA, void> {
-    return this.use((value, _, setEither) => setEither(a).match(IO.failNow, (s) => value.set(s)));
-  }
-}