@fncts/io 0.0.20 → 0.0.21

package/_src/Ref/DerivedAll.ts

@@ -1,75 +0,0 @@
-import type { Atomic } from "./Atomic/Atomic.js";
-import type { PRef } from "./definition.js";
-
-import { RefInternal } from "./definition.js";
-
-export class DerivedAll<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A, B> {
-  readonly _tag = "DerivedAll";
-
-  constructor(
-    readonly use: <X>(
-      f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => 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 DerivedAll((f) =>
-          f(
-            value,
-            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
-            (c) => (s) => ca(c).flatMap((a) => setEither(a)(s).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((f) =>
-          f(
-            value,
-            (s) => getEither(s).match((e) => Either.left(eb(e)), bd),
-            (c) => (s) =>
-              getEither(s)
-                .match((e) => Either.left(ec(e)), ca(c))
-                .flatMap((a) => setEither(a)(s).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) =>
-        value.modify((s) =>
-          setEither(a)(s).match(
-            (e) => [Either.left(e), s] as [Either<EA, void>, typeof s],
-            (s) => [Either.right(undefined), s],
-          ),
-        ).absolve,
-    );
-  }
-}

package/_src/Ref/Synchronized/api.ts

@@ -1,249 +0,0 @@
-import type { PRef } from "../definition.js";
-
-import { identity, tuple } from "@fncts/base/data/function";
-
-import { concreteSynchronized } from "./definition.js";
-
-/**
- * Maps and filters the `get` value of the `SRef` with the specified
- * effectual partial function, returning a `SRef` with a `get` value that
- * succeeds with the result of the partial function if it is defined or else
- * fails with `None`.
- *
- * @tsplus fluent fncts.io.Ref.Synchronized collectIO
- */
-export function collectIO_<RA, RB, EA, EB, A, B, RC, EC, C>(
-  ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
-  f: (b: B) => Maybe<IO<RC, EC, C>>,
-  __tsplusTrace?: string,
-): PRef.Synchronized<RA, RB | RC, EA, Maybe<EB | EC>, A, C> {
-  return ref.matchIO(
-    identity,
-    (eb) => Just<EB | EC>(eb),
-    IO.succeedNow,
-    (b) =>
-      f(b)
-        .map((a) => a.asJustError)
-        .getOrElse(IO.failNow(Nothing())),
-  );
-}
-
-/**
- * Transforms the `set` value of the `SRef` with the specified effectual
- * function.
- *
- * @tsplus fluent fncts.io.Ref.Synchronized contramapIO
- */
-export function contramapIO_<RA, RB, EA, EB, B, A, RC, EC, C>(
-  ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
-  f: (c: C) => IO<RC, EC, A>,
-  __tsplusTrace?: string,
-): PRef.Synchronized<RA | RC, RB, EC | EA, EB, C, B> {
-  return ref.dimapIO(f, IO.succeedNow);
-}
-
-/**
- * Transforms both the `set` and `get` values of the `Synchronized` with the
- * specified effectual functions.
- *
- * @tsplus fluent fncts.io.Ref.Synchronized dimapIO
- */
-export function dimapIO_<RA, RB, EA, EB, B, RC, EC, A, RD, ED, C = A, D = B>(
-  ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
-  f: (c: C) => IO<RC, EC, A>,
-  g: (b: B) => IO<RD, ED, D>,
-  __tsplusTrace?: string,
-): PRef.Synchronized<RA | RC, RB | RD, EA | EC, EB | ED, C, D> {
-  return ref.matchIO(
-    (ea: EA | EC) => ea,
-    (eb: EB | ED) => eb,
-    f,
-    g,
-  );
-}
-
-/**
- * Filters the `set` value of the `SRef` with the specified effectual
- * predicate, returning a `SRef` with a `set` value that succeeds if the
- * predicate is satisfied or else fails with `None`.
- *
- * @tsplus fluent fncts.io.Ref.Synchronized filterInputIO
- */
-export function filterInputIO_<RA, RB, EA, EB, B, A, RC, EC, A1 extends A = A>(
-  ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
-  f: (a: A1) => IO<RC, EC, boolean>,
-  __tsplusTrace?: string,
-): PRef.Synchronized<RA | RC, RB, Maybe<EC | EA>, EB, A1, B> {
-  return ref.matchIO(
-    (ea): Maybe<EC | EA> => Just(ea),
-    identity,
-    (a) => f(a).asJustError.ifIO(IO.failNow(Nothing()), IO.succeedNow(a)),
-    IO.succeedNow,
-  );
-}
-
-/**
- * Filters the `get` value of the `SRef` with the specified effectual predicate,
- * returning a `SRef` with a `get` value that succeeds if the predicate is
- * satisfied or else fails with `None`.
- *
- * @tsplus fluent fncts.io.Ref.Synchronized filterOutputIO
- */
-export function filterOutputIO_<RA, RB, EA, EB, A, B, RC, EC>(
-  ref: PRef.Synchronized<RA, RB, EA, EB, A, B>,
-  f: (b: B) => IO<RC, EC, boolean>,
-  __tsplusTrace?: string,
-): PRef.Synchronized<RA, RB | RC, EA, Maybe<EC | EB>, A, B> {
-  return ref.matchIO(
-    identity,
-    (eb): Maybe<EC | EB> => Maybe.just(eb),
-    IO.succeedNow,
-    (b) => f(b).asJustError.ifIO(IO.succeedNow(b), IO.failNow(Nothing())),
-  );
-}
-
-/**
- * Atomically modifies the `Synchronized` with the specified function, returning the
- * value immediately before modification.
- */
-export function getAndUpdateIO_<RA, RB, EA, EB, R1, E1, A>(
-  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
-  f: (a: A) => IO<R1, E1, A>,
-  __tsplusTrace?: string,
-): IO<RA | RB | R1, EA | EB | E1, A> {
-  return ref.modifyIO((a) => f(a).map((r) => [a, r]));
-}
-
-/**
- * Atomically modifies the `SRef` with the specified function, returning the
- * value immediately before modification.
- */
-export function getAndUpdateJustIO_<RA, RB, EA, EB, R1, E1, A>(
-  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
-  f: (a: A) => Maybe<IO<R1, E1, A>>,
-  __tsplusTrace?: string,
-): IO<RA | RB | R1, EA | EB | E1, A> {
-  return ref.modifyIO((a) =>
-    f(a)
-      .getOrElse(IO.succeedNow(a))
-      .map((r) => [a, r]),
-  );
-}
-
-/**
- * @tsplus fluent fncts.io.Ref.Synchronized matchIO
- */
-export function matchIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(
-  self: PRef.Synchronized<RA, RB, EA, EB, A, B>,
-  ea: (_: EA) => EC,
-  eb: (_: EB) => ED,
-  ca: (_: C) => IO<RC, EC, A>,
-  bd: (_: B) => IO<RD, ED, D>,
-  __tsplusTrace?: string,
-): PRef.Synchronized<RA | RC, RB | RD, EC, ED, C, D> {
-  return self.matchIO(ea, eb, ca, bd);
-}
-
-/**
- * @tsplus fluent fncts.io.Ref.Synchronized matchAllIO
- */
-export function matchAllIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(
-  self: PRef.Synchronized<RA, RB, EA, EB, A, B>,
-  ea: (_: EA) => EC,
-  eb: (_: EB) => ED,
-  ec: (_: EB) => EC,
-  ca: (_: C) => (_: B) => IO<RC, EC, A>,
-  bd: (_: B) => IO<RD, ED, D>,
-  __tsplusTrace?: string,
-): PRef.Synchronized<RA | RB | RC, RB & RD, EC, ED, C, D> {
-  return self.matchAllIO(ea, eb, ec, ca, bd);
-}
-
-/**
- * @tsplus fluent fncts.io.Ref.Synchronized modifyIO
- */
-export function modifyIO_<RA, RB, EA, EB, A, R1, E1, B>(
-  self: PRef.Synchronized<RA, RB, EA, EB, A, A>,
-  f: (a: A) => IO<R1, E1, readonly [B, A]>,
-  __tsplusTrace?: string,
-): IO<RA | RB | R1, EA | EB | E1, B> {
-  concreteSynchronized(self);
-  return self.withPermit(self.unsafeGet.flatMap(f).flatMap(([b, a]) => self.unsafeSet(a).as(b)));
-}
-
-/**
- * Atomically modifies the `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 `updateJust`.
- *
- * @tsplus fluent fncts.io.Ref.Synchronized modifyJustIO
- */
-export function modifyJustIO_<RA, RB, EA, EB, R1, E1, A, B>(
-  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
-  def: B,
-  f: (a: A) => Maybe<IO<R1, E1, readonly [B, A]>>,
-  __tsplusTrace?: string,
-): IO<RA | RB | R1, EA | EB | E1, B> {
-  return ref.modifyIO((a) => f(a).getOrElse(IO.succeedNow(tuple(def, a))));
-}
-
-/**
- * Atomically modifies the `SRef` with the specified function.
- *
- * @tsplus fluent fncts.io.Ref.Synchronized updateAndGetIO
- */
-export function updateAndGetIO_<RA, RB, EA, EB, R1, E1, A>(
-  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
-  f: (a: A) => IO<R1, E1, A>,
-  __tsplusTrace?: string,
-): IO<RA | RB | R1, E1 | EA | EB, void> {
-  return ref.modifyIO((a) => f(a).map((r) => [r, r])).asUnit;
-}
-
-/**
- * Atomically modifies the `Synchronized` with the specified function.
- *
- * @tsplus fluent fncts.io.Ref.Synchronized updateIO
- */
-export function updateIO_<RA, RB, EA, EB, R1, E1, A>(
-  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
-  f: (a: A) => IO<R1, E1, A>,
-  __tsplusTrace?: string,
-): IO<RA | RB | R1, E1 | EA | EB, void> {
-  return ref.modifyIO((a) => f(a).map((r) => [undefined, r]));
-}
-
-/**
- * Atomically modifies the `SRef` with the specified function.
- *
- * @tsplus fluent fncts.io.Ref.Synchronized updateJustAndGetIO
- */
-export function updateJustAndGetIO_<RA, RB, EA, EB, R1, E1, A>(
-  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
-  f: (a: A) => Maybe<IO<R1, E1, A>>,
-  __tsplusTrace?: string,
-): IO<RA | RB | R1, E1 | EA | EB, A> {
-  return ref.modifyIO((a) =>
-    f(a)
-      .getOrElse(IO.succeedNow(a))
-      .map((r) => [r, r]),
-  );
-}
-
-/**
- * Atomically modifies the `SRef` with the specified function.
- *
- * @tsplus fluent fncts.io.Ref.Synchronized updateJustIO
- */
-export function updateJustIO_<RA, RB, EA, EB, R1, E1, A>(
-  ref: PRef.Synchronized<RA, RB, EA, EB, A, A>,
-  f: (a: A) => Maybe<IO<R1, E1, A>>,
-  __tsplusTrace?: string,
-): IO<RA | RB | R1, E1 | EA | EB, void> {
-  return ref.modifyIO((a) =>
-    f(a)
-      .getOrElse(IO.succeedNow(a))
-      .map((r) => [undefined, r]),
-  );
-}

package/_src/Ref/Synchronized/constructors.ts

@@ -1,12 +0,0 @@
-import { PSynchronizedInternal } from "./definition.js";
-
-/**
- * @tsplus static fncts.io.Ref.SynchronizedOps make
- */
-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 PSynchronizedInternal(new Set([semaphore]), ref.get, (a: A) => ref.set(a));
-  });
-}

package/_src/Ref/Synchronized/definition.ts

@@ -1,126 +0,0 @@
-import type { PRef } from "../definition.js";
-
-import { RefInternal } from "../definition.js";
-
-/**
- * @tsplus type fncts.io.Ref.Synchronized
- */
-export interface PSynchronized<RA, RB, EA, EB, A, B> extends PRef<RA, RB, EA, EB, A, B> {}
-
-/**
- * @tsplus type fncts.io.Ref.SynchronizedOps
- */
-export interface PSynchronizedOps {}
-
-/**
- * @tsplus static fncts.io.RefOps Synchronized
- */
-export const Synchronized: PSynchronizedOps = {};
-
-/**
- * @tsplus type fncts.io.Ref.Synchronized
- */
-export class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInternal<RA, RB, EA, EB, A, B> {
-  readonly _tag = "Synchronized";
-  constructor(
-    readonly semaphores: Set<TSemaphore>,
-    readonly unsafeGet: IO<RB, EB, B>,
-    readonly unsafeSet: (a: A) => IO<RA, EA, void>,
-  ) {
-    super();
-  }
-
-  get get(): IO<RB, EB, B> {
-    if (this.semaphores.size === 1) {
-      return this.unsafeGet;
-    } else {
-      return this.withPermit(this.unsafeGet);
-    }
-  }
-
-  set(a: A, __tsplusTrace?: string): IO<RA, EA, void> {
-    return this.withPermit(this.unsafeSet(a));
-  }
-
-  matchAllIO<RC, RD, EC, ED, C, D>(
-    ea: (_: EA) => EC,
-    eb: (_: EB) => ED,
-    ec: (_: EB) => EC,
-    ca: (_: C) => (_: B) => IO<RC, EC, A>,
-    bd: (_: B) => IO<RD, ED, D>,
-    __tsplusTrace?: string,
-  ): PSynchronizedInternal<RA | RC | RB, RB | RD, EC, ED, C, D> {
-    return new PSynchronizedInternal(
-      this.semaphores,
-      this.get.matchIO((e) => IO.failNow(eb(e)), bd),
-      (c) =>
-        this.get.matchIO(
-          (e) => IO.failNow(ec(e)),
-          (b) => ca(c)(b).flatMap((a) => this.unsafeSet(a).mapError(ea)),
-        ),
-    );
-  }
-
-  matchIO<RC, RD, EC, ED, C, D>(
-    ea: (_: EA) => EC,
-    eb: (_: EB) => ED,
-    ca: (_: C) => IO<RC, EC, A>,
-    bd: (_: B) => IO<RD, ED, D>,
-    __tsplusTrace?: string,
-  ): PSynchronizedInternal<RA | RC, RB | RD, EC, ED, C, D> {
-    return new PSynchronizedInternal(
-      this.semaphores,
-      this.unsafeGet.matchIO((e) => IO.failNow(eb(e)), bd),
-      (c) => ca(c).flatMap((a) => this.unsafeSet(a).mapError(ea)),
-    );
-  }
-
-  match<EC, ED, C, D>(
-    ea: (_: EA) => EC,
-    eb: (_: EB) => ED,
-    ca: (_: C) => Either<EC, A>,
-    bd: (_: B) => Either<ED, D>,
-    __tsplusTrace?: string,
-  ): PSynchronizedInternal<RA, RB, EC, ED, C, D> {
-    return this.matchIO(
-      ea,
-      eb,
-      (c) => IO.fromEitherNow(ca(c)),
-      (b) => IO.fromEitherNow(bd(b)),
-    );
-  }
-
-  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>,
-    __tsplusTrace?: string,
-  ): PSynchronizedInternal<RA, RB, EC, ED, C, D> {
-    return this.matchAllIO(
-      ea,
-      eb,
-      ec,
-      (c) => (b) => IO.fromEitherNow(ca(c)(b)),
-      (b) => IO.fromEitherNow(bd(b)),
-    ) as PSynchronizedInternal<RA, RB, EC, ED, C, D>;
-  }
-
-  withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-    return IO.uninterruptibleMask(({ restore }) =>
-      restore(STM.foreach(this.semaphores, (s) => s.acquire).commit).apSecond(
-        restore(io).ensuring(STM.foreach(this.semaphores, (s) => s.release).commit),
-      ),
-    );
-  }
-}
-
-/**
- * @tsplus macro remove
- */
-export function concreteSynchronized<RA, RB, EA, EB, A, B>(
-  self: PSynchronized<RA, RB, EA, EB, A, B>,
-): asserts self is PSynchronizedInternal<RA, RB, EA, EB, A, B> {
-  //
-}

package/_src/Ref/api/collect.ts

@@ -1,19 +0,0 @@
-import type { PRef } from "../definition.js";
-
-import { identity } from "@fncts/base/data/function";
-
-/**
- * Maps and filters the `get` value of the `Ref` with the specified partial
- * function, returning a `Ref` with a `get` value that succeeds with the
- * result of the partial function if it is defined or else fails with `None`.
- *
- * @tsplus fluent fncts.io.Ref collect
- * @tsplus fluent fncts.io.Ref.Synchronized collect
- */
-export function collect_<RA, RB, EA, EB, A, B, C>(
-  ref: PRef<RA, RB, EA, EB, A, B>,
-  pf: (_: B) => Maybe<C>,
-  __tsplusTrace?: string,
-): PRef<RA, RB, EA, Maybe<EB>, A, C> {
-  return ref.match(identity, Maybe.just, Either.right, (b) => pf(b).toEither(Nothing()));
-}

package/_src/Ref/api/dimap.ts

@@ -1,115 +0,0 @@
-import type { PRef } from "../definition.js";
-
-/**
- * Transforms the `set` value of the `Ref` with the specified function.
- *
- * @tsplus fluent fncts.io.Ref contramap
- * @tsplus fluent fncts.io.Ref.Synchronized contramap
- */
-export function contramap_<RA, RB, EA, EB, B, A, C>(
-  ref: PRef<RA, RB, EA, EB, A, B>,
-  f: (_: C) => A,
-  __tsplusTrace?: string,
-): PRef<RA, RB, EA, EB, C, B> {
-  return ref.contramapEither((c) => Either.right(f(c)));
-}
-
-/**
- * Transforms the `set` value of the `Ref` with the specified fallible
- * function.
- *
- * @tsplus fluent fncts.io.Ref contramapEither
- * @tsplus fluent fncts.io.Ref.Synchronized contramapEither
- */
-export function contramapEither_<RA, RB, EA, EB, A, B, EC, C>(
-  ref: PRef<RA, RB, EA, EB, A, B>,
-  f: (_: C) => Either<EC, A>,
-  __tsplusTrace?: string,
-): PRef<RA, RB, EC | EA, EB, C, B> {
-  return ref.dimapEither(f, Either.right);
-}
-
-/**
- * Transforms both the `set` and `get` values of the `Ref` with the
- * specified functions.
- *
- * @tsplus fluent fncts.io.Ref dimap
- * @tsplus fluent fncts.io.Ref.Synchronized dimap
- */
-export function dimap_<RA, RB, EA, EB, A, B, C, D>(
-  ref: PRef<RA, RB, EA, EB, A, B>,
-  f: (_: C) => A,
-  g: (_: B) => D,
-  __tsplusTrace?: string,
-): PRef<RA, RB, EA, EB, C, D> {
-  return ref.dimapEither(
-    (c) => Either.right(f(c)),
-    (b) => Either.right(g(b)),
-  );
-}
-
-/**
- * Transforms both the `set` and `get` values of the `Ref` with the
- * specified fallible functions.
- *
- * @tsplus fluent fncts.io.Ref dimapEither
- * @tsplus fluent fncts.io.Ref.Synchronized dimapEither
- */
-export function dimapEither_<RA, RB, EA, EB, A, B, C, EC, D, ED>(
-  ref: PRef<RA, RB, EA, EB, A, B>,
-  f: (_: C) => Either<EC, A>,
-  g: (_: B) => Either<ED, D>,
-  __tsplusTrace?: string,
-): PRef<RA, RB, EC | EA, ED | EB, C, D> {
-  return ref.match(
-    (ea: EA | EC) => ea,
-    (eb: EB | ED) => eb,
-    f,
-    g,
-  );
-}
-
-/**
- * Transforms both the `set` and `get` errors of the `Ref` with the
- * specified functions.
- *
- * @tsplus fluent fncts.io.Ref dimapError
- * @tsplus fluent fncts.io.Ref.Synchronized dimapError
- */
-export function dimapError_<RA, RB, EA, EB, A, B, EC, ED>(
-  ref: PRef<RA, RB, EA, EB, A, B>,
-  f: (_: EA) => EC,
-  g: (_: EB) => ED,
-  __tsplusTrace?: string,
-): PRef<RA, RB, EC, ED, A, B> {
-  return ref.match(f, g, Either.right, Either.right);
-}
-
-/**
- * Transforms the `get` value of the `Ref` with the specified fallible
- * function.
- *
- * @tsplus fluent fncts.io.Ref mapEither
- * @tsplus fluent fncts.io.Ref.Synchronized mapEither
- */
-export function mapEither_<RA, RB, EA, EB, A, B, EC, C>(
-  ref: PRef<RA, RB, EA, EB, A, B>,
-  f: (_: B) => Either<EC, C>,
-  __tsplusTrace?: string,
-): PRef<RA, RB, EA, EC | EB, A, C> {
-  return ref.dimapEither(Either.right, f);
-}
-
-/**
- * Transforms the `get` value of the `Ref` with the specified function.
- *
- * @tsplus fluent fncts.io.Ref map
- * @tsplus fluent fncts.io.Ref.Synchronized map
- */
-export function map_<RA, RB, EA, EB, A, B, C>(
-  ref: PRef<RA, RB, EA, EB, A, B>,
-  f: (_: B) => C,
-  __tsplusTrace?: string,
-): PRef<RA, RB, EA, EB, A, C> {
-  return ref.mapEither((b) => Either.right(f(b)));
-}

package/_src/Ref/api/filter.ts

@@ -1,35 +0,0 @@
-import type { PRef } from "../definition.js";
-
-import { identity } from "@fncts/base/data/function";
-
-/**
- * Filters the `set` value of the `Ref` with the specified predicate,
- * returning a `Ref` with a `set` value that succeeds if the predicate is
- * satisfied or else fails with `None`.
- *
- * @tsplus fluent fncts.io.Ref filterInput
- * @tsplus fluent fncts.io.Ref.Synchronized filterInput
- */
-export function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(
-  ref: PRef<RA, RB, EA, EB, A, B>,
-  f: (_: A1) => boolean,
-  __tsplusTrace?: string,
-): PRef<RA, RB, Maybe<EA>, EB, A1, B> {
-  return ref.match(Maybe.just, identity, (a) => (f(a) ? Either.right(a) : Either.left(Nothing())), Either.right);
-}
-
-/**
- * Filters the `get` value of the `Ref` with the specified predicate,
- * returning a `Ref` with a `get` value that succeeds if the predicate is
- * satisfied or else fails with `None`.
- *
- * @tsplus fluent fncts.io.Ref filterOutput
- * @tsplus fluent fncts.io.Ref.Synchronized filterOutput
- */
-export function filterOutput_<RA, RB, EA, EB, A, B>(
-  ref: PRef<RA, RB, EA, EB, A, B>,
-  f: (_: B) => boolean,
-  __tsplusTrace?: string,
-): PRef<RA, RB, EA, Maybe<EB>, A, B> {
-  return ref.match(identity, Maybe.just, Either.right, (b) => (f(b) ? Either.right(b) : Either.left(Nothing())));
-}

package/_src/Ref/api/get.ts

@@ -1,17 +0,0 @@
-import type { PRef } from "../definition.js";
-
-import { concrete } from "../definition.js";
-
-/**
- * Reads the value from the `Ref`.
- *
- * @tsplus getter fncts.io.Ref get
- * @tsplus getter fncts.io.Ref.Synchronized get
- */
-export function get<RA, RB, EA, EB, A, B>(
-  self: PRef<RA, RB, EA, EB, A, B>,
-  __tsplusTrace?: string,
-): IO<RA | RB, EA | EB, B> {
-  concrete(self);
-  return self.get as IO<RA | RB, EA | EB, B>;
-}

package/_src/Ref/api/match.ts

@@ -1,24 +0,0 @@
-import type { PRef } from "../definition.js";
-
-import { concrete } from "../definition.js";
-
-/**
- * Folds over the error and value types of the `Ref`. This is a highly
- * polymorphic method that is capable of arbitrarily transforming the error
- * and value types of the `Ref`. For most use cases one of the more specific
- * combinators implemented in terms of `match` will be more ergonomic but this
- * method is extremely useful for implementing new combinators.
- *
- * @tsplus fluent fncts.io.Ref match
- * @tsplus fluent fncts.io.Ref.Synchronized match
- */
-export function match_<RA, RB, EA, EB, A, B, EC, ED, C, D>(
-  ref: PRef<RA, RB, EA, EB, A, B>,
-  ea: (_: EA) => EC,
-  eb: (_: EB) => ED,
-  ca: (_: C) => Either<EC, A>,
-  bd: (_: B) => Either<ED, D>,
-): PRef<RA, RB, EC, ED, C, D> {
-  concrete(ref);
-  return ref.match(ea, eb, ca, bd as any);
-}

package/_src/Ref/api/matchAll.ts

@@ -1,23 +0,0 @@
-import type { PRef } from "../definition.js";
-
-import { concrete } from "../definition.js";
-
-/**
- * Folds over the error and value types of the `Ref`, allowing access to
- * the state in transforming the `set` value. This is a more powerful version
- * of `match` but requires unifying the error types.
- *
- * @tsplus fluent fncts.io.Ref matchAll
- * @tsplus fluent fncts.io.Ref.Synchronized matchAll
- */
-export function matchAll_<RA, RB, EA, EB, A, B, EC, ED, C, D>(
-  ref: PRef<RA, RB, EA, EB, A, B>,
-  ea: (_: EA) => EC,
-  eb: (_: EB) => ED,
-  ec: (_: EB) => EC,
-  ca: (_: C) => (_: B) => Either<EC, A>,
-  bd: (_: B) => Either<ED, D>,
-): PRef<RA, RB, EC, ED, C, D> {
-  concrete(ref);
-  return ref.matchAll(ea, eb, ec, ca as any, bd as any);
-}