import * as Deferred from "effect/Deferred";
import * as Effect from "effect/Effect";
import * as Fiber from "effect/Fiber";
import * as Scope from "effect/Scope";
/**
* A lazily evaluated, memoized effect whose computation runs in a fiber of
* its own, owned by `scope`.
*
* `Effect.cached` evaluates on the fiber of whichever caller gets there
* first. When that caller is interrupted while others are waiting — a
* concurrent plan cancelling sibling diffs — every waiter fails
* interrupt-only and the cache stays poisoned for the rest of the process.
* A computation that many fibers share must not have that failure mode: here
* it runs detached from every caller, so interrupting a waiter never touches
* it, and only closing `scope` cancels it (its waiters then see the
* interruption, as they should).
*
* Requirements are captured from the first caller, exactly as
* `Effect.cached` does.
*/
export const cachedInScope =
(scope: Scope.Scope) =>
(effect: Effect.Effect): Effect.Effect, never, R> =>
Effect.gen(function* () {
const context = yield* Effect.context();
const deferred = yield* Deferred.make();
let started = false;
return Effect.suspend(() => {
if (started) return Deferred.await(deferred);
started = true;
return effect.pipe(
Effect.provideContext(context),
// `onExit` also runs on interruption, so the waiters always learn
// how the computation ended.
Effect.onExit((exit) => Deferred.done(deferred, exit)),
// Not a child of the caller: the caller's interruption must not
// reach it. The scope owns its lifetime instead.
Effect.forkDetach,
Effect.flatMap((fiber) => Scope.addFinalizer(scope, Fiber.interrupt(fiber))),
Effect.andThen(Deferred.await(deferred)),
);
});
});