@fncts/io 0.0.17 → 0.0.19

package/_mjs/internal/IsFatal.mjs

@@ -0,0 +1,104 @@
+export const IsFatalTypeId = /*#__PURE__*/Symbol.for("fncts.io.IsFatal");
+/**
+ * @tsplus type fncts.io.IsFatal
+ * @tsplus companion fncts.io.IsFatalOps
+ */
+
+export class IsFatal {
+  constructor() {
+    this._typeId = IsFatalTypeId;
+  }
+
+  apply(t) {
+    concrete(this);
+
+    switch (this._tag) {
+      case 0
+      /* IsFatalTag.Single */
+      :
+        return this.predicate(t);
+
+      case 1
+      /* IsFatalTag.Empty */
+      :
+        return false;
+
+      case 2
+      /* IsFatalTag.Both */
+      :
+        return this.left.apply(t) || this.right.apply(t);
+    }
+  }
+
+}
+export class Single extends IsFatal {
+  constructor(predicate) {
+    super();
+    this.predicate = predicate;
+    this._tag = 0
+    /* IsFatalTag.Single */
+    ;
+  }
+
+}
+export class Empty extends IsFatal {
+  constructor() {
+    super(...arguments);
+    this._tag = 1
+    /* IsFatalTag.Empty */
+    ;
+  }
+
+}
+export class Both extends IsFatal {
+  constructor(left, right) {
+    super();
+    this.left = left;
+    this.right = right;
+    this._tag = 2
+    /* IsFatalTag.Both */
+    ;
+  }
+
+}
+
+function concrete(u) {//
+}
+/**
+ * @tsplus static fncts.io.IsFatalOps empty
+ */
+
+
+export const empty = /*#__PURE__*/new Empty();
+/**
+ * @tsplus static fncts.io.IsFatalOps __call
+ */
+
+export function makeIsFatal(predicate) {
+  return new Single(predicate);
+}
+/**
+ * @tsplus static fncts.io.IsFatalOps both
+ * @tsplus fluent fncts.io.IsFatal both
+ * @tsplus operator fncts.io.IsFatal |
+ */
+
+export function both(left, right) {
+  concrete(left);
+  concrete(right);
+
+  if (left._tag === 1
+  /* IsFatalTag.Empty */
+  ) {
+    return right;
+  }
+
+  if (right._tag === 1
+  /* IsFatalTag.Empty */
+  ) {
+    return left;
+  }
+
+  return new Both(left, right);
+}
+//# sourceMappingURL=IsFatal.mjs.map

package/_mjs/internal/IsFatal.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"IsFatal.mjs","mappings":"AAMA,OAAO,MAAMA,aAAa,gBAAGC,MAAM,CAACC,GAAP,CAAW,kBAAX,CAAtB;AAGP;;;;;AAIA,OAAM,MAAgBC,OAAhB,CAAuB;EAA7BC;IACW,eAAyBJ,aAAzB;EAaV;;EAXCK,KAAK,CAACC,CAAD,EAAW;IACdC,QAAQ,CAAC,IAAD,CAAR;;IACA,QAAQ,KAAKC,IAAb;MACE;MAAA;MAAA;QACE,OAAO,KAAKC,SAAL,CAAeH,CAAf,CAAP;;MACF;MAAA;MAAA;QACE,OAAO,KAAP;;MACF;MAAA;MAAA;QACE,OAAO,KAAKI,IAAL,CAAUL,KAAV,CAAgBC,CAAhB,KAAsB,KAAKK,KAAL,CAAWN,KAAX,CAAiBC,CAAjB,CAA7B;IANJ;EAQD;;AAb0B;AAgB7B,OAAM,MAAOM,MAAP,SAAsBT,OAAtB,CAA6B;EAEjCC,YAAqBK,SAArB,EAAkD;IAChD;IADmB;IADZ,YAAI;IAAA;IAAJ;EAGR;;AAJgC;AAOnC,OAAM,MAAOI,KAAP,SAAqBV,OAArB,CAA4B;EAAlCC;;IACW,YAAI;IAAA;IAAJ;EACV;;AAFiC;AAIlC,OAAM,MAAOU,IAAP,SAAoBX,OAApB,CAA2B;EAE/BC,YAAqBM,IAArB,EAA6CC,KAA7C,EAA2D;IACzD;IADmB;IAAwB;IADpC,YAAI;IAAA;IAAJ;EAGR;;AAJ8B;;AAOjC,SAASJ,QAAT,CAAkBQ,CAAlB,EAA4B,CAC1B;AACD;AAED;;;;;AAGA,OAAO,MAAMC,KAAK,gBAAY,IAAIH,KAAJ,EAAvB;AAEP;;;;AAGA,OAAM,SAAUI,WAAV,CAAsBR,SAAtB,EAAmD;EACvD,OAAO,IAAIG,MAAJ,CAAWH,SAAX,CAAP;AACD;AAED;;;;;;AAKA,OAAM,SAAUS,IAAV,CAAeR,IAAf,EAA8BC,KAA9B,EAA4C;EAChDJ,QAAQ,CAACG,IAAD,CAAR;EACAH,QAAQ,CAACI,KAAD,CAAR;;EACA,IAAID,IAAI,CAACF,IAAL,KAAS;EAAA;EAAb,EAAoC;IAClC,OAAOG,KAAP;EACD;;EACD,IAAIA,KAAK,CAACH,IAAN,KAAU;EAAA;EAAd,EAAqC;IACnC,OAAOE,IAAP;EACD;;EACD,OAAO,IAAII,IAAJ,CAASJ,IAAT,EAAeC,KAAf,CAAP;AACD","names":["IsFatalTypeId","Symbol","for","IsFatal","constructor","apply","t","concrete","_tag","predicate","left","right","Single","Empty","Both","u","empty","makeIsFatal","both"],"sourceRoot":"","sources":["../../_src/internal/IsFatal.ts"],"sourcesContent":[null]}

package/_src/Clock/definition.ts

@@ -9,5 +9,6 @@ export abstract class Clock {
 
 /**
  * @tsplus static fncts.io.ClockOps Tag
+ * @tsplus implicit
  */
 export const ClockTag = Tag<Clock>("fncts.io.Clock");

package/_src/Fiber/FiberContext.ts

@@ -8,11 +8,10 @@ import { CancellerState } from "@fncts/io/CancellerState";
 import { FiberTypeId, isFiber } from "@fncts/io/Fiber/definition";
 import { FiberState } from "@fncts/io/FiberState";
 import { FiberStatus, FiberStatusTag } from "@fncts/io/FiberStatus";
-import { defaultScheduler } from "@fncts/io/internal/Scheduler";
 import { StackTraceBuilder } from "@fncts/io/internal/StackTraceBuilder";
 import { concrete, IOTag, isIOError } from "@fncts/io/IO/definition";
 
-export type FiberRefLocals = AtomicReference<HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>>;
+export type FiberRefLocals = HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>;
 
 type Erased = IO<any, any, any>;
 type ErasedCont = (a: any) => Erased;
@@ -73,16 +72,15 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
   private asyncEpoch         = 0 | 0;
   private stack              = Stack<Frame>();
   nextIO: Instruction | null = null;
-  private currentSupervisor: Supervisor<any>;
 
   constructor(
-    protected readonly fiberId: FiberId.Runtime,
-    private runtimeConfig: RuntimeConfig,
-    private interruptStatus: Stack<boolean>,
-    private fiberRefLocals: FiberRefLocals,
+    readonly fiberId: FiberId.Runtime,
+    public runtimeConfig: RuntimeConfig,
+    public interruptStatus: Stack<boolean>,
+    public fiberRefLocals: FiberRefLocals,
     private readonly _children: Set<FiberContext<unknown, unknown>>,
   ) {
-    this.currentSupervisor = this.runtimeConfig.supervisor;
+    this.unsafeSetRef(FiberRef.currentSupervisor, this.runtimeConfig.supervisor);
   }
 
   get poll() {
@@ -91,7 +89,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
 
   get inheritRefs(): UIO<void> {
     return IO.defer(() => {
-      const childFiberRefLocals = this.fiberRefLocals.get;
+      const childFiberRefLocals = this.fiberRefLocals;
       if (childFiberRefLocals.isEmpty) {
         return IO.unit;
       } else {
@@ -142,6 +140,10 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     });
   }
 
+  get fiberRefs(): FiberRefs {
+    return FiberRefs(this.fiberRefLocals);
+  }
+
   get await(): UIO<Exit<E, A>> {
     return IO.asyncInterrupt((k): Either<UIO<void>, UIO<Exit<E, A>>> => {
       const cb: FiberState.Callback<never, Exit<E, A>> = (x) => k(IO.fromExit(x));
@@ -171,7 +173,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
   }
 
   interruptAs(fiberId: FiberId): UIO<Exit<E, A>> {
-    return this.unsafeInterruptAs(fiberId);
+    return this.interruptAsFork(fiberId).apSecond(this.await);
   }
 
   evalOn(effect: UIO<any>, orElse: UIO<any>): UIO<void> {
@@ -310,24 +312,13 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
                     }
                     break;
                   }
+
                   case IOTag.Match: {
                     this.stack.push(current);
                     current = concrete(current.io);
                     break;
                   }
-                  case IOTag.SetInterrupt: {
-                    const boolFlag = current.flag.toBoolean;
-                    if (this.unsafeIsInterruptible !== boolFlag) {
-                      this.interruptStatus.push(current.flag.toBoolean);
-                      this.unsafeRestoreInterruptStatus();
-                    }
-                    current = concrete(current.io);
-                    break;
-                  }
-                  case IOTag.GetInterrupt: {
-                    current = concrete(current.f(InterruptStatus.fromBoolean(this.unsafeIsInterruptible)));
-                    break;
-                  }
+
                   case IOTag.Async: {
                     const trace = current.trace;
 
@@ -372,10 +363,6 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
                     );
                     break;
                   }
-                  case IOTag.GetDescriptor: {
-                    current = concrete(current.f(this.unsafeGetDescriptor()));
-                    break;
-                  }
                   case IOTag.Yield: {
                     current = null;
                     this.unsafeRunLater(concrete(IO.unit));
@@ -390,47 +377,8 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
                     break;
                   }
 
-                  case IOTag.FiberRefModifyAll: {
-                    const [result, newValue] = current.f(this.fiberId, FiberRefs(this.fiberRefLocals.get));
-                    this.fiberRefLocals.set(newValue.fiberRefLocals);
-                    current = this.unsafeNextEffect(result);
-                    break;
-                  }
-
-                  case IOTag.FiberRefModify: {
-                    const c                  = current;
-                    const [result, newValue] = current.f(this.unsafeGetRef(current.fiberRef));
-                    this.unsafeSetRef(c.fiberRef, newValue);
-                    current = this.unsafeNextEffect(result);
-                    break;
-                  }
-
-                  case IOTag.FiberRefLocally: {
-                    const oldValue = this.unsafeGetRef(current.fiberRef);
-                    const fiberRef = current.fiberRef;
-                    this.unsafeSetRef(fiberRef, current.localValue);
-                    this.unsafeAddFinalizer(
-                      IO.succeed(() => {
-                        this.unsafeSetRef(fiberRef, oldValue);
-                      }),
-                    );
-                    current = concrete(current.io);
-                    break;
-                  }
-
-                  case IOTag.FiberRefDelete: {
-                    this.unsafeDeleteRef(current.fiberRef);
-                    current = this.unsafeNextEffect(undefined);
-                    break;
-                  }
-
-                  case IOTag.FiberRefWith: {
-                    current = concrete(current.f(this.unsafeGetRef(current.fiberRef)));
-                    break;
-                  }
-
-                  case IOTag.GetRuntimeConfig: {
-                    current = concrete(current.f(this.runtimeConfig));
+                  case IOTag.Stateful: {
+                    current = concrete(current.onState(this, this.state.status));
                     break;
                   }
 
@@ -439,39 +387,6 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
                     break;
                   }
 
-                  case IOTag.Supervise: {
-                    const oldSupervisor    = this.currentSupervisor;
-                    this.currentSupervisor = current.supervisor.zip(oldSupervisor);
-                    this.unsafeAddFinalizer(
-                      IO.succeed(() => {
-                        this.currentSupervisor = oldSupervisor;
-                      }),
-                    );
-                    current = concrete(current.io);
-                    break;
-                  }
-
-                  case IOTag.GetForkScope: {
-                    current = concrete(current.f(this.unsafeGetRef(FiberRef.forkScopeOverride).getOrElse(this.scope)));
-                    break;
-                  }
-
-                  case IOTag.OverrideForkScope: {
-                    const oldForkScopeOverride = this.unsafeGetRef(FiberRef.forkScopeOverride);
-                    this.unsafeSetRef(FiberRef.forkScopeOverride, current.forkScope);
-                    this.unsafeAddFinalizer(
-                      IO.succeed(() => {
-                        this.unsafeSetRef(FiberRef.forkScopeOverride, oldForkScopeOverride);
-                      }),
-                    );
-                    current = concrete(current.io);
-                    break;
-                  }
-                  case IOTag.Ensuring: {
-                    this.unsafeAddFinalizer(current.finalizer);
-                    current = concrete(current.io);
-                    break;
-                  }
                   case IOTag.Logged: {
                     this.unsafeLogWith(
                       current.message,
@@ -485,11 +400,6 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
                     current = this.unsafeNextEffect(undefined);
                     break;
                   }
-                  case IOTag.SetRuntimeConfig: {
-                    this.runtimeConfig = current.runtimeConfig;
-                    current            = concrete(IO.unit);
-                    break;
-                  }
                   default: {
                     console.log("Unrecognized Instruction", current);
                     throw new Error("Unrecognized Instruction");
@@ -520,6 +430,8 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
                 current     = concrete(IO.failCauseNow(e.exit.cause, trace));
               }
             }
+          } else if (this.unsafeIsFatal(e)) {
+            this.unsafeHandleFatalError(e);
           } else {
             this.unsafeSetInterrupting(true);
             current = concrete(IO.haltNow(e));
@@ -528,7 +440,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
       }
     } finally {
       currentFiber.set(null);
-      this.currentSupervisor !== Supervisor.none && this.currentSupervisor.unsafeOnSuspend(this);
+      this.currentSupervisor.unsafeOnSuspend(this);
     }
   }
 
@@ -539,19 +451,19 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     });
   }
 
-  private unsafeGetRef<A>(ref: FiberRef<A>): A {
-    return this.fiberRefLocals.get
+  unsafeGetRef<A>(ref: FiberRef<A>): A {
+    return this.fiberRefLocals
       .get(ref)
       .map((_) => _.head[1])
       .getOrElse(ref.initial) as A;
   }
 
   private unsafeGetRefs(fiberRefLocals: FiberRefLocals): HashMap<FiberRef<unknown>, unknown> {
-    return fiberRefLocals.get.map((stack) => stack.head[1]);
+    return fiberRefLocals.map((stack) => stack.head[1]);
   }
 
-  private unsafeSetRef<A>(ref: FiberRef<A>, value: A): void {
-    const oldState = this.fiberRefLocals.get;
+  unsafeSetRef<A>(ref: FiberRef<A>, value: A): void {
+    const oldState = this.fiberRefLocals;
     const oldStack = oldState.get(ref).getOrElse(List.empty<readonly [FiberId.Runtime, unknown]>());
     let newStack: Cons<readonly [FiberId.Runtime, unknown]>;
     if (oldStack.isEmpty()) {
@@ -561,12 +473,12 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     } else {
       newStack = Cons([this.fiberId, value], oldStack);
     }
-    const newState = oldState.set(ref, newStack);
-    this.fiberRefLocals.set(newState);
+    const newState      = oldState.set(ref, newStack);
+    this.fiberRefLocals = newState;
   }
 
-  private unsafeDeleteRef<A>(ref: FiberRef<A>): void {
-    this.fiberRefLocals.set(this.fiberRefLocals.get.remove(ref));
+  unsafeDeleteRef<A>(ref: FiberRef<A>): void {
+    this.fiberRefLocals = this.fiberRefLocals.remove(ref);
   }
 
   unsafePoll() {
@@ -592,7 +504,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     }
   });
 
-  private unsafeAddFinalizer(finalizer: IO<any, never, any>): void {
+  unsafeAddFinalizer(finalizer: IO<any, never, any>): void {
     this.stack.push(
       new Finalizer(finalizer, (v) => {
         this.unsafeDisableInterruption();
@@ -602,7 +514,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     );
   }
 
-  private get unsafeIsInterruptible() {
+  get unsafeIsInterruptible() {
     return this.interruptStatus.hasNext ? this.interruptStatus.peek()! : true;
   }
 
@@ -622,7 +534,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     this.interruptStatus.push(false);
   }
 
-  private unsafeRestoreInterruptStatus(): void {
+  unsafeRestoreInterruptStatus(): void {
     this.stack.push(this.interruptExit);
   }
 
@@ -724,9 +636,9 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     }
   }
 
-  private unsafeInterruptAs(fiberId: FiberId): UIO<Exit<E, A>> {
+  interruptAsFork(fiberId: FiberId): UIO<void> {
     const interruptedCause = Cause.interrupt(fiberId);
-    return IO.defer(() => {
+    return IO(() => {
       const oldState = this.state;
       if (
         this.state._tag === "Executing" &&
@@ -745,7 +657,6 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
         this.state.interruptors.add(fiberId);
         this.state.suppressed = newCause;
       }
-      return this.await;
     });
   }
 
@@ -890,15 +801,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
   ): FiberContext<any, any> {
     const childId = FiberId.unsafeMake(TraceElement.parse(trace));
 
-    const childFiberRefLocals = this.fiberRefLocals.get.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);
-      }
-    });
+    const childFiberRefLocals = this.fiberRefs.forkAs(childId).fiberRefLocals;
 
     const parentScope: FiberScope = forkScope
       .orElse(this.unsafeGetRef(FiberRef.forkScopeOverride))
@@ -910,7 +813,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
       childId,
       this.runtimeConfig,
       Stack.single(this.unsafeIsInterruptible),
-      new AtomicReference(childFiberRefLocals),
+      childFiberRefLocals,
       grandChildren,
     );
 
@@ -958,7 +861,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     }
   }
 
-  private unsafeGetDescriptor() {
+  unsafeGetDescriptor() {
     return new FiberDescriptor(
       this.fiberId,
       this.state.status,
@@ -1056,7 +959,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
       logLevel,
       message,
       Cause.empty(),
-      this.fiberRefLocals.get,
+      this.fiberRefLocals,
       spans,
       annotations,
     );
@@ -1087,7 +990,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
       }
       contextMap = map;
     } else {
-      contextMap = this.fiberRefLocals.get;
+      contextMap = this.fiberRefLocals;
     }
 
     this.runtimeConfig.logger.log(
@@ -1101,4 +1004,16 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
       annotations,
     );
   }
+
+  private unsafeIsFatal(t: unknown): boolean {
+    return this.unsafeGetRef(FiberRef.currentIsFatal).apply(t);
+  }
+
+  private unsafeHandleFatalError(t: unknown): never {
+    return this.unsafeGetRef(FiberRef.currentReportFatal)(t);
+  }
+
+  get currentSupervisor(): Supervisor<any> {
+    return this.unsafeGetRef(FiberRef.currentSupervisor);
+  }
 }

package/_src/Fiber/api/collectAll.ts

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

package/_src/Fiber/api/interruptAll.ts

@@ -3,8 +3,8 @@
  *
  * @tsplus static fncts.io.FiberOps interruptAllAs
  */
-export function interruptAllAs_(fs: Iterable<Fiber<any, any>>, id: FiberId, __tsplusTrace?: string): UIO<void> {
-  return fs.foldLeft(IO.unit, (io, f) => io.flatMap(() => f.interruptAs(id).asUnit));
+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)
 }
 
 /**

package/_src/Fiber/api/interruptAs.ts

@@ -3,5 +3,5 @@
  */
 export function interruptAs<E, A>(self: Fiber<E, A>, fiberId: FiberId, __tsplusTrace?: string): UIO<Exit<E, A>> {
   self.concrete();
-  return self.interruptAs(fiberId);
+  return self.interruptAsFork(fiberId) > self.await;
 }

package/_src/Fiber/api/interruptAsFork.ts

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

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 fiber.interrupt.forkDaemon.asUnit;
+  return IO.descriptorWith(({ id }) => fiber.interruptAsFork(id))
 }

package/_src/Fiber/definition.ts

@@ -40,11 +40,9 @@ export interface FiberCommon<E, A> extends Fiber<E, A> {
   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.
+   * Interrupts the fiber as if interrupted from the specified fiber.
    */
-  readonly interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>;
+  readonly interruptAsFork: (fiberId: FiberId) => UIO<void>;
 
   /**
    * Tentatively observes the fiber, but returns immediately if it is not already done.
@@ -107,7 +105,7 @@ export class SyntheticFiber<E, A> implements FiberCommon<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>>,
+    readonly interruptAsFork: (fiberId: FiberId) => UIO<void>,
   ) {
     this.await = wait;
   }

package/_src/FiberRef/api.ts

@@ -1,13 +1,18 @@
 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);
+  return IO.withFiberContext((fiber) =>
+    IO(() => {
+      const [result, newValue] = f(fiber.unsafeGetRef(self));
+      fiber.unsafeSetRef(self, newValue);
+      return result;
+    }),
+  );
 }
 
 /**
@@ -60,9 +65,19 @@ 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) {
-  return <R1, E1, B>(use: IO<R1, E1, B>): IO<R1, E1, B> => {
-    return new FiberRefLocally(value, fiberRef, use);
-  };
+  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;
+      }),
+    );
 }
 
 /**
@@ -84,14 +99,14 @@ export function getWith_<A, R, E, B>(
   f: (a: A) => IO<R, E, B>,
   __tsplusTrace?: string,
 ): IO<R, E, B> {
-  return new FiberRefWith(fiberRef, f, __tsplusTrace);
+  return IO.withFiberContext((fiber) => f(fiber.unsafeGetRef(fiberRef)));
 }
 
 /**
  * @tsplus getter fncts.io.FiberRef remove
  */
 export function remove<A>(self: FiberRef<A>, __tsplusTrace?: string): UIO<void> {
-  return new FiberRefDelete(self, __tsplusTrace);
+  return IO.withFiberContext((fiber) => IO(fiber.unsafeDeleteRef(self)));
 }
 
 /**
@@ -133,3 +148,11 @@ export function fork<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>): Patc
   concrete(self);
   return self._fork;
 }
+
+/**
+ * @tsplus fluent 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);
+}

package/_src/FiberRef/definition.ts

@@ -33,6 +33,7 @@ export class FiberRefInternal<Value, Patch> extends FiberRef<Value> implements H
     readonly _combine: (first: Patch, second: Patch) => Patch,
     readonly _patch: (patch: Patch) => (oldValue: Value) => Value,
     readonly _fork: Patch,
+    readonly _join: (oldValue: Value, newValue: Value) => Value,
   ) {
     super();
   }