@fncts/io 0.0.1

package/_src/Fiber/api/await.ts

@@ -0,0 +1,7 @@
+/**
+ * @tsplus getter fncts.io.Fiber await
+ */
+export function wait<E, A>(fiber: Fiber<E, A>): UIO<Exit<E, A>> {
+  fiber.concrete();
+  return fiber.await;
+}

package/_src/Fiber/api/awaitAll.ts

@@ -0,0 +1,8 @@
+/**
+ * Awaits on all fibers to be completed, successfully or not.
+ *
+ * @tsplus static fncts.io.FiberOps awaitAll
+ */
+export function awaitAll<E, A>(as: Iterable<Fiber<E, A>>): IO<unknown, never, Exit<E, Conc<A>>> {
+  return IO.foreachC(as, (f) => f.await.flatMap(IO.fromExitNow)).result;
+}

package/_src/Fiber/api/children.ts

@@ -0,0 +1,7 @@
+/**
+ * @tsplus getter fncts.io.Fiber children
+ */
+export function children<E, A>(self: Fiber<E, A>): UIO<Conc<Fiber.Runtime<any, any>>> {
+  self.concrete();
+  return self.children;
+}

package/_src/Fiber/api/collectAll.ts

@@ -0,0 +1,32 @@
+import { SyntheticFiber } from "@fncts/io/Fiber/definition";
+
+/**
+ * Collects all fibers into a single fiber producing an in-order list of the
+ * results.
+ *
+ * @tsplus static fncts.io.FiberOps sequenceIterable
+ */
+export function sequenceIterable<E, A>(fibers: Iterable<Fiber<E, A>>): Fiber.Synthetic<E, Conc<A>> {
+  return new SyntheticFiber(
+    fibers.foldLeft(FiberId.none as FiberId, (b, a) => b.combine(a.id)),
+    Fiber.awaitAll(fibers),
+    IO.foreachC(fibers, (fiber) => fiber.children).map((c) => c.flatten),
+    IO.foreachDiscard(fibers, (f) => f.inheritRefs),
+    IO.foreach(fibers, (f) => f.poll).map((exits) =>
+      exits.foldRight(Just(Exit.succeed(Conc.empty()) as Exit<E, Conc<A>>), (a, b) =>
+        a.match(
+          () => Nothing(),
+          (ra) =>
+            b.match(
+              () => Nothing(),
+              (rb) => Just(ra.zipWithCause(rb, (a, as) => as.prepend(a), Cause.both)),
+            ),
+        ),
+      ),
+    ),
+    (fiberId) =>
+      IO.foreach(fibers, (fiber) => fiber.interruptAs(fiberId)).map((exits) =>
+        exits.foldRight(Exit.succeed(Conc.empty()), (a, b) => a.zipWithCause(b, (a, b) => b.append(a), Cause.then)),
+      ),
+  );
+}

package/_src/Fiber/api/evalOn.ts

@@ -0,0 +1,12 @@
+/**
+ * @tsplus fluent fncts.io.Fiber evalOn
+ */
+export function evalOn_<E, A>(fiber: Fiber<E, A>, effect: UIO<any>, orElse: UIO<any>): UIO<void> {
+  fiber.concrete();
+  switch (fiber._tag) {
+    case "RuntimeFiber":
+      return fiber.evalOn(effect, orElse);
+    case "SyntheticFiber":
+      return IO.unit;
+  }
+}

package/_src/Fiber/api/evalOnIO.ts

@@ -0,0 +1,18 @@
+/**
+ * A fully-featured, but much slower version of `evalOn`, which is useful
+ * when environment and error are required.
+ *
+ * @tsplus fluent fncts.io.Fiber evalOnIO
+ */
+export function evalOnIO_<E, A, R1, E1, B, R2, E2, C>(
+  fiber: Fiber<E, A>,
+  effect: IO<R1, E1, B>,
+  orElse: IO<R2, E2, C>,
+): IO<R1 & R2, E1 | E2, B | C> {
+  return Do((Δ) => {
+    const r = Δ(IO.environment<R1 & R2>());
+    const f = Δ(Future.make<E1 | E2, B | C>());
+    Δ(fiber.evalOn(f.fulfill(effect.provideEnvironment(r)), f.fulfill(orElse.provideEnvironment(r))));
+    return Δ(f.await);
+  });
+}

package/_src/Fiber/api/fromIO.ts

@@ -0,0 +1,8 @@
+/**
+ * Lifts an `IO` into a `Fiber`.
+ *
+ * @tsplus static fncts.io.FiberOps fromIO
+ */
+export function fromIO<E, A>(effect: FIO<E, A>): UIO<Fiber<E, A>> {
+  return effect.result.map((exit) => Fiber.done(exit));
+}

package/_src/Fiber/api/id.ts

@@ -0,0 +1,7 @@
+/**
+ * @tsplus getter fncts.io.Fiber id
+ */
+export function id<E, A>(self: Fiber<E, A>): FiberId {
+  self.concrete();
+  return self.id;
+}

package/_src/Fiber/api/inheritRefs.ts

@@ -0,0 +1,7 @@
+/**
+ * @tsplus getter fncts.io.Fiber inheritRefs
+ */
+export function inheritRefs<E, A>(fiber: Fiber<E, A>): UIO<void> {
+  fiber.concrete();
+  return fiber.inheritRefs;
+}

package/_src/Fiber/api/interrupt.ts

@@ -0,0 +1,11 @@
+/**
+ * Interrupts the fiber from whichever fiber is calling this method. If the
+ * fiber has already exited, the returned effect will resume immediately.
+ * Otherwise, the effect will resume when the fiber exits.
+ *
+ * @tsplus getter fncts.io.Fiber interrupt
+ */
+export function interrupt<E, A>(fiber: Fiber<E, A>): UIO<Exit<E, A>> {
+  fiber.concrete();
+  return IO.fiberId.flatMap((id) => fiber.interruptAs(id));
+}

package/_src/Fiber/api/interruptAll.ts

@@ -0,0 +1,17 @@
+/**
+ * Interrupts all fibers as by the specified fiber, awaiting their interruption.
+ *
+ * @tsplus static fncts.io.FiberOps interruptAllAs
+ */
+export function interruptAllAs_(fs: Iterable<Fiber<any, any>>, id: FiberId): UIO<void> {
+  return fs.foldLeft(IO.unit, (io, f) => io.flatMap(() => f.interruptAs(id).asUnit));
+}
+
+/**
+ * Interrupts all fibers and awaits their interruption
+ *
+ * @tsplus static fncts.io.FiberOps interruptAll
+ */
+export function interruptAll(fs: Iterable<Fiber<any, any>>): UIO<void> {
+  return IO.fiberId.flatMap((id) => Fiber.interruptAllAs(fs, id));
+}

package/_src/Fiber/api/interruptAs.ts

@@ -0,0 +1,7 @@
+/**
+ * @tsplus fluent fncts.io.Fiber interruptAs
+ */
+export function interruptAs<E, A>(self: Fiber<E, A>, fiberId: FiberId): UIO<Exit<E, A>> {
+  self.concrete();
+  return self.interruptAs(fiberId);
+}

package/_src/Fiber/api/interruptFork.ts

@@ -0,0 +1,10 @@
+/**
+ * Interrupts the fiber from whichever fiber is calling this method. The
+ * interruption will happen in a separate daemon fiber, and the returned
+ * effect will always resume immediately without waiting.
+ *
+ * @tsplus getter fncts.io.Fiber interruptFork
+ */
+export function interruptFork<E, A>(fiber: Fiber<E, A>): UIO<void> {
+  return fiber.interrupt.forkDaemon.asUnit;
+}

package/_src/Fiber/api/join.ts

@@ -0,0 +1,13 @@
+/**
+ * Joins the fiber, which suspends the joining fiber until the result of the
+ * fiber has been determined. Attempting to join a fiber that has erred will
+ * result in a catchable error. Joining an interrupted fiber will result in an
+ * "inner interruption" of this fiber, unlike interruption triggered by another
+ * fiber, "inner interruption" can be caught and recovered.
+ *
+ * @tsplus getter fncts.io.Fiber join
+ */
+export function join<E, A>(fiber: Fiber<E, A>): FIO<E, A> {
+  fiber.concrete();
+  return fiber.await.flatMap(IO.fromExitNow).tap(() => fiber.inheritRefs);
+}

package/_src/Fiber/api/joinAll.ts

@@ -0,0 +1,12 @@
+/**
+ * Joins all fibers, awaiting their _successful_ completion.
+ * Attempting to join a fiber that has erred will result in
+ * a catchable error, _if_ that error does not result from interruption.
+ *
+ * @tsplus static fncts.io.FiberOps joinAll
+ */
+export function joinAll<E, A>(as: Iterable<Fiber<E, A>>): IO<unknown, E, Conc<A>> {
+  return Fiber.awaitAll(as)
+    .flatMap(IO.fromExitNow)
+    .tap(() => IO.foreach(as, (f) => f.inheritRefs));
+}

package/_src/Fiber/api/location.ts

@@ -0,0 +1,7 @@
+/**
+ * @tsplus getter fncts.io.Fiber location
+ */
+export function location<E, A>(self: Fiber<E, A>): TraceElement {
+  self.concrete();
+  return self._tag === "RuntimeFiber" ? self.location : TraceElement.NoLocation;
+}

package/_src/Fiber/api/mapFiber.ts

@@ -0,0 +1,9 @@
+/**
+ * Passes the success of this fiber to the specified callback, and continues
+ * with the fiber that it returns.
+ *
+ * @tsplus fluent fncts.io.Fiber mapFiber
+ */
+export function mapFiber_<A, E, E1, A1>(fiber: Fiber<E, A>, f: (a: A) => Fiber<E1, A1>): UIO<Fiber<E | E1, A1>> {
+  return fiber.await.map((exit) => exit.match(Fiber.failCause, f));
+}

package/_src/Fiber/api/mapIO.ts

@@ -0,0 +1,31 @@
+import { SyntheticFiber } from "@fncts/io/Fiber/definition";
+
+/**
+ * Effectfully maps over the value the fiber computes.
+ *
+ * @tsplus fluent fncts.io.Fiber mapIO
+ */
+export function mapIO_<E, E1, A, B>(fiber: Fiber<E, A>, f: (a: A) => FIO<E1, B>): Fiber<E | E1, B> {
+  return new SyntheticFiber(
+    fiber.id,
+    fiber.await.flatMap((_) => _.foreachIO(f)),
+    fiber.children,
+    fiber.inheritRefs,
+    fiber.poll.flatMap((_) =>
+      _.match(
+        () => IO.succeedNow(Nothing()),
+        (_) => _.foreachIO(f).map((exit) => Just(exit)),
+      ),
+    ),
+    (id) => fiber.interruptAs(id).flatMap((_) => _.foreachIO(f)),
+  );
+}
+
+/**
+ * Maps over the value the fiber computes.
+ *
+ * @tsplus fluent fncts.io.Fiber map
+ */
+export function map_<E, A, B>(fa: Fiber<E, A>, f: (a: A) => B): Fiber<E, B> {
+  return fa.mapIO((a) => IO.succeedNow(f(a)));
+}

package/_src/Fiber/api/poll.ts

@@ -0,0 +1,7 @@
+/**
+ * @tsplus getter fncts.io.Fiber poll
+ */
+export function poll<E, A>(self: Fiber<E, A>): UIO<Maybe<Exit<E, A>>> {
+  self.concrete();
+  return self.poll;
+}

package/_src/Fiber/api/zipWith.ts

@@ -0,0 +1,25 @@
+import { SyntheticFiber } from "@fncts/io/Fiber/definition";
+
+/**
+ * Zips this fiber with the specified fiber, combining their results using
+ * the specified combiner function. Both joins and interruptions are performed
+ * in sequential order from left to right.
+ *
+ * @tsplus fluent fncts.io.Fiber zipWith
+ */
+export function zipWith_<E, A, E1, B, C>(
+  self: Fiber<E, A>,
+  that: Fiber<E1, B>,
+  f: (a: A, b: B) => C,
+): Fiber<E | E1, C> {
+  return new SyntheticFiber(
+    self.id,
+    self.await.flatMap(IO.fromExitNow).zipWithC(that.await.flatMap(IO.fromExitNow), f).result,
+    self.children,
+    that.inheritRefs > self.inheritRefs,
+    self.poll.zipWith(that.poll, (ma, mb) =>
+      ma.isJust() && mb.isJust() ? Just(ma.value.zipWithCause(mb.value, f, Cause.then)) : Nothing(),
+    ),
+    (id) => self.interruptAs(id).zipWith(that.interruptAs(id), (ea, eb) => ea.zipWithCause(eb, f, Cause.then)),
+  );
+}

package/_src/Fiber/constructors.ts

@@ -0,0 +1,43 @@
+import { SyntheticFiber } from "@fncts/io/Fiber";
+
+/**
+ * @tsplus static fncts.io.FiberOps done
+ */
+export function done<E, A>(exit: Exit<E, A>): Fiber<E, A> {
+  return new SyntheticFiber(
+    FiberId.none,
+    IO.succeedNow(exit),
+    IO.succeedNow(Conc()),
+    IO.unit,
+    IO.succeedNow(Just(exit)),
+    () => IO.succeedNow(exit),
+  );
+}
+
+/**
+ * @tsplus static fncts.io.FiberOps fail
+ */
+export function fail<E>(e: E): Fiber<E, never> {
+  return done(Exit.fail(e));
+}
+
+/**
+ * @tsplus static fncts.io.FiberOps failCause
+ */
+export function failCause<E>(cause: Cause<E>): Fiber<E, never> {
+  return done(Exit.failCause(cause));
+}
+
+/**
+ * @tsplus static fncts.io.FiberOps interruptAs
+ */
+export function interrupted(id: FiberId): Fiber<never, never> {
+  return done(Exit.interrupt(id));
+}
+
+/**
+ * @tsplus static fncts.io.FiberOps succeed
+ */
+export function succeed<A>(a: A): Fiber<never, A> {
+  return done(Exit.succeed(a));
+}

package/_src/Fiber/definition.ts

@@ -0,0 +1,128 @@
+import type { FiberStatus } from "@fncts/io/FiberStatus";
+
+export const FiberTypeId = Symbol.for("fncts.io.Fiber");
+export type FiberTypeId = typeof FiberTypeId;
+
+/**
+ * @tsplus type fncts.io.Fiber
+ */
+export interface Fiber<E, A> {
+  readonly _typeId: FiberTypeId;
+  readonly _E: () => E;
+  readonly _A: () => A;
+}
+
+/**
+ * @tsplus type fncts.io.FiberOps
+ */
+export interface FiberOps {}
+
+export const Fiber: FiberOps = {};
+
+export declare namespace Fiber {
+  export type Runtime<E, A> = RuntimeFiber<E, A>;
+  export type Synthetic<E, A> = SyntheticFiber<E, A>;
+}
+
+export interface FiberCommon<E, A> extends Fiber<E, A> {
+  readonly id: FiberId;
+
+  /**
+   * Awaits the fiber, which suspends the awaiting fiber until the result of the
+   * fiber has been determined.
+   */
+  readonly await: UIO<Exit<E, A>>;
+
+  /**
+   * Inherits values from all {@link FiberRef} instances into current fiber.
+   * This will resume immediately.
+   */
+  readonly inheritRefs: UIO<void>;
+
+  /**
+   * Interrupts the fiber as if interrupted from the specified fiber. If the
+   * fiber has already exited, the returned effect will resume immediately.
+   * Otherwise, the effect will resume when the fiber exits.
+   */
+  readonly interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>;
+
+  /**
+   * Tentatively observes the fiber, but returns immediately if it is not already done.
+   */
+  readonly poll: UIO<Maybe<Exit<E, A>>>;
+
+  /**
+   * Retrieves the immediate children of the fiber.
+   */
+  readonly children: UIO<Conc<Fiber.Runtime<any, any>>>;
+}
+
+export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
+  readonly _tag: "RuntimeFiber";
+
+  /**
+   * The identity of the Fiber
+   */
+  readonly id: FiberId.Runtime;
+
+  /**
+   * The location the fiber was forked from
+   */
+  readonly location: TraceElement;
+
+  /**
+   * Evaluates the specified effect on the fiber. If this is not possible,
+   * because the fiber has already ended life, then the specified alternate
+   * effect will be executed instead.
+   */
+  readonly evalOn: (effect: UIO<any>, orElse: UIO<any>) => UIO<void>;
+
+  readonly evalOnIO: <R1, E1, B, R2, E2, C>(
+    effect: IO<R1, E1, B>,
+    orElse: IO<R2, E2, C>,
+  ) => IO<R1 & R2, E1 | E2, B | C>;
+
+  /**
+   * The status of the fiber.
+   */
+  readonly status: UIO<FiberStatus>;
+
+  /**
+   * The trace of the Fiber
+   */
+  readonly trace: UIO<Trace>;
+}
+
+export class SyntheticFiber<E, A> implements FiberCommon<E, A> {
+  readonly _tag = "SyntheticFiber";
+
+  readonly _typeId: FiberTypeId = FiberTypeId;
+  readonly _E!: () => E;
+  readonly _A!: () => A;
+  readonly await;
+
+  constructor(
+    readonly id: FiberId,
+    wait: UIO<Exit<E, A>>,
+    readonly children: UIO<Conc<Fiber.Runtime<any, any>>>,
+    readonly inheritRefs: UIO<void>,
+    readonly poll: UIO<Maybe<Exit<E, A>>>,
+    readonly interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>,
+  ) {
+    this.await = wait;
+  }
+}
+
+export type ConcreteFiber<E, A> = Fiber.Runtime<E, A> | Fiber.Synthetic<E, A>;
+
+/**
+ * @tsplus fluent fncts.io.Fiber concrete
+ * @tsplus macro remove
+ */
+export function concrete<E, A>(_fiber: Fiber<E, A>): asserts _fiber is ConcreteFiber<E, A> {
+  //
+}
+
+export function isFiber(u: unknown): u is Fiber<unknown, unknown> {
+  return hasTypeId(u, FiberTypeId);
+}

package/_src/Fiber.ts

@@ -0,0 +1,28 @@
+// codegen:start { preset: barrel, include: Fiber/*.ts }
+export * from "./Fiber/constructors.js";
+export * from "./Fiber/definition.js";
+export * from "./Fiber/FiberContext.js";
+// codegen:end
+
+// codegen:start { preset: barrel, include: Fiber/api/*.ts }
+export * from "./Fiber/api/await.js";
+export * from "./Fiber/api/awaitAll.js";
+export * from "./Fiber/api/children.js";
+export * from "./Fiber/api/collectAll.js";
+export * from "./Fiber/api/evalOn.js";
+export * from "./Fiber/api/evalOnIO.js";
+export * from "./Fiber/api/fromIO.js";
+export * from "./Fiber/api/id.js";
+export * from "./Fiber/api/inheritRefs.js";
+export * from "./Fiber/api/interrupt.js";
+export * from "./Fiber/api/interruptAll.js";
+export * from "./Fiber/api/interruptAs.js";
+export * from "./Fiber/api/interruptFork.js";
+export * from "./Fiber/api/join.js";
+export * from "./Fiber/api/joinAll.js";
+export * from "./Fiber/api/location.js";
+export * from "./Fiber/api/mapFiber.js";
+export * from "./Fiber/api/mapIO.js";
+export * from "./Fiber/api/poll.js";
+export * from "./Fiber/api/zipWith.js";
+// codegen:end

package/_src/FiberDescriptor.ts

@@ -0,0 +1,19 @@
+import type { FiberId } from "@fncts/base/data/FiberId";
+import type { FiberScope } from "@fncts/io/FiberScope";
+import type { FiberStatus } from "@fncts/io/FiberStatus";
+
+/**
+ * A record containing information about a `Fiber`.
+ *
+ * @tsplus type fncts.io.FiberDescriptor
+ * @tsplus companion fncts.io.FiberDescriptorOps
+ */
+export class FiberDescriptor {
+  constructor(
+    readonly id: FiberId,
+    readonly status: FiberStatus,
+    readonly interruptors: ReadonlySet<FiberId>,
+    readonly interruptStatus: InterruptStatus,
+    readonly scope: FiberScope,
+  ) {}
+}

package/_src/FiberRef/api/locallyScoped.ts

@@ -0,0 +1,9 @@
+/**
+ * @tsplus fluent fncts.io.FiberRef locallyScoped
+ */
+export function locallyScoped_<A>(ref: FiberRef<A>, a: A): IO<Has<Scope>, never, void> {
+  return IO.acquireRelease(
+    ref.get.flatMap((old) => ref.set(a).as(old)),
+    (a) => ref.set(a),
+  ).asUnit;
+}

package/_src/FiberRef/api/locallyScopedWith.ts

@@ -0,0 +1,6 @@
+/**
+ * @tsplus fluent fncts.io.FiberRef locallyScopedWith
+ */
+export function locallyScopedWith<A>(self: FiberRef<A>, f: (a: A) => A): IO<Has<Scope>, never, void> {
+  return self.getWith((a) => self.locallyScoped(f(a)));
+}

package/_src/FiberRef/api.ts

@@ -0,0 +1,135 @@
+import { identity } from "@fncts/base/data/function";
+import { concrete } from "@fncts/io/FiberRef/definition";
+import { FiberRefDelete, FiberRefLocally, FiberRefModify, FiberRefWith } from "@fncts/io/IO/definition";
+
+/**
+ * @tsplus fluent fncts.io.FiberRef modify
+ */
+export function modify_<A, B>(self: FiberRef<A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string): UIO<B> {
+  concrete(self);
+  return new FiberRefModify(self, f, __tsplusTrace);
+}
+
+/**
+ * @tsplus fluent fncts.io.FiberRef update
+ */
+export function update_<A>(fiberRef: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): UIO<void> {
+  return fiberRef.modify((a) => [undefined, f(a)]);
+}
+
+/**
+ * @tsplus fluent fncts.io.FiberRef set
+ */
+export function set_<A>(fiberRef: FiberRef<A>, a: A): UIO<void> {
+  return fiberRef.modify(() => [undefined, a]);
+}
+
+/**
+ * @tsplus getter fncts.io.FiberRef get
+ */
+export function get<A>(fiberRef: FiberRef<A>): UIO<A> {
+  return fiberRef.modify((a) => [a, a]);
+}
+
+/**
+ * @tsplus fluent fncts.io.FiberRef getAndSet
+ */
+export function getAndSet_<A>(fiberRef: FiberRef<A>, a: A): UIO<A> {
+  return fiberRef.modify((v) => [v, a]);
+}
+
+/**
+ * @tsplus fluent fncts.io.FiberRef getAndUpdate
+ */
+export function getAndUpdate_<A>(fiberRef: FiberRef<A>, f: (a: A) => A): UIO<A> {
+  return fiberRef.modify((a) => [a, f(a)]);
+}
+
+/**
+ * @tsplus fluent fncts.io.FiberRef getAndUpdateJust
+ */
+export function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) => Maybe<A>): UIO<A> {
+  return fiberRef.modify((a) => [a, f(a).getOrElse(a)]);
+}
+
+/**
+ * Returns an `IO` that runs with `value` bound to the current fiber.
+ *
+ * Guarantees that fiber data is properly restored via `bracket`.
+ *
+ * @tsplus fluent fncts.io.FiberRef locally
+ */
+export function locally_<A>(fiberRef: FiberRef<A>, value: A) {
+  return <R1, E1, B>(use: IO<R1, E1, B>): IO<R1, E1, B> => {
+    return new FiberRefLocally(value, fiberRef, use);
+  };
+}
+
+/**
+ * Returns an `IO` that runs with `f` applied to the current fiber.
+ *
+ * Guarantees that fiber data is properly restored via `bracket`.
+ *
+ * @tsplus fluent fncts.io.FiberRef locallyWith
+ */
+export function locallyWith_<A>(self: FiberRef<A>, f: (a: A) => A) {
+  return <R1, E1, B>(use: IO<R1, E1, B>): IO<R1, E1, B> => self.getWith((a) => self.locally(f(a))(use));
+}
+
+/**
+ * @tsplus fluent fncts.io.FiberRef getWith
+ */
+export function getWith_<A, R, E, B>(
+  fiberRef: FiberRef<A>,
+  f: (a: A) => IO<R, E, B>,
+  __tsplusTrace?: string,
+): IO<R, E, B> {
+  return new FiberRefWith(fiberRef, f, __tsplusTrace);
+}
+
+/**
+ * @tsplus getter fncts.io.FiberRef remove
+ */
+export function remove<A>(self: FiberRef<A>, __tsplusTrace?: string): UIO<void> {
+  return new FiberRefDelete(self, __tsplusTrace);
+}
+
+/**
+ * @tsplus getter fncts.io.FiberRef diff
+ */
+export function diff<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>) {
+  concrete(self);
+  return (oldValue: Value, newValue: Value): Patch => self._diff(oldValue, newValue);
+}
+
+/**
+ * @tsplus getter fncts.io.FiberRef initial
+ */
+export function initial<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>): Value {
+  concrete(self);
+  return self._initial;
+}
+
+/**
+ * @tsplus getter fncts.io.FiberRef combine
+ */
+export function combine<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>) {
+  concrete(self);
+  return (first: Patch, second: Patch) => self._combine(first, second);
+}
+
+/**
+ * @tsplus getter fncts.io.FiberRef patch
+ */
+export function patch<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>) {
+  concrete(self);
+  return (patch: Patch) => (oldValue: Value) => self._patch(patch)(oldValue);
+}
+
+/**
+ * @tsplus getter fncts.io.FiberRef fork
+ */
+export function fork<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>): Patch {
+  concrete(self);
+  return self._fork;
+}