@fncts/io 0.0.20 → 0.0.22

package/_src/Fiber/api/awaitAll.ts

@@ -4,5 +4,5 @@
  * @tsplus static fncts.io.FiberOps awaitAll
  */
 export function awaitAll<E, A>(as: Iterable<Fiber<E, A>>, __tsplusTrace?: string): IO<never, never, Exit<E, Conc<A>>> {
-  return IO.foreachC(as, (f) => f.await.flatMap(IO.fromExitNow)).result;
+  return IO.foreachConcurrent(as, (f) => f.await.flatMap(IO.fromExitNow)).result;
 }

package/_src/Fiber/api/collectAll.ts

@@ -13,7 +13,7 @@ export function sequenceIterable<E, 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.foreachConcurrent(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) =>
@@ -27,6 +27,6 @@ export function sequenceIterable<E, A>(
         ),
       ),
     ),
-    (fiberId) => IO.foreachDiscard(fibers, (fiber) => fiber.interruptAsFork(fiberId))
+    (fiberId) => IO.foreach(fibers, (fiber) => fiber.interruptAsFork(fiberId)),
   );
 }

package/_src/Fiber/api/inheritRefs.ts

@@ -3,5 +3,5 @@
  */
 export function inheritRefs<E, A>(fiber: Fiber<E, A>, __tsplusTrace?: string): UIO<void> {
   fiber.concrete();
-  return fiber.inheritRefs;
+  return fiber.inheritAll;
 }

package/_src/Fiber/api/interrupt.ts

@@ -5,7 +5,6 @@
  *
  * @tsplus getter fncts.io.Fiber interrupt
  */
-export function interrupt<E, A>(fiber: Fiber<E, A>, __tsplusTrace?: string): UIO<Exit<E, A>> {
-  fiber.concrete();
+export function interrupt<E, A>(fiber: Fiber<E, A>): UIO<Exit<E, A>> {
   return IO.fiberId.flatMap((id) => fiber.interruptAs(id));
 }

package/_src/Fiber/api/interruptAll.ts

@@ -4,9 +4,8 @@
  * @tsplus static fncts.io.FiberOps interruptAllAs
  */
 export function interruptAllAs(fs: Iterable<Fiber<any, any>>, id: FiberId, __tsplusTrace?: string): UIO<void> {
-  return IO.foreachDiscard(fs, fiber => fiber.interruptAsFork(id)) > IO.foreachDiscard(fs, fiber => fiber.await)
+  return IO.foreachDiscard(fs, (fiber) => fiber.interruptAsFork(id)) > IO.foreachDiscard(fs, (fiber) => fiber.await);
 }
-
 /**
  * Interrupts all fibers and awaits their interruption
  *

package/_src/Fiber/api/interruptAs.ts

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

package/_src/Fiber/api/interruptFork.ts

@@ -6,5 +6,5 @@
  * @tsplus getter fncts.io.Fiber interruptFork
  */
 export function interruptFork<E, A>(fiber: Fiber<E, A>, __tsplusTrace?: string): UIO<void> {
-  return IO.descriptorWith(({ id }) => fiber.interruptAsFork(id))
+  return IO.fiberId.flatMap((id) => fiber.interruptAsFork(id));
 }

package/_src/Fiber/api/location.ts

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

package/_src/Fiber/api/mapFiber.ts

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

package/_src/Fiber/api/mapIO.ts

@@ -3,33 +3,33 @@ import { SyntheticFiber } from "@fncts/io/Fiber/definition";
 /**
  * Effectfully maps over the value the fiber computes.
  *
- * @tsplus fluent fncts.io.Fiber mapIO
+ * @tsplus pipeable fncts.io.Fiber mapIO
  */
-export function mapIO_<E, E1, A, B>(
-  fiber: Fiber<E, A>,
-  f: (a: A) => FIO<E1, B>,
-  __tsplusTrace?: string,
-): 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)),
+export function mapIO<E1, A, B>(f: (a: A) => FIO<E1, B>, __tsplusTrace?: string) {
+  return <E>(fiber: Fiber<E, A>): 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)),
-  );
+      (id) => fiber.interruptAs(id).flatMap((_) => _.foreachIO(f)),
+    );
+  };
 }
 
 /**
  * Maps over the value the fiber computes.
  *
- * @tsplus fluent fncts.io.Fiber map
+ * @tsplus pipeable fncts.io.Fiber map
  */
-export function map_<E, A, B>(fa: Fiber<E, A>, f: (a: A) => B, __tsplusTrace?: string): Fiber<E, B> {
-  return fa.mapIO((a) => IO.succeedNow(f(a)));
+export function map<A, B>(f: (a: A) => B, __tsplusTrace?: string) {
+  return <E>(fa: Fiber<E, A>): Fiber<E, B> => {
+    return fa.mapIO((a) => IO.succeedNow(f(a)));
+  };
 }

package/_src/Fiber/api/zipWith.ts

@@ -5,22 +5,19 @@ import { SyntheticFiber } from "@fncts/io/Fiber/definition";
  * the specified combiner function. Both joins and interruptions are performed
  * in sequential order from left to right.
  *
- * @tsplus fluent fncts.io.Fiber zipWith
+ * @tsplus pipeable 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,
-  __tsplusTrace?: string,
-): 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)),
-  );
+export function zipWith<A, E1, B, C>(that: Fiber<E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string) {
+  return <E>(self: Fiber<E, A>): Fiber<E | E1, C> => {
+    return new SyntheticFiber(
+      self.id,
+      self.await.flatMap(IO.fromExitNow).zipWithConcurrent(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/definition.ts

@@ -1,4 +1,10 @@
+import type { FiberId } from "@fncts/base/data/FiberId";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 import type { FiberStatus } from "@fncts/io/FiberStatus";
+import type { UIO } from "@fncts/io/IO/definition";
+
+import { IterableWeakMap } from "@fncts/base/collection/weak/IterableWeakMap";
+import { IterableWeakSet } from "@fncts/base/collection/weak/IterableWeakSet";
 
 export const FiberTypeId = Symbol.for("fncts.io.Fiber");
 export type FiberTypeId = typeof FiberTypeId;
@@ -37,10 +43,12 @@ export interface FiberCommon<E, A> extends Fiber<E, A> {
    * Inherits values from all {@link FiberRef} instances into current fiber.
    * This will resume immediately.
    */
-  readonly inheritRefs: UIO<void>;
+  readonly inheritAll: UIO<void>;
 
   /**
-   * Interrupts the fiber as if interrupted from the specified fiber.
+   * 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 interruptAsFork: (fiberId: FiberId) => UIO<void>;
 
@@ -66,19 +74,7 @@ export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
   /**
    * 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>;
+  readonly location?: string;
 
   /**
    * The status of the fiber.
@@ -103,7 +99,7 @@ export class SyntheticFiber<E, A> implements FiberCommon<E, A> {
     readonly id: FiberId,
     wait: UIO<Exit<E, A>>,
     readonly children: UIO<Conc<Fiber.Runtime<any, any>>>,
-    readonly inheritRefs: UIO<void>,
+    readonly inheritAll: UIO<void>,
     readonly poll: UIO<Maybe<Exit<E, A>>>,
     readonly interruptAsFork: (fiberId: FiberId) => UIO<void>,
   ) {
@@ -124,3 +120,8 @@ export function concrete<E, A>(_fiber: Fiber<E, A>): asserts _fiber is ConcreteF
 export function isFiber(u: unknown): u is Fiber<unknown, unknown> {
   return hasTypeId(u, FiberTypeId);
 }
+
+/**
+ * @tsplus static fncts.io.FiberOps _roots
+ */
+export const _roots: IterableWeakSet<FiberRuntime<any, any>> = new IterableWeakSet();

package/_src/Fiber.ts

@@ -1,16 +1,14 @@
 // codegen:start { preset: barrel, include: Fiber/*.ts }
 export * from "./Fiber/constructors.js";
 export * from "./Fiber/definition.js";
-export * from "./Fiber/FiberContext.js";
+export * from "./Fiber/FiberMessage.js";
+export * from "./Fiber/FiberRuntime.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";

package/_src/FiberDescriptor.ts

@@ -1,5 +1,4 @@
 import type { FiberId } from "@fncts/base/data/FiberId";
-import type { FiberScope } from "@fncts/io/FiberScope";
 import type { FiberStatus } from "@fncts/io/FiberStatus";
 
 /**
@@ -9,11 +8,5 @@ import type { FiberStatus } from "@fncts/io/FiberStatus";
  * @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,
-  ) {}
+  constructor(readonly id: FiberId, readonly status: FiberStatus, readonly interruptors: HashSet<FiberId>) {}
 }

package/_src/FiberRef/api/locallyScoped.ts

@@ -1,9 +1,11 @@
 /**
- * @tsplus fluent fncts.io.FiberRef locallyScoped
+ * @tsplus pipeable fncts.io.FiberRef locallyScoped
  */
-export function locallyScoped_<A>(ref: FiberRef<A>, a: A, __tsplusTrace?: string): IO<Scope, never, void> {
-  return IO.acquireRelease(
-    ref.get.flatMap((old) => ref.set(a).as(old)),
-    (a) => ref.set(a),
-  ).asUnit;
+export function locallyScoped<A>(a: A, __tsplusTrace?: string) {
+  return (ref: FiberRef<A>): IO<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

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

package/_src/FiberRef/api.ts

@@ -1,32 +1,37 @@
-import { identity } from "@fncts/base/data/function";
 import { concrete } from "@fncts/io/FiberRef/definition";
 
 /**
- * @tsplus fluent fncts.io.FiberRef modify
+ * @tsplus pipeable 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 IO.withFiberContext((fiber) =>
-    IO(() => {
-      const [result, newValue] = f(fiber.unsafeGetRef(self));
-      fiber.unsafeSetRef(self, newValue);
-      return result;
-    }),
-  );
+export function modify<A, B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string) {
+  return (self: FiberRef<A>): UIO<B> => {
+    concrete(self);
+    return IO.withFiberRuntime((fiber) =>
+      IO(() => {
+        const [result, newValue] = f(fiber.getFiberRef(self));
+        fiber.setFiberRef(self, newValue);
+        return result;
+      }),
+    );
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRef update
+ * @tsplus pipeable 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)]);
+export function update<A>(f: (a: A) => A, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<void> => {
+    return fiberRef.modify((a) => [undefined, f(a)]);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRef set
+ * @tsplus pipeable fncts.io.FiberRef set
  */
-export function set_<A>(fiberRef: FiberRef<A>, a: A, __tsplusTrace?: string): UIO<void> {
-  return fiberRef.modify(() => [undefined, a]);
+export function set<A>(a: A, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<void> => {
+    return fiberRef.modify(() => [undefined, a]);
+  };
 }
 
 /**
@@ -37,24 +42,30 @@ export function get<A>(fiberRef: FiberRef<A>, __tsplusTrace?: string): UIO<A> {
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRef getAndSet
+ * @tsplus pipeable fncts.io.FiberRef getAndSet
  */
-export function getAndSet_<A>(fiberRef: FiberRef<A>, a: A, __tsplusTrace?: string): UIO<A> {
-  return fiberRef.modify((v) => [v, a]);
+export function getAndSet<A>(a: A, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<A> => {
+    return fiberRef.modify((v) => [v, a]);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRef getAndUpdate
+ * @tsplus pipeable fncts.io.FiberRef getAndUpdate
  */
-export function getAndUpdate_<A>(fiberRef: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): UIO<A> {
-  return fiberRef.modify((a) => [a, f(a)]);
+export function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<A> => {
+    return fiberRef.modify((a) => [a, f(a)]);
+  };
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRef getAndUpdateJust
+ * @tsplus pipeable fncts.io.FiberRef getAndUpdateJust
  */
-export function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<A> {
-  return fiberRef.modify((a) => [a, f(a).getOrElse(a)]);
+export function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<A> => {
+    return fiberRef.modify((a) => [a, f(a).getOrElse(a)]);
+  };
 }
 
 /**
@@ -64,20 +75,13 @@ export function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) => Maybe<A
  *
  * @tsplus fluent fncts.io.FiberRef locally
  */
-export function locally_<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: string) {
+export function locally<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: string) {
   return <R1, E1, B>(use: IO<R1, E1, B>): IO<R1, E1, B> =>
-    IO.withFiberContext((fiber) =>
-      IO.defer(() => {
-        const oldValue = fiber.unsafeGetRef(fiberRef);
-        fiber.unsafeSetRef(fiberRef, value);
-        fiber.unsafeAddFinalizer(
-          IO(() => {
-            fiber.unsafeSetRef(fiberRef, oldValue);
-          }),
-        );
-        return use;
-      }),
-    );
+    IO.withFiberRuntime((fiberState) => {
+      const oldValue = fiberState.getFiberRef(fiberRef);
+      fiberState.setFiberRef(fiberRef, value);
+      return use.ensuring(IO.succeed(fiberState.setFiberRef(fiberRef, oldValue)));
+    });
 }
 
 /**
@@ -87,26 +91,27 @@ export function locally_<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: str
  *
  * @tsplus fluent fncts.io.FiberRef locallyWith
  */
-export function locallyWith_<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string) {
+export function locallyWith<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string) {
   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
+ * @tsplus pipeable 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 IO.withFiberContext((fiber) => f(fiber.unsafeGetRef(fiberRef)));
+export function getWith<A, R, E, B>(f: (a: A) => IO<R, E, B>, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): IO<R, E, B> => {
+    return fiberRef.get.flatMap(f);
+  };
 }
 
 /**
  * @tsplus getter fncts.io.FiberRef remove
  */
 export function remove<A>(self: FiberRef<A>, __tsplusTrace?: string): UIO<void> {
-  return IO.withFiberContext((fiber) => IO(fiber.unsafeDeleteRef(self)));
+  return IO.withFiberRuntime((fiberState) => {
+    fiberState.deleteFiberRef(self);
+    return IO.unit;
+  });
 }
 
 /**
@@ -150,9 +155,11 @@ export function fork<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>): Patc
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRef join
+ * @tsplus pipeable fncts.io.FiberRef join
  */
-export function join<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>, oldValue: Value, newValue: Value): Value {
-  concrete(self);
-  return self._join(oldValue, newValue);
+export function join<Value>(oldValue: Value, newValue: Value) {
+  return <Patch>(self: FiberRef.WithPatch<Value, Patch>): Value => {
+    concrete(self);
+    return self._join(oldValue, newValue);
+  };
 }

package/_src/FiberRef/unsafe.ts

@@ -64,6 +64,11 @@ export const forkScopeOverride = FiberRef.unsafeMake<Maybe<FiberScope>>(
   (parent, _) => parent,
 );
 
+/**
+ * @tsplus static fncts.io.FiberRefOps interruptedCause
+ */
+export const interruptedCause = FiberRef.unsafeMake(Cause.empty<never>(), identity, (parent, _) => parent);
+
 /**
  * @tsplus static fncts.io.FiberRefOps currentEnvironment
  */
@@ -87,7 +92,7 @@ export const currentLogSpan = FiberRef.unsafeMake<List<LogSpan>>(Nil());
 /**
  * @tsplus static fncts.io.FiberRefOps currentLogAnnotations
  */
-export const currentLogAnnotations = FiberRef.unsafeMake<HashMap<string, string>>(HashMap.makeDefault());
+export const currentLogAnnotations = FiberRef.unsafeMake<HashMap<string, string>>(HashMap.empty());
 
 /**
  * @tsplus static fncts.io.FiberRefOps currentScheduler

package/_src/FiberRef.ts

@@ -4,7 +4,6 @@ export * from "./FiberRef/constructors.js";
 export * from "./FiberRef/definition.js";
 export * from "./FiberRef/unsafe.js";
 // codegen:end
-
 // codegen:start { preset: barrel, include: ./FiberRef/api/*.ts }
 export * from "./FiberRef/api/locallyScoped.js";
 export * from "./FiberRef/api/locallyScopedWith.js";

package/_src/FiberRefs/api.ts

@@ -1,31 +1,86 @@
+import { MaybeTag } from "@fncts/base/data/Maybe";
 import { FiberRefs } from "@fncts/io/FiberRefs/definition";
 
 /**
  * @tsplus getter fncts.io.FiberRefs fiberRefs
  */
 export function fiberRefs(self: FiberRefs): HashSet<FiberRef<unknown>> {
-  return self.fiberRefLocals.keySet;
+  return self.unFiberRefs.keySet;
 }
 
 /**
+ * @tsplus macro identity
  * @tsplus static fncts.io.FiberRefsOps __call
  */
 export function make(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>): FiberRefs {
-  return new FiberRefs(fiberRefLocals);
+  return FiberRefs.get(fiberRefLocals);
 }
 
 /**
- * @tsplus fluent fncts.io.FiberRefs forkAs
+ * @tsplus pipeable fncts.io.FiberRefs forkAs
  */
-export function forkAs(self: FiberRefs, childId: FiberId.Runtime): FiberRefs {
-  const childFiberRefLocals = self.fiberRefLocals.mapWithIndex((fiberRef, stack) => {
-    const oldValue = stack.head[1];
-    const newValue = fiberRef.patch(fiberRef.fork)(oldValue);
-    if (oldValue === newValue) {
-      return stack;
-    } else {
-      return Cons([childId, newValue], stack);
-    }
-  });
-  return FiberRefs(childFiberRefLocals);
+export function forkAs(childId: FiberId.Runtime) {
+  return (self: FiberRefs): FiberRefs => {
+    const childFiberRefLocals = self.unFiberRefs.mapWithIndex((fiberRef, stack) => {
+      const oldValue = stack.head[1];
+      const newValue = fiberRef.patch(fiberRef.fork)(oldValue);
+      if (oldValue === newValue) {
+        return stack;
+      } else {
+        return Cons([childId, newValue], stack);
+      }
+    });
+    return FiberRefs(childFiberRefLocals);
+  };
+}
+
+/**
+ * @tsplus fluent fncts.io.FiberRefs get
+ */
+export function get<A>(self: FiberRefs, fiberRef: FiberRef<A>): Maybe<A> {
+  return self.unFiberRefs.get(fiberRef).map((_) => _.head[1] as A);
+}
+
+/**
+ * @tsplus fluent fncts.io.FiberRefs getOrDefault
+ */
+export function getOrDefault<A>(self: FiberRefs, fiberRef: FiberRef<A>): A {
+  const v = self.unFiberRefs.get(fiberRef);
+  Maybe.concrete(v);
+  if (v._tag === MaybeTag.Just) {
+    return v.value.head[1] as A;
+  } else {
+    return fiberRef.initial;
+  }
+}
+
+/**
+ * @tsplus fluent fncts.io.FiberRefs updateAs
+ */
+export function updateAs<A>(self: FiberRefs, fiberId: FiberId.Runtime, fiberRef: FiberRef<A>, value: A): FiberRefs {
+  const oldStack = self.unFiberRefs.get(fiberRef).getOrElse(List.empty<readonly [FiberId.Runtime, unknown]>());
+  let newStack: Cons<readonly [FiberId.Runtime, unknown]>;
+  if (oldStack.isEmpty()) {
+    newStack = Cons([fiberId, value]);
+  } else if (oldStack.head[0] == fiberId) {
+    newStack = Cons([fiberId, value], oldStack.tail);
+  } else {
+    newStack = Cons([fiberId, value], oldStack);
+  }
+  return FiberRefs(self.unFiberRefs.set(fiberRef, newStack));
+}
+
+/**
+ * @tsplus fluent fncts.io.FiberRefs delete
+ */
+export function remove(self: FiberRefs, fiberRef: FiberRef<any>): FiberRefs {
+  return FiberRefs(self.unFiberRefs.remove(fiberRef));
+}
+
+/**
+ * @tsplus getter fncts.io.FiberRefs unFiberRefs
+ * @tsplus macro identity
+ */
+export function unFiberRefs(self: FiberRefs): HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>> {
+  return FiberRefs.reverseGet(self);
 }