@fncts/io 0.0.1

package/_src/IO/api/bracketExit.ts

@@ -0,0 +1,32 @@
+/**
+ * Acquires a resource, uses the resource, and then releases the resource.
+ * Neither the acquisition nor the release will be interrupted, and the
+ * resource is guaranteed to be released, so long as the `acquire` IO
+ * succeeds. If `use` fails, then after release, the returned IO will fail
+ * with the same error.
+ *
+ * @tsplus fluent fncts.io.IO bracketExit
+ * @tsplus static fncts.io.IOOps bracketExit
+ */
+export function bracketExit_<R, E, A, E1, R1, A1, R2, E2>(
+  acquire: Lazy<IO<R, E, A>>,
+  use: (a: A) => IO<R1, E1, A1>,
+  release: (a: A, e: Exit<E1, A1>) => IO<R2, E2, any>,
+): IO<R & R1 & R2, E | E1 | E2, A1> {
+  return IO.uninterruptibleMask(({ restore }) =>
+    acquire().flatMap((a) =>
+      IO.defer(restore(use(a))).result.flatMap((exit) =>
+        IO.defer(release(a, exit)).matchCauseIO(
+          (cause2) =>
+            IO.failCause(
+              exit.match(
+                (cause1) => Cause.then(cause1, cause2),
+                () => cause2,
+              ),
+            ),
+          () => IO.fromExit(exit),
+        ),
+      ),
+    ),
+  );
+}

package/_src/IO/api/clockWith.ts

@@ -0,0 +1,11 @@
+/**
+ * @tsplus static fncts.io.IOOps clockWith
+ */
+export function clockWith<R, E, A>(f: (clock: Clock) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return IOEnv.services.getWith((services) => f(services.get(Clock.Tag)));
+}
+
+/**
+ * @tsplus static fncts.io.IOOps clock
+ */
+export const clock = IO.clockWith(IO.succeedNow);

package/_src/IO/api/concurrency.ts

@@ -0,0 +1,42 @@
+/**
+ * The number of fibers used for concurrent operators.
+ */
+export const Concurrency: FiberRef<Maybe<number>> = FiberRef.unsafeMake(Nothing());
+
+/**
+ * Retrieves the maximum number of fibers for concurrent operators or `Nothing` if
+ * it is unbounded.
+ *
+ * @tsplus static fncts.io.IOOps concurrency
+ */
+export const concurrency: UIO<Maybe<number>> = Concurrency.get;
+
+/**
+ * Retrieves the current maximum number of fibers for concurrent operators and
+ * uses it to run the specified effect.
+ *
+ * @tsplus static fncts.io.IOOps concurrencyWith
+ */
+export function concurrencyWith<R, E, A>(f: (concurrency: Maybe<number>) => IO<R, E, A>): IO<R, E, A> {
+  return Concurrency.getWith(f);
+}
+
+/**
+ * Runs the specified effect with the specified maximum number of fibers for
+ * concurrent operators.
+ *
+ * @tsplus fluent fncts.io.IO withConcurrency
+ */
+export function withConcurrency_<R, E, A>(ma: IO<R, E, A>, n: number): IO<R, E, A> {
+  return IO.defer(Concurrency.locally(Just(n))(ma));
+}
+
+/**
+ * Runs the specified effect with an unbounded maximum number of fibers for
+ * concurrent operators.
+ *
+ * @tsplus getter fncts.io.IO withConcurrencyUnbounded
+ */
+export function withConcurrencyUnbounded<R, E, A>(ma: IO<R, E, A>): IO<R, E, A> {
+  return IO.defer(Concurrency.locally(Nothing())(ma));
+}

package/_src/IO/api/concurrentFinalizers.ts

@@ -0,0 +1,11 @@
+/**
+ * @tsplus getter fncts.io.IO concurrentFinalizers
+ */
+export function concurrentFinalizers<R, E, A>(io: IO<R, E, A>): IO<R & Has<Scope>, E, A> {
+  return Do((Δ) => {
+    const outerScope = Δ(IO.scope);
+    const innerScope = Δ(Scope.concurrent);
+    Δ(outerScope.addFinalizerExit(Finalizer.get((exit) => innerScope.close(exit))));
+    return Δ(innerScope.extend(io));
+  });
+}

package/_src/IO/api/consoleWith.ts

@@ -0,0 +1,13 @@
+import { Console } from "@fncts/io/Console";
+
+/**
+ * @tsplus static fncts.io.IOOps consoleWith
+ */
+export function consoleWith<R, E, A>(f: (console: Console) => IO<R, E, A>): IO<R, E, A> {
+  return IOEnv.services.getWith((services) => f(services.get(Console.Tag)));
+}
+
+/**
+ * @tsplus static fncts.io.IOOps console
+ */
+export const console = IO.consoleWith(IO.succeedNow);

package/_src/IO/api/core-scope.ts

@@ -0,0 +1,138 @@
+import { ExitTag } from "@fncts/base/data/Exit";
+
+import { FiberScope } from "../../FiberScope.js";
+import { Fork, GetForkScope, IO, OverrideForkScope, Race } 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 IO.defer(new OverrideForkScope(self, Just(FiberScope.global), __tsplusTrace));
+}
+
+/**
+ * Retrieves the scope that will be used to supervise forked effects.
+ *
+ * @tsplus static fncts.io.IOOps forkScope
+ */
+export const forkScope: UIO<FiberScope> = new GetForkScope(IO.succeedNow);
+
+/**
+ * Retrieves the scope that will be used to supervise forked effects.
+ *
+ * @tsplus static fncts.io.IOOps forkScopeWith
+ */
+export function forkScopeWith<R, E, A>(f: (_: FiberScope) => IO<R, E, A>, __tsplusTrace?: string) {
+  return new GetForkScope(f, __tsplusTrace);
+}
+
+export class ForkScopeRestore {
+  constructor(private scope: FiberScope) {}
+
+  readonly restore = <R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> =>
+    new OverrideForkScope(ma, Just(this.scope), __tsplusTrace);
+}
+
+/**
+ * Captures the fork scope, before overriding it with the specified new
+ * scope, passing a function that allows restoring the fork scope to
+ * what it was originally.
+ *
+ * @tsplus static fncts.io.IOOps forkScopeMask
+ */
+export function forkScopeMask_<R, E, A>(
+  newScope: FiberScope,
+  f: (restore: ForkScopeRestore) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
+  return IO.forkScopeWith(
+    (scope) => new OverrideForkScope(f(new ForkScopeRestore(scope)), Just(newScope), __tsplusTrace),
+  );
+}
+
+/**
+ * Returns an effect that races this effect with the specified effect, calling
+ * the specified finisher as soon as one result or the other has been computed.
+ *
+ * @tsplus fluent fncts.io.IO raceWith
+ */
+export function raceWith_<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(
+  left: IO<R, E, A>,
+  right: Lazy<IO<R1, E1, A1>>,
+  leftWins: (exit: Exit<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>,
+  rightWins: (exit: Exit<E1, A1>, fiber: Fiber<E, A>) => IO<R3, E3, A3>,
+  __tsplusTrace?: string,
+): IO<R & R1 & R2 & R3, E2 | E3, A2 | A3> {
+  return IO.defer(
+    () =>
+      new Race(
+        left,
+        right(),
+        (winner, loser) =>
+          winner.await.flatMap((exit) => {
+            switch (exit._tag) {
+              case ExitTag.Success:
+                return winner.inheritRefs.flatMap(() => leftWins(exit, loser));
+              case ExitTag.Failure:
+                return leftWins(exit, loser);
+            }
+          }),
+        (winner, loser) =>
+          winner.await.flatMap((exit) => {
+            switch (exit._tag) {
+              case ExitTag.Success:
+                return winner.inheritRefs.flatMap(() => rightWins(exit, loser));
+              case ExitTag.Failure:
+                return rightWins(exit, loser);
+            }
+          }),
+      ),
+  );
+}
+
+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 forkScopeWith((scope) => f((e) => new OverrideForkScope(e, 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, Fiber.Runtime<E, A>> {
+  return new Fork(ma, Just(FiberScope.global), __tsplusTrace);
+}
+
+/**
+ * Returns a new effect that will utilize the specified scope to supervise
+ * any fibers forked within the original effect.
+ *
+ * @tsplus fluent fncts.io.IO overrideForkScope
+ */
+export function overrideForkScope_<R, E, A>(ma: IO<R, E, A>, scope: FiberScope, __tsplusTrace?: string): IO<R, E, A> {
+  return new OverrideForkScope(ma, Just(scope), __tsplusTrace);
+}
+
+/**
+ * Returns a new effect that will utilize the default scope (fiber scope) to
+ * supervise any fibers forked within the original effect.
+ *
+ * @tsplus getter fncts.io.IO defaultForkScope
+ */
+export function defaultForkScope<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return new OverrideForkScope(ma, Nothing(), __tsplusTrace);
+}

package/_src/IO/api/environment.ts

@@ -0,0 +1,126 @@
+import type * as Intersection from "@fncts/typelevel/Intersection";
+
+/**
+ * Provides some of the environment required to run this `IO`,
+ * leaving the remainder `R0`.
+ *
+ * @tsplus fluent fncts.io.IO contramapEnvironment
+ */
+export function contramapEnvironment_<R0, R, E, A>(
+  self: IO<R, E, A>,
+  f: (r0: Environment<R0>) => Environment<R>,
+  __tsplusTrace?: string,
+): IO<R0, E, A> {
+  return IO.environmentWithIO((r0: Environment<R0>) => self.provideEnvironment(f(r0)));
+}
+
+/**
+ * Accesses the environment provided to an `IO`
+ *
+ * @tsplus static fncts.io.IOOps environment
+ */
+export function environment<R>(__tsplusTrace?: string): URIO<R, Environment<R>> {
+  return IO.defer(FiberRef.currentEnvironment.get as URIO<R, Environment<R>>);
+}
+
+/**
+ * Accesses the environment provided to an `IO`
+ *
+ * @tsplus static fncts.io.IOOps environmentWith
+ */
+export function environmentWith<R, A>(f: (_: Environment<R>) => A, __tsplusTrace?: string): URIO<R, A> {
+  return IO.environment<R>().map(f);
+}
+
+/**
+ * Effectfully accesses the environment provided to an `IO`
+ *
+ * @tsplus static fncts.io.IOOps environmentWithIO
+ */
+export function environmentWithIO<R0, R, E, A>(
+  f: (r: Environment<R0>) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R & R0, E, A> {
+  return IO.environment<R0>().flatMap(f);
+}
+
+/**
+ * Provides all of the environment required to compute a MonadEnv
+ *
+ * Provides the `IO` with its required environment, which eliminates
+ * its dependency on `R`.
+ *
+ * @tsplus fluent fncts.io.IO provideEnvironment
+ */
+export function provideEnvironment_<R, E, A>(self: IO<R, E, A>, r: Environment<R>, __tsplusTrace?: string): FIO<E, A> {
+  return FiberRef.currentEnvironment.locallyWith((_) => _.union(r))(self as FIO<E, A>);
+}
+
+/**
+ * @tsplus fluent fncts.io.IO provideSomeEnvironment
+ */
+export function provideSomeEnvironment_<R, E, A, R0>(
+  self: IO<R, E, A>,
+  environment: Environment<R0>,
+  __tsplusTrace?: string,
+): IO<Intersection.Erase<R, R0>, E, A> {
+  return self.contramapEnvironment((r0) => r0.union(environment));
+}
+
+/**
+ * @tsplus fluent fncts.io.IO provideService
+ */
+export function provideService_<E, A, T>(
+  self: IO<Has<T>, E, A>,
+  service: T,
+  tag: Tag<T>,
+  __tsplusTrace?: string,
+): FIO<E, A> {
+  return self.provideEnvironment(Environment().add(service, tag));
+}
+
+/**
+ * @tsplus fluent fncts.io.IO provideSomeService
+ */
+export function provideSomeService_<R, E, A, T>(
+  self: IO<R, E, A>,
+  service: T,
+  tag: Tag<T>,
+  __tsplusTrace?: string,
+): IO<Intersection.Erase<R, Has<T>>, E, A> {
+  return self.contramapEnvironment((r: Environment<R>) => r.add(service, tag));
+}
+
+/**
+ * @tsplus static fncts.io.IOAspects provideSomeService
+ */
+export function provideSomeService<T>(service: T, tag: Tag<T>, __tsplusTrace?: string) {
+  return <R, E, A>(io: IO<R & Has<T>, E, A>): IO<R, E, A> =>
+    // @ts-expect-error
+    io.provideSomeService(service, tag);
+}
+
+/**
+ * @tsplus static fncts.io.IOOps service
+ */
+export function service<T>(tag: Tag<T>, __tsplusTrace?: string): IO<Has<T>, never, T> {
+  return IO.serviceWithIO(IO.succeedNow, tag);
+}
+
+/**
+ * @tsplus static fncts.io.IOOps serviceWith
+ */
+export function serviceWith<S, A>(f: (service: S) => A, tag: Tag<S>): IO<Has<S>, never, A> {
+  return IO.serviceWithIO((s) => IO.succeedNow(f(s)), tag);
+}
+
+/**
+ * @tsplus static fncts.io.IOOps serviceWithIO
+ */
+export function serviceWithIO<T, R, E, A>(
+  f: (service: T) => IO<R, E, A>,
+  tag: Tag<T>,
+  __tsplusTrace?: string,
+): IO<R & Has<T>, E, A> {
+  return IO.defer(FiberRef.currentEnvironment.get.flatMap((environment) => f(environment.unsafeGet(tag))));
+}

package/_src/IO/api/foreachC.ts

@@ -0,0 +1,178 @@
+import { identity } from "@fncts/base/data/function";
+import { AtomicNumber } from "@fncts/base/internal/AtomicNumber";
+
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` and runs
+ * produced effects in parallel, discarding the results.
+ *
+ * For a sequential version of this method, see `IO.foreachDiscard`.
+ *
+ * Optimized to avoid keeping full tree of effects, so that method could be
+ * able to handle large input sequences.
+ * Behaves almost like this code:
+ *
+ * Additionally, interrupts all effects on any failure.
+ *
+ * @tsplus static fncts.io.IOOps foreachDiscardC
+ * @tsplus fluent fncts.Iterable traverseIODiscardC
+ */
+export function foreachDiscardC_<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E, any>): IO<R, E, void> {
+  return IO.concurrencyWith((conc) =>
+    conc.match(
+      () => foreachConcurrentUnboundedDiscard(as, f),
+      (n) => foreachConcurrentBoundedDiscard(as, n, f),
+    ),
+  );
+}
+
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` in parallel,
+ * and returns the results in a `Conc<B>`.
+ *
+ * For a sequential version of this method, see `IO.foreach`.
+ *
+ * @tsplus static fncts.io.IOOps foreachC
+ * @tsplus fluent fncts.Iterable traverseIOC
+ */
+export function foreachC_<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>> {
+  return IO.concurrencyWith((conc) =>
+    conc.match(
+      () => foreachConcurrentUnbounded(as, f),
+      (n) => foreachConcurrentBounded(as, n, f),
+    ),
+  );
+}
+
+function foreachConcurrentUnboundedDiscard<R, E, A>(as: Iterable<A>, f: (a: A) => IO<R, E, any>): IO<R, E, void> {
+  return IO.defer(() => {
+    const arr  = Array.from(as);
+    const size = arr.length;
+
+    if (size === 0) {
+      return IO.unit;
+    }
+
+    return IO.uninterruptibleMask(({ restore }) => {
+      const future = Future.unsafeMake<void, void>(FiberId.none);
+      const ref    = new AtomicNumber(0);
+
+      return IO.transplant((graft) =>
+        IO.foreach(
+          as,
+          (a) =>
+            graft(
+              restore(IO.defer(f(a))).matchCauseIO(
+                (cause) => future.fail(undefined).apSecond(IO.failCauseNow(cause)),
+                () => {
+                  if (ref.incrementAndGet() === size) {
+                    future.unsafeDone(IO.unit);
+                  }
+                  return IO.unit;
+                },
+              ),
+            ).forkDaemon,
+        ),
+      ).flatMap((fibers) =>
+        restore(future.await).matchCauseIO(
+          (cause) =>
+            foreachConcurrentUnbounded(fibers, (f) => f.interrupt).flatMap((exits) =>
+              Exit.collectAllC(exits).match(
+                () => IO.failCauseNow(cause.stripFailures),
+                (exit) =>
+                  exit.isFailure()
+                    ? IO.failCauseNow(Cause.both(cause.stripFailures, exit.cause))
+                    : IO.failCauseNow(cause.stripFailures),
+              ),
+            ),
+          () => IO.foreachDiscard(fibers, (fiber) => fiber.inheritRefs),
+        ),
+      );
+    });
+  });
+}
+
+function foreachConcurrentUnbounded<R, E, A, B>(as: Iterable<A>, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>> {
+  return IO.succeed<B[]>([])
+    .flatMap((array) =>
+      foreachConcurrentUnboundedDiscard(as.zipWithIndex, ([n, a]) =>
+        IO.defer(f(a)).flatMap((b) =>
+          IO.succeed(() => {
+            array[n] = b;
+          }),
+        ),
+      ).flatMap(() => IO.succeed(array)),
+    )
+    .map(Conc.from);
+}
+
+function foreachConcurrentBoundedDiscardWorker<R, E, A>(queue: Queue<A>, f: (a: A) => IO<R, E, any>): IO<R, E, void> {
+  return queue.poll.flatMap((ma) =>
+    ma.match(
+      () => IO.unit,
+      (a) => f(a).flatMap(() => foreachConcurrentBoundedDiscardWorker(queue, f)),
+    ),
+  );
+}
+
+function foreachConcurrentBoundedDiscard<R, E, A>(
+  as: Iterable<A>,
+  n: number,
+  f: (a: A) => IO<R, E, any>,
+): IO<R, E, void> {
+  return IO.defer(() => {
+    const size =
+      "length" in as && typeof (as as Iterable<A> & { length: unknown })["length"] === "number"
+        ? (as as Iterable<A> & { length: number })["length"]
+        : as.size;
+
+    if (size === 0) {
+      return IO.unit;
+    }
+
+    return Do((Δ) => {
+      const queue = Δ(Queue.makeBounded<A>(size));
+      Δ(queue.offerAll(as));
+      Δ(foreachConcurrentUnboundedDiscard(foreachConcurrentBoundedDiscardWorker(queue, f).replicate(n), identity));
+    });
+  });
+}
+
+function foreachConcurrentBoundedWorker<R, E, A, B>(
+  queue: Queue<readonly [number, A]>,
+  array: Array<any>,
+  f: (a: A) => IO<R, E, B>,
+): IO<R, E, void> {
+  return queue.poll.flatMap((ma) =>
+    ma.match(
+      () => IO.unit,
+      ([n, a]) =>
+        f(a)
+          .tap((b) =>
+            IO.succeed(() => {
+              array[n] = b;
+            }),
+          )
+          .flatMap(() => foreachConcurrentBoundedWorker(queue, array, f)),
+    ),
+  );
+}
+
+function foreachConcurrentBounded<R, E, A, B>(as: Iterable<A>, n: number, f: (a: A) => IO<R, E, B>): IO<R, E, Conc<B>> {
+  return IO.defer(() => {
+    const size =
+      "length" in as && typeof (as as Iterable<A> & { length: unknown })["length"] === "number"
+        ? (as as Iterable<A> & { length: number })["length"]
+        : as.size;
+
+    if (size === 0) {
+      return IO.succeed(Conc.empty());
+    }
+    return Do((Δ) => {
+      const array = Δ(IO.succeed(new Array<B>(size)));
+      const queue = Δ(Queue.makeBounded<readonly [number, A]>(size));
+      Δ(queue.offerAll(as.zipWithIndex));
+      Δ(foreachConcurrentUnboundedDiscard(foreachConcurrentBoundedWorker(queue, array, f).replicate(n), identity));
+      return Conc.from(array);
+    });
+  });
+}

package/_src/IO/api/foreachExec.ts

@@ -0,0 +1,19 @@
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` in parallel,
+ * and returns the results in a new `Conc<B>`.
+ *
+ * For a sequential version of this method, see `foreach`.
+ *
+ * @tsplus static fncts.io.IOOps foreachExec
+ */
+export function foreachExec_<R, E, A, B>(
+  as: Iterable<A>,
+  es: ExecutionStrategy,
+  f: (a: A) => IO<R, E, B>,
+): IO<R, E, Conc<B>> {
+  return es.match(
+    () => IO.foreach(as, f),
+    () => IO.foreachC(as, f).withConcurrencyUnbounded,
+    (fiberBound) => IO.foreachC(as, f).withConcurrency(fiberBound),
+  );
+}

package/_src/IO/api/forkAll.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns an effect that forks all of the specified values, and returns a
+ * composite fiber that produces a list of their results, in order.
+ *
+ * @tsplus static fncts.io.IOOps forkAll
+ */
+export function forkAll<R, E, A>(as: Iterable<IO<R, E, A>>, __tsplusTrace?: string): URIO<R, Fiber<E, Conc<A>>> {
+  return IO.foreach(as, (io) => io.fork).map(Fiber.sequenceIterable);
+}

package/_src/IO/api/forkIn.ts

@@ -0,0 +1,15 @@
+/**
+ * Forks the workflow in the specified scope. The fiber will be interrupted
+ * when the scope is closed.
+ *
+ * @tsplus fluent fncts.io.IO forkIn
+ */
+export function forkIn_<R, E, A>(
+  self: IO<R, E, A>,
+  scope: Scope,
+  __tsplusTrace?: string,
+): URIO<R, Fiber.Runtime<E, A>> {
+  return IO.uninterruptibleMask(({ restore }) =>
+    restore(self).forkDaemon.tap((fiber) => scope.addFinalizer(fiber.interrupt)),
+  );
+}

package/_src/IO/api/forkScoped.ts

@@ -0,0 +1,11 @@
+/**
+ * @tsplus getter fncts.io.IO forkScoped
+ */
+export function forkScoped<R, E, A>(
+  self: IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R & Has<Scope>, never, Fiber.Runtime<E, A>> {
+  return IO.uninterruptibleMask(({ restore }) =>
+    restore(self).forkDaemon.tap((fiber) => IO.addFinalizer(fiber.interrupt)),
+  );
+}

package/_src/IO/api/fulfill.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns an IO that keeps or breaks a promise based on the result of
+ * this effect. Synchronizes interruption, so if this effect is interrupted,
+ * the specified promise will be interrupted, too.
+ *
+ * @tsplus fluent fncts.io.IO fulfill
+ */
+export function fulfill_<R, E, A>(effect: IO<R, E, A>, p: Future<E, A>): IO<R, never, boolean> {
+  return IO.uninterruptibleMask(({ restore }) => restore(effect).result.flatMap((exit) => p.done(exit)));
+}