@fncts/io 0.0.24 → 0.0.26

package/_src/FiberRef/operations.ts

@@ -0,0 +1,115 @@
+import { concrete } from "@fncts/io/FiberRef/definition";
+
+/**
+ * @tsplus pipeable fncts.io.FiberRef modify
+ */
+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 pipeable fncts.io.FiberRef update
+ */
+export function update<A>(f: (a: A) => A, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<void> => {
+    return fiberRef.modify((a) => [undefined, f(a)]);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.FiberRef set
+ */
+export function set<A>(a: A, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<void> => {
+    return fiberRef.modify(() => [undefined, a]);
+  };
+}
+
+/**
+ * @tsplus getter fncts.io.FiberRef get
+ */
+export function get<A>(fiberRef: FiberRef<A>, __tsplusTrace?: string): UIO<A> {
+  return fiberRef.modify((a) => [a, a]);
+}
+
+/**
+ * @tsplus pipeable fncts.io.FiberRef getAndSet
+ */
+export function getAndSet<A>(a: A, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<A> => {
+    return fiberRef.modify((v) => [v, a]);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.FiberRef getAndUpdate
+ */
+export function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string) {
+  return (fiberRef: FiberRef<A>): UIO<A> => {
+    return fiberRef.modify((a) => [a, f(a)]);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.FiberRef getAndUpdateJust
+ */
+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)]);
+  };
+}
+
+/**
+ * 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, __tsplusTrace?: string) {
+  return <R1, E1, B>(use: IO<R1, E1, B>): IO<R1, E1, B> =>
+    IO.withFiberRuntime((fiberState) => {
+      const oldValue = fiberState.getFiberRef(fiberRef);
+      fiberState.setFiberRef(fiberRef, value);
+      return use.ensuring(IO.succeed(fiberState.setFiberRef(fiberRef, oldValue)));
+    });
+}
+
+/**
+ * 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, __tsplusTrace?: string) {
+  return <R1, E1, B>(use: IO<R1, E1, B>): IO<R1, E1, B> => self.getWith((a) => self.locally(f(a))(use));
+}
+
+/**
+ * @tsplus pipeable fncts.io.FiberRef getWith
+ */
+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.withFiberRuntime((fiberState) => {
+    fiberState.deleteFiberRef(self);
+    return IO.unit;
+  });
+}

package/_src/FiberRef.ts

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

package/_src/FiberRefs/api.ts

@@ -84,3 +84,75 @@ export function remove(self: FiberRefs, fiberRef: FiberRef<any>): FiberRefs {
 export function unFiberRefs(self: FiberRefs): HashMap<FiberRef<any>, Cons<readonly [FiberId.Runtime, unknown]>> {
   return FiberRefs.reverseGet(self);
 }
+
+/**
+ * @tsplus pipeable fncts.io.FiberRefs join
+ */
+export function join(fiberId: FiberId.Runtime, that: FiberRefs) {
+  return (self: FiberRefs): FiberRefs => {
+    const parentFiberRefs = FiberRefs.reverseGet(self);
+    const childFiberRefs  = FiberRefs.reverseGet(that);
+    const fiberRefLocals  = childFiberRefs.foldLeftWithIndex(parentFiberRefs, (ref, parentFiberRefs, childStack) => {
+      const childValue = childStack.head[1];
+      if (childStack.head[0] == fiberId) {
+        return parentFiberRefs;
+      }
+      return parentFiberRefs.get(ref).match(
+        () => {
+          if (Equatable.strictEquals(childValue, ref.initial)) return parentFiberRefs;
+          return parentFiberRefs.set(ref, Cons([fiberId, childValue] as const));
+        },
+        (parentStack) => {
+          const [ancestor, wasModified] = findAncestor(ref, parentStack, childStack);
+          if (!wasModified) return parentFiberRefs;
+          const patch    = ref.diff(ancestor, childValue);
+          const oldValue = parentStack.head[1];
+          const newValue = ref.join(oldValue, ref.patch(patch)(oldValue));
+          if (oldValue === newValue) return parentFiberRefs;
+          let newStack: Cons<readonly [FiberId.Runtime, unknown]>;
+          if (parentStack.isEmpty()) {
+            newStack = Cons([fiberId, newValue] as const);
+          } else {
+            const [parentFiberId] = parentStack.head;
+            if (parentFiberId == fiberId) {
+              newStack = Cons([parentFiberId, newValue], parentStack.tail);
+            } else {
+              newStack = Cons([fiberId, newValue], parentStack);
+            }
+          }
+          return parentFiberRefs.set(ref, newStack);
+        },
+      );
+    });
+    return FiberRefs.get(fiberRefLocals);
+  };
+}
+
+function compareFiberId(left: FiberId.Runtime, right: FiberId.Runtime): number {
+  const compare = Number.Ord.compare(right.startTime)(left.startTime);
+  return compare === 0 ? Number.Ord.compare(right.id)(left.id) : compare;
+}
+
+/**
+ * @tsplus tailRec
+ */
+function findAncestor(
+  ref: FiberRef<any>,
+  parentStack: List<readonly [FiberId.Runtime, any]>,
+  childStack: List<readonly [FiberId.Runtime, any]>,
+  childModified = false,
+): readonly [any, boolean] {
+  if (parentStack.isNonEmpty() && childStack.isNonEmpty()) {
+    const [parentFiberId]            = parentStack.head;
+    const [childFiberId, childValue] = childStack.head;
+    const compare                    = compareFiberId(parentFiberId, childFiberId);
+    if (compare < 0) {
+      return findAncestor(ref, parentStack, childStack.tail, true);
+    } else if (compare > 0) {
+      return findAncestor(ref, parentStack.tail, childStack, childModified);
+    } else {
+      return [childValue, childModified];
+    }
+  }
+  return [ref.initial, true];
+}

package/_src/FiberRefs.ts

@@ -1,5 +1,4 @@
 // codegen:start { preset: barrel, include: ./FiberRefs/*.ts }
 export * from "./FiberRefs/api.js";
 export * from "./FiberRefs/definition.js";
-export * from "./FiberRefs/join.js";
 // codegen:end

package/_src/Future/api.ts

@@ -49,7 +49,7 @@ export function failCause<E>(cause: Cause<E>, __tsplusTrace?: string) {
  */
 export function fulfill<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string) {
   return (future: Future<E, A>): IO<R, never, boolean> => {
-    return IO.uninterruptibleMask(({ restore }) => restore(io).result.flatMap((exit) => future.done(exit)));
+    return IO.uninterruptibleMask((restore) => restore(io).result.flatMap((exit) => future.done(exit)));
   };
 }
 

package/_src/IO/api/asyncIO.ts

@@ -9,7 +9,7 @@ export function asyncIO<R, E, A>(
     const f = Δ(Future.make<E, A>());
     const r = Δ(IO.runtime<R>());
     const a = Δ(
-      IO.uninterruptibleMask(({ restore }) => {
+      IO.uninterruptibleMask((restore) => {
         const io = register((k) => r.unsafeRunAsync(k.fulfill(f)));
         return restore(io.catchAllCause((cause) => f.failCause(cause))).fork > restore(f.await);
       }),

package/_src/IO/api/bracketExit.ts

@@ -14,7 +14,7 @@ export function bracketExit<R, E, A, E1, R1, A1, R2, E2>(
   release: (a: A, e: Exit<E1, A1>) => IO<R2, E2, any>,
   __tsplusTrace?: string,
 ): IO<R | R1 | R2, E | E1 | E2, A1> {
-  return IO.uninterruptibleMask(({ restore }) =>
+  return IO.uninterruptibleMask((restore) =>
     acquire().flatMap((a) =>
       IO.defer(restore(use(a))).result.flatMap((exit) =>
         IO.defer(release(a, exit)).matchCauseIO(

package/_src/IO/api/daemonChildren.ts

@@ -0,0 +1,6 @@
+/**
+ * @tsplus getter fncts.io.IO daemonChildren
+ */
+export function daemonChildren<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return FiberRef.forkScopeOverride.locally(Just(FiberScope.global))(self);
+}

package/_src/IO/api/disconnect.ts

@@ -0,0 +1,25 @@
+/**
+ * Returns an IO whose interruption will be disconnected from the
+ * fiber's own interruption, being performed in the background without
+ * slowing down the fiber's interruption.
+ *
+ * This method is useful to create "fast interrupting" effects. For
+ * example, if you call this on a bracketed effect, then even if the
+ * effect is "stuck" in acquire or release, its interruption will return
+ * immediately, while the acquire / release are performed in the
+ * background.
+ *
+ * See timeout and race for other applications.
+ *
+ * @tsplus getter fncts.io.IO disconnect
+ */
+export function disconnect<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return IO.uninterruptibleMask((restore) =>
+    IO.fiberId.flatMap((fiberId) =>
+      Do((Δ) => {
+        const fiber = Δ(restore(self).forkDaemon);
+        return Δ(restore(fiber.join).onInterrupt(fiber.interruptAsFork(fiberId)));
+      }),
+    ),
+  );
+}

package/_src/IO/api/foreachConcurrent.ts

@@ -62,7 +62,7 @@ function foreachConcurrentUnboundedDiscard<R, E, A>(
     if (size === 0) {
       return IO.unit;
     }
-    return IO.uninterruptibleMask(({ restore }) => {
+    return IO.uninterruptibleMask((restore) => {
       const future = Future.unsafeMake<void, void>(FiberId.none);
       const ref    = new AtomicNumber(0);
       return IO.transplant((graft) =>

package/_src/IO/api/fork.ts

@@ -55,6 +55,9 @@ export function unsafeFork<R, E, A, E1, B>(
   return fiber;
 }
 
+/**
+ * @tsplus static fncts.io.IOOps unsafeMakeChildFiber
+ */
 export function unsafeMakeChildFiber<R, E, A, E1, B>(
   effect: IO<R, E, A>,
   parentFiber: FiberRuntime<E1, B>,

package/_src/IO/api/forkDaemon.ts

@@ -0,0 +1,12 @@
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
+
+/**
+ * Forks the effect into a new fiber attached to the global scope. Because the
+ * new fiber is attached to the global scope, when the fiber executing the
+ * returned effect terminates, the forked fiber will continue running.
+ *
+ * @tsplus getter fncts.io.IO forkDaemon
+ */
+export function forkDaemon<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, FiberRuntime<E, A>> {
+  return ma.fork.daemonChildren;
+}

package/_src/IO/api/forkIn.ts

@@ -6,7 +6,7 @@
  */
 export function forkIn(scope: Scope, __tsplusTrace?: string) {
   return <R, E, A>(self: IO<R, E, A>): URIO<R, Fiber.Runtime<E, A>> => {
-    return IO.uninterruptibleMask(({ restore }) =>
+    return IO.uninterruptibleMask((restore) =>
       restore(self).forkDaemon.tap((fiber) => scope.addFinalizer(fiber.interrupt)),
     );
   };

package/_src/IO/api/forkScoped.ts

@@ -5,7 +5,5 @@ export function forkScoped<R, E, A>(
   self: IO<R, E, A>,
   __tsplusTrace?: string,
 ): IO<R | Scope, never, Fiber.Runtime<E, A>> {
-  return IO.uninterruptibleMask(({ restore }) =>
-    restore(self).forkDaemon.tap((fiber) => IO.addFinalizer(fiber.interrupt)),
-  );
+  return IO.uninterruptibleMask((restore) => restore(self).forkDaemon.tap((fiber) => IO.addFinalizer(fiber.interrupt)));
 }

package/_src/IO/api/fulfill.ts

@@ -7,6 +7,6 @@
  */
 export function fulfill<E, A>(p: Future<E, A>, __tsplusTrace?: string) {
   return <R>(effect: IO<R, E, A>): IO<R, never, boolean> => {
-    return IO.uninterruptibleMask(({ restore }) => restore(effect).result.flatMap((exit) => p.done(exit)));
+    return IO.uninterruptibleMask((restore) => restore(effect).result.flatMap((exit) => p.done(exit)));
   };
 }

package/_src/IO/api/interrupt.ts

@@ -2,20 +2,11 @@ import { Dynamic, Interruptible, Uninterruptible } from "@fncts/io/IO/definition
 import { RuntimeFlag } from "@fncts/io/RuntimeFlag";
 import { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 
-export interface InterruptibilityRestorer {
-  readonly restore: <R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => IO<R, E, A>;
-  readonly force: <R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => IO<R, E, A>;
-}
+export type InterruptibilityRestorer = <R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => IO<R, E, A>;
 
-const RestoreInterruptible: InterruptibilityRestorer = {
-  restore: (io, __tsplusTrace) => io.interruptible,
-  force: (io, __tsplusTrace) => io.interruptible,
-};
+const RestoreInterruptible: InterruptibilityRestorer = (io, __tsplusTrace) => io.interruptible;
 
-const RestoreUninterruptible: InterruptibilityRestorer = {
-  restore: (io, __tsplusTrace) => io.uninterruptible,
-  force: (io, __tsplusTrace) => io.uninterruptible.disconnect.interruptible,
-};
+const RestoreUninterruptible: InterruptibilityRestorer = (io, __tsplusTrace) => io.uninterruptible;
 
 /**
  * Returns an effect that is interrupted as if by the specified fiber.
@@ -34,22 +25,6 @@ export function interruptAs(fiberId: FiberId, __tsplusTrace?: string): FIO<never
  */
 export const interrupt: IO<never, never, never> = IO.fiberId.flatMap(IO.interruptAs);
 
-// /**
-//  * Switches the interrupt status for this effect. If `true` is used, then the
-//  * effect becomes interruptible (the default), while if `false` is used, then
-//  * the effect becomes uninterruptible. These changes are compositional, so
-//  * they only affect regions of the effect.
-//  *
-//  * @tsplus fluent fncts.io.IO setInterruptStatus
-//  */
-// export function setInterruptStatus_<R, E, A>(
-//   self: IO<R, E, A>,
-//   flag: InterruptStatus,
-//   __tsplusTrace?: string,
-// ): IO<R, E, A> {
-//   return new SetInterrupt(self, flag, __tsplusTrace);
-// }
-
 /**
  * Returns a new effect that performs the same operations as this effect, but
  * interruptibly, even if composed inside of an uninterruptible region.
@@ -101,7 +76,7 @@ export function uninterruptibleMask<R, E, A>(f: (restore: InterruptibilityRestor
  */
 export function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrace?: string) {
   return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E, A> => {
-    return IO.uninterruptibleMask(({ restore }) =>
+    return IO.uninterruptibleMask((restore) =>
       restore(self).matchCauseIO(
         (cause1) =>
           finalizer.matchCauseIO(
@@ -172,7 +147,7 @@ export function onInterruptWith<R1, E1>(
  */
 export function onExit<E, A, R1, E1>(cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>, __tsplusTrace?: string) {
   return <R>(self: IO<R, E, A>): IO<R | R1, E | E1, A> => {
-    return IO.uninterruptibleMask(({ restore }) =>
+    return IO.uninterruptibleMask((restore) =>
       restore(self).matchCauseIO(
         (failure1) => {
           const result = Exit.failCause(failure1);
@@ -189,29 +164,3 @@ export function onExit<E, A, R1, E1>(cleanup: (exit: Exit<E, A>) => IO<R1, E1, a
     );
   };
 }
-
-/**
- * Returns an IO whose interruption will be disconnected from the
- * fiber's own interruption, being performed in the background without
- * slowing down the fiber's interruption.
- *
- * This method is useful to create "fast interrupting" effects. For
- * example, if you call this on a bracketed effect, then even if the
- * effect is "stuck" in acquire or release, its interruption will return
- * immediately, while the acquire / release are performed in the
- * background.
- *
- * See timeout and race for other applications.
- *
- * @tsplus getter fncts.io.IO disconnect
- */
-export function disconnect<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return uninterruptibleMask(({ restore }) =>
-    IO.fiberId.flatMap((fiberId) =>
-      Do((Δ) => {
-        const fiber = Δ(restore(self).forkDaemon);
-        return Δ(restore(fiber.join).onInterrupt(fiber.interruptAsFork(fiberId)));
-      }),
-    ),
-  );
-}

package/_src/IO/api/race.ts

@@ -1,7 +1,3 @@
-function maybeDisconnect<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return IO.uninterruptibleMask((restore) => restore.force(io));
-}
-
 /**
  * Returns an IO that races this effect with the specified effect,
  * returning the first successful `A` from the faster side. If one effect
@@ -14,10 +10,24 @@ function maybeDisconnect<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R
  * @tsplus pipeable fncts.io.IO race
  */
 export function race<R1, E1, A1>(that: IO<R1, E1, A1>) {
-  return <R, E, A>(io: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
-    return IO.fiberId.flatMap((id) =>
-      maybeDisconnect(io).raceWith(
-        maybeDisconnect(that),
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
+    return IO.checkInterruptible((status) => disconnect(self, status).raceAwait(disconnect(that, status)));
+  };
+}
+
+function disconnect<R, E, A>(io: IO<R, E, A>, interruptStatus: InterruptStatus, __tsplusTrace?: string): IO<R, E, A> {
+  if (interruptStatus.isInterruptible) return io.disconnect;
+  else return io.uninterruptible.disconnect.interruptible;
+}
+
+/**
+ * @tsplus pipeable fncts.io.IO raceAwait
+ */
+export function raceAwait<R1, E1, A1>(that: IO<R1, E1, A1>) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E | E1, A | A1> => {
+    return IO.fiberIdWith((id) =>
+      self.raceWith(
+        that,
         (exit, right) =>
           exit.match(
             (cause) => right.join.mapErrorCause((c) => Cause.both(cause, c)),

package/_src/IO/api/{core-scope.ts → raceWith.ts}

@@ -2,17 +2,6 @@ import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 
 import { ExitTag } from "@fncts/base/data/Exit";
 import { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
-import { unsafeMakeChildFiber } from "@fncts/io/IO/api/fork";
-
-import { FiberScope } from "../../FiberScope.js";
-import { IO } from "../definition.js";
-
-/**
- * @tsplus getter fncts.io.IO daemonChildren
- */
-export function daemonChildren<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return FiberRef.forkScopeOverride.locally(Just(FiberScope.global))(self);
-}
 
 /**
  * @tsplus pipeable fncts.io.IO raceFibersWith
@@ -40,8 +29,8 @@ export function raceFibersWith<R, E, A, R1, E1, B, R2, E2, C, R3, E3, D>(
       }
 
       const raceIndicator = new AtomicBoolean(true);
-      const leftFiber     = unsafeMakeChildFiber(left, parentState, parentRuntimeFlags, null, __tsplusTrace);
-      const rightFiber    = unsafeMakeChildFiber(right0, parentState, parentRuntimeFlags, null, __tsplusTrace);
+      const leftFiber     = IO.unsafeMakeChildFiber(left, parentState, parentRuntimeFlags, null, __tsplusTrace);
+      const rightFiber    = IO.unsafeMakeChildFiber(right0, parentState, parentRuntimeFlags, null, __tsplusTrace);
       leftFiber.setFiberRef(FiberRef.forkScopeOverride, Just(parentState.scope));
       rightFiber.setFiberRef(FiberRef.forkScopeOverride, Just(parentState.scope));
 
@@ -91,34 +80,3 @@ export function raceWith<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(
     );
   };
 }
-
-export type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
-
-/**
- * Transplants specified effects so that when those effects fork other
- * effects, the forked effects will be governed by the scope of the
- * fiber that executes this effect.
- *
- * This can be used to "graft" deep grandchildren onto a higher-level
- * scope, effectively extending their lifespans into the parent scope.
- *
- * @tsplus static fncts.io.IOOps transplant
- */
-export function transplant<R, E, A>(f: (_: Grafter) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return IO.withFiberRuntime((fiberState) => {
-    const scopeOverride = fiberState.getFiberRef(FiberRef.forkScopeOverride);
-    const scope         = scopeOverride.getOrElse(fiberState.scope);
-    return f(FiberRef.forkScopeOverride.locally(Just(scope)));
-  });
-}
-
-/**
- * Forks the effect into a new fiber attached to the global scope. Because the
- * new fiber is attached to the global scope, when the fiber executing the
- * returned effect terminates, the forked fiber will continue running.
- *
- * @tsplus getter fncts.io.IO forkDaemon
- */
-export function forkDaemon<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, FiberRuntime<E, A>> {
-  return ma.fork.daemonChildren;
-}

package/_src/IO/api/transplant.ts

@@ -0,0 +1,19 @@
+export type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
+
+/**
+ * Transplants specified effects so that when those effects fork other
+ * effects, the forked effects will be governed by the scope of the
+ * fiber that executes this effect.
+ *
+ * This can be used to "graft" deep grandchildren onto a higher-level
+ * scope, effectively extending their lifespans into the parent scope.
+ *
+ * @tsplus static fncts.io.IOOps transplant
+ */
+export function transplant<R, E, A>(f: (_: Grafter) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return IO.withFiberRuntime((fiberState) => {
+    const scopeOverride = fiberState.getFiberRef(FiberRef.forkScopeOverride);
+    const scope         = scopeOverride.getOrElse(fiberState.scope);
+    return f(FiberRef.forkScopeOverride.locally(Just(scope)));
+  });
+}

package/_src/IO/api/whenFiberRef.ts

@@ -0,0 +1,9 @@
+/**
+ * @tsplus pipeable fncts.io.IO whenFiberRef
+ * @tsplus static fncts.io.IOOps whenFiberRef
+ */
+export function whenFiberRef<S>(ref: FiberRef<S>, f: Predicate<S>, __tsplusTrace?: string) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R, E, Maybe<A>> => {
+    return self.whenIO(ref.get.map(f));
+  };
+}

package/_src/IO/api/whenRef.ts

@@ -0,0 +1,9 @@
+/**
+ * @tsplus pipeable fncts.io.IO whenRef
+ * @tsplus static fncts.io.IOOps whenRef
+ */
+export function whenRef<S>(ref: Ref<S>, f: Predicate<S>) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R, E, Maybe<A>> => {
+    return self.whenIO(ref.get.map(f));
+  };
+}