@typed/fx 0.0.4 → 0.0.8

package/src/Cause/Cause.ts

@@ -85,6 +85,16 @@ export const traced =
   <E>(cause: Cause<E>): Cause<E> =>
     new Traced(cause, trace)
 
+export const isEmpty = <E>(cause: Cause<E>): cause is Empty => cause.tag === Empty.tag
+export const isInterrupted = <E>(cause: Cause<E>): cause is Interrupted =>
+  cause.tag === 'Interrupted'
+export const isUnexpected = <E>(cause: Cause<E>): cause is Unexpected => cause.tag === 'Unexpected'
+export const isExpected = <E>(cause: Cause<E>): cause is Expected<E> => cause.tag === 'Expected'
+export const isSequential = <E>(cause: Cause<E>): cause is Sequential<E, E> =>
+  cause.tag === 'Sequential'
+export const isParallel = <E>(cause: Cause<E>): cause is Parallel<E, E> => cause.tag === 'Parallel'
+export const isTraced = <E>(cause: Cause<E>): cause is Traced<E> => cause.tag === 'Traced'
+
 export const makeParallelAssociative = <E>(): Associative.Associative<Cause<E>> => ({
   concat: (left, right) =>
     left.tag === Empty.tag ? right : right.tag === Empty.tag ? left : new Parallel(left, right),
@@ -423,3 +433,56 @@ export const makeDebug = <E>(renderer: Renderer<E> = defaultRenderer): D.Debug<C
   D.Debug((cause) => prettyPrint(cause, renderer))
 
 export const Debug = makeDebug()
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export const findExpected = find(<E>(_e: E): _e is E => true)
+
+export function findType<T extends Cause<any>['tag']>(tag: T) {
+  return <E>(cause: Cause<E>): Maybe.Maybe<Cause<E>> => {
+    if (cause.tag === tag) {
+      return Maybe.Just(cause)
+    }
+
+    if (cause.tag === 'Sequential') {
+      return pipe(
+        findType(tag)(cause.left),
+        Maybe.match(
+          () => findType(tag)(cause.right),
+          (a) =>
+            pipe(
+              findType(tag)(cause.right),
+              Maybe.match(
+                () => Maybe.Just(a),
+                (b) => Maybe.Just(sequential(a, b)),
+              ),
+            ),
+        ),
+      )
+    }
+
+    if (cause.tag === 'Parallel') {
+      return pipe(
+        findType(tag)(cause.left),
+        Maybe.match(
+          () => findType(tag)(cause.right),
+          (a) =>
+            pipe(
+              findType(tag)(cause.right),
+              Maybe.match(
+                () => Maybe.Just(a),
+                (b) => Maybe.Just(parallel(a, b)),
+              ),
+            ),
+        ),
+      )
+    }
+
+    if (cause.tag === 'Traced') {
+      return findType(tag)(cause.cause)
+    }
+
+    return Maybe.Nothing
+  }
+}
+
+export const findInterrupted = findType('Interrupted')

package/src/Cause/Renderer.ts

@@ -67,7 +67,7 @@ export function renderInterrupted<E>(
 ): Sequential {
   return Sequential([
     Failure([
-      `Interrupted by Fiber ${FiberIdDebug.debug(cause.fiberId)}.`,
+      `Interrupted by ${FiberIdDebug.debug(cause.fiberId)}.`,
       '',
       ...renderTrace(trace, renderer),
     ]),

package/src/Env/Env.ts

@@ -1,14 +1,24 @@
-import { getServiceFromFiberRefs } from '@/FiberRef/builtins.js'
+import { makeEnvFromFiberRefs } from '@/FiberRef/builtins.js'
 import * as FiberRefs from '@/FiberRefs/FiberRefs.js'
 import { Of } from '@/Fx/Fx.js'
 import { Service } from '@/Service/Service.js'
 
+/**
+ * Env is an abstraction over FiberRefs which keeps track of services and joining them back together.
+ */
 export interface Env<R> {
+  readonly fiberRefs: FiberRefs.FiberRefs
   readonly get: <S extends R>(service: Service<S>) => Of<S>
+  readonly addService: <S, I extends S>(service: Service<S>, impl: I) => Env<R | S>
+  readonly join: <S>(other: Env<S>) => Env<R | S>
 }
 
-export function Env<R>(fiberRefs: FiberRefs.FiberRefs): Env<R> {
-  return {
-    get: getServiceFromFiberRefs(fiberRefs),
-  }
+export const Empty = makeEnvFromFiberRefs<never>(FiberRefs.FiberRefs())
+
+export function Env<S, I extends S>(service: Service<S>, impl: I): Env<S> {
+  return Empty.addService(service, impl)
+}
+
+export function fromFiberRefs<R>(fiberRefs: FiberRefs.FiberRefs): Env<R> {
+  return makeEnvFromFiberRefs(fiberRefs)
 }

package/src/Fiber/fromScope.ts

@@ -0,0 +1,19 @@
+import { pipe } from 'hkt-ts'
+
+import { Synthetic } from './Fiber.js'
+
+import { FiberId } from '@/FiberId/FiberId.js'
+import { Closeable, closeOrWait, wait } from '@/Scope/Closeable.js'
+import { Exit, FiberRefs, Fx } from '@/index.js'
+
+export function fromScope(id: FiberId, fiberRefs: FiberRefs.FiberRefs, scope: Closeable) {
+  return Synthetic({
+    id,
+    exit: wait(scope),
+    inheritFiberRefs: pipe(
+      Fx.getFiberRefs,
+      Fx.flatMap((refs) => Fx.fromLazy(() => FiberRefs.join(refs, fiberRefs))),
+    ),
+    interruptAs: (id) => closeOrWait(scope)(Exit.interrupt(id)),
+  })
+}

package/src/FiberRef/builtins.ts

@@ -19,8 +19,7 @@ import { Trace } from '@/Trace/Trace.js'
 export const CurrentEnv = make(
   pipe(
     Fx.getFiberContext,
-    // Always use a snapshot of the FiberRefs to avoid mutability problems.
-    Fx.map((c): Env<any> => ({ get: getServiceFromFiberRefs(c.fiberRefs) })),
+    Fx.map((c) => makeEnvFromFiberRefs(c.fiberRefs)),
   ),
   {
     fork: constant(Nothing), // Always create a new Env for each Fiber.
@@ -28,6 +27,18 @@ export const CurrentEnv = make(
   },
 )
 
+export function makeEnvFromFiberRefs<R>(fiberRefs: FiberRefs.FiberRefs): Env<R> {
+  // Always use a snapshot of the FiberRefs to avoid mutability problems.
+  const forked = FiberRefs.fork(fiberRefs)
+
+  return {
+    fiberRefs: forked,
+    get: getServiceFromFiberRefs(forked),
+    addService: addServiceFromFiberRefs(forked),
+    join: joinEnvFromFiberRefs(forked),
+  }
+}
+
 export const CurrentConcurrencyLevel = make(
   Fx.fromLazy(() => new Semaphore(NonNegativeInteger(Infinity))),
   {
@@ -55,17 +66,26 @@ export const Layers = FiberRef.make(
   },
 )
 
-export const Services = FiberRef.make(Fx.now(ImmutableMap<Service<any>, any>()), {
-  join: identity, // Always keep the parent Fiber's services
-})
+export const Services = FiberRef.make(
+  Fx.fromLazy(() => ImmutableMap<Service<any>, any>()),
+  {
+    join: identity, // Always keep the parent Fiber's services
+  },
+)
 
-export const CurrentLogSpans = FiberRef.make(Fx.now(ImmutableMap<string, LogSpan>()), {
-  join: identity,
-})
+export const CurrentLogSpans = FiberRef.make(
+  Fx.fromLazy(() => ImmutableMap<string, LogSpan>()),
+  {
+    join: identity,
+  },
+)
 
-export const CurrentLogAnnotations = FiberRef.make(Fx.now(ImmutableMap<string, LogAnnotation>()), {
-  join: identity,
-})
+export const CurrentLogAnnotations = FiberRef.make(
+  Fx.fromLazy(() => ImmutableMap<string, LogAnnotation>()),
+  {
+    join: identity,
+  },
+)
 
 export function getServiceFromFiberRefs(fiberRefs: FiberRefs.FiberRefs) {
   return <S>(id: Service<S>): Fx.Of<S> => {
@@ -112,3 +132,35 @@ const getLayerFromFiberRefs = <S>(id: Service<S>, fiberRefs: FiberRefs.FiberRefs
 
     return join(fiber)
   })
+
+export function addServiceFromFiberRefs<R>(fiberRefs: FiberRefs.FiberRefs): Env<R>['addService'] {
+  return (id, impl) => {
+    const forked = fiberRefs.fork()
+
+    // AddService
+    FiberRefs.setFiberRef(
+      Services,
+      pipe(
+        forked,
+        FiberRefs.maybeGetFiberRefValue(Services),
+        Maybe.match(
+          () => ImmutableMap<Service<any>, any>().set(id, impl),
+          (s) => s.set(id, impl),
+        ),
+      ),
+    )(forked)
+
+    return makeEnvFromFiberRefs(forked)
+  }
+}
+
+export function joinEnvFromFiberRefs<R>(fiberRefs: FiberRefs.FiberRefs): Env<R>['join'] {
+  return (other) => {
+    const forked = other.fiberRefs.fork()
+
+    // Reverse the order to ensure incoming values take precedence for Services + Layers
+    FiberRefs.join(forked, fiberRefs)
+
+    return makeEnvFromFiberRefs(forked)
+  }
+}

package/src/FiberRuntime/FiberRuntime.ts

@@ -119,6 +119,11 @@ export class FiberRuntime<F extends Fx.AnyFx>
   readonly addObserver = (
     observer: (exit: Exit.Exit<Fx.ErrorsOf<F>, Fx.OutputOf<F>>) => void,
   ): Disposable => {
+    if (this._status.tag === 'Done') {
+      const exit = this._status.exit
+      return this.setTimer(() => observer(exit))
+    }
+
     this._observers.push(observer)
 
     return Disposable(() => {
@@ -137,10 +142,7 @@ export class FiberRuntime<F extends Fx.AnyFx>
         this._disposable.dispose()
         this._disposable = settable()
         this._current = Maybe.Just(Fx.interrupted(id).instr)
-
-        if (this._status.tag === 'Suspended') {
-          this.setTimer(() => this.loop())
-        }
+        this.loop()
       } else {
         // Record the interrupting FiberId for if/when the interrupt status becomes true again.
         this._interruptedBy.add(id)
@@ -207,6 +209,7 @@ export class FiberRuntime<F extends Fx.AnyFx>
 
   protected addCustomTrace(trace?: string) {
     if (trace) {
+      this.pushPopFiberRef(Builtin.CurrentTrace, this.getRuntimeTrace())
       this.pushPopFiberRef(Builtin.CurrentTrace, Trace.Trace.custom(trace))
     }
   }
@@ -225,14 +228,8 @@ export class FiberRuntime<F extends Fx.AnyFx>
     this.withFiberRef(Builtin.CurrentConcurrencyLevel, (semaphore) => {
       const withConcurrency = acquireFiber(semaphore.value)
 
-      const f = new FiberRuntime(
-        withConcurrency(instr.first),
-        this.context.fork({ fiberRefs: this.context.fiberRefs }),
-      )
-      const s = new FiberRuntime(
-        withConcurrency(instr.second),
-        this.context.fork({ fiberRefs: this.context.fiberRefs }),
-      )
+      const f = new FiberRuntime(withConcurrency(instr.first), this.context.fork())
+      const s = new FiberRuntime(withConcurrency(instr.second), this.context.fork())
 
       const [future, onExit] = bothFuture(f, s)
 
@@ -247,7 +244,14 @@ export class FiberRuntime<F extends Fx.AnyFx>
 
       return pipe(
         wait(future),
-        Fx.ensuring(() => Fx.fromLazy(() => inner.dispose())),
+        Fx.ensuring(() =>
+          Fx.fromLazy(() => {
+            FiberRefs.join(this.context.fiberRefs, f.context.fiberRefs)
+            FiberRefs.join(this.context.fiberRefs, s.context.fiberRefs)
+
+            inner.dispose()
+          }),
+        ),
       )
     })
   }
@@ -267,14 +271,8 @@ export class FiberRuntime<F extends Fx.AnyFx>
   protected processEither(instr: Extract<AnyInstruction, { readonly tag: 'Either' }>) {
     this.withFiberRef(Builtin.CurrentConcurrencyLevel, (semaphore) => {
       const withConcurrency = acquireFiber(semaphore.value)
-      const f = new FiberRuntime(
-        withConcurrency(instr.first),
-        this.context.fork({ fiberRefs: this.context.fiberRefs }),
-      )
-      const s = new FiberRuntime(
-        withConcurrency(instr.second),
-        this.context.fork({ fiberRefs: this.context.fiberRefs }),
-      )
+      const f = new FiberRuntime(withConcurrency(instr.first), this.context.fork())
+      const s = new FiberRuntime(withConcurrency(instr.second), this.context.fork())
 
       const inner = settable()
       const future = Pending<never, any, any>()
@@ -283,10 +281,19 @@ export class FiberRuntime<F extends Fx.AnyFx>
           pipe(
             Fx.fromExit(exit),
             Fx.ensuring(() =>
-              index === 0 ? s.interruptAs(f.context.id) : f.interruptAs(s.context.id),
+              index === 0
+                ? pipe(
+                    s.interruptAs(f.context.id),
+                    Fx.tapLazy(() => FiberRefs.join(this.context.fiberRefs, f.context.fiberRefs)),
+                  )
+                : pipe(
+                    f.interruptAs(s.context.id),
+                    Fx.tapLazy(() => FiberRefs.join(this.context.fiberRefs, s.context.fiberRefs)),
+                  ),
             ),
           ),
         )
+
         inner.dispose()
       }
 
@@ -335,9 +342,9 @@ export class FiberRuntime<F extends Fx.AnyFx>
   }
 
   protected processFromCause(instr: Extract<AnyInstruction, { readonly tag: 'FromCause' }>) {
-    if (instr.cause.tag === 'Interrupted' && this._children.length > 0) {
-      const fiberId = instr.cause.fiberId
-      const interrupts = this._children.map((c) => c.interruptAs(fiberId))
+    const interruptedCause = Cause.findInterrupted(instr.cause)
+    if (Maybe.isJust(interruptedCause) && this._children.length > 0) {
+      const interrupts = this._children.map((c) => c.interruptAs(this.id))
       this._children = []
 
       // Cancel all Child Fibers and then continue with the Cause
@@ -449,12 +456,12 @@ export class FiberRuntime<F extends Fx.AnyFx>
   protected processProvideService(
     instr: Extract<AnyInstruction, { readonly tag: 'ProvideService' }>,
   ) {
-    this.withFiberRef(Builtin.Services, (services) =>
+    this.withFiberRef(Builtin.CurrentEnv, (env) =>
       pipe(
         instr.fx,
         Fx.fiberRefLocally(
-          Builtin.Services,
-          services.value.set(instr.service, instr.implementation),
+          Builtin.CurrentEnv,
+          env.value.addService(instr.service, instr.implementation),
         ),
       ),
     )

package/src/Fx/Fx.test.ts

@@ -107,14 +107,14 @@ describe(new URL(import.meta.url).pathname, () => {
     console.time('Fx: Fib25 Construction')
     const program = fib(25)
     console.timeEnd('Fx: Fib25 Construction')
-    for (let i = 0; i < 10; i++) {
+    for (let i = 0; i < 5; i++) {
       console.time('Fib25')
       await runMain(program)
       console.timeEnd('Fib25')
     }
   })
 
-  it('runs Fib w/ generators', async () => {
+  it.skip('runs Fib w/ generators', async () => {
     const fib = (n: number): Fx.Of<number> =>
       Fx.Fx(function* () {
         if (n < 2) {

package/src/Fx/Fx.ts

@@ -206,6 +206,9 @@ export const tap =
       __trace,
     )
 
+export const tapLazy = <A, B>(f: (a: A) => B, __trace?: string) =>
+  tap((a: A) => fromLazy(() => f(a)), __trace)
+
 export const mapTo =
   <B>(b: B, __trace?: string) =>
   <R, E, A>(fx: Fx<R, E, A>): Fx<R, E, B> =>
@@ -227,13 +230,7 @@ export const match =
     __trace?: string,
   ) =>
   <R>(fx: Fx<R, E, A>): Fx<R | R2 | R3, E2 | E3, B | C> =>
-    Match.make(
-      fx,
-      (cause) =>
-        cause.tag === 'Expected' ? onLeft(cause.error) : (fromCause(cause) as Fx<R2, E2, B>),
-      onRight,
-      __trace,
-    )
+    Match.make(fx, flow(findExpectedCause, Either.match(onLeft, fromCause)), onRight, __trace)
 
 export const orElseCause =
   <E, R2, E2, B>(onLeft: (cause: Cause.Cause<E>) => Fx<R2, E2, B>, __trace?: string) =>
@@ -530,7 +527,7 @@ export const Top: T.Top3REC<FxHKT, never, never> = {
   top: now<unknown>([]),
 }
 
-export const top = T.top
+export const top = Top.top
 
 export const never = async<never, never, never>(() => Either.Left(unit))
 
@@ -601,8 +598,12 @@ export const CommutativeBoth: CB.CommutativeBoth3<FxHKT> = {
   both,
 }
 
-export const zipLeft = AB.zipLeft<FxHKT>({ ...CommutativeBoth, ...Covariant })
-export const zipRight = AB.zipRight<FxHKT>({ ...CommutativeBoth, ...Covariant })
+export const zipLeft = AB.zipLeft<FxHKT>({ ...CommutativeBoth, ...Covariant }) as <R2, E2, B>(
+  second: Fx<R2, E2, B>,
+) => <R, E, A>(first: Fx<R, E, A>) => Fx<R | R2, E | E2, A>
+export const zipRight = AB.zipRight<FxHKT>({ ...CommutativeBoth, ...Covariant }) as <R2, E2, B>(
+  second: Fx<R2, E2, B>,
+) => <R, E, A>(first: Fx<R, E, A>) => Fx<R | R2, E | E2, B>
 
 export const IdentityBothPar: IB.IdentityBoth3<FxHKT> = {
   ...CommutativeBoth,

package/src/Fx/join.ts

@@ -18,10 +18,10 @@ export const join = <E, A>(fiber: Fiber.Fiber<E, A>) =>
     ),
   )
 
-export const forkJoinInContext = <R, E, A>(
-  fx: Fx.Fx<R, E, A>,
-  context: FiberContext<FiberId.Live>,
-): Fx.Fx<R, E, A> => pipe(fx, Fx.forkInContext(context), Fx.flatMap(join))
+export const forkJoinInContext =
+  (context: FiberContext<FiberId.Live>) =>
+  <R, E, A>(fx: Fx.Fx<R, E, A>): Fx.Fx<R, E, A> =>
+    pipe(fx, Fx.forkInContext(context), Fx.flatMap(join))
 
 export const forkJoinIn = <R, E, A>(fx: Fx.Fx<R, E, A>, scope: Scope): Fx.Fx<R, E, A> =>
   pipe(fx, Fx.forkIn(scope), Fx.flatMap(join))

package/src/Schedule/ScheduleState.ts

@@ -20,6 +20,9 @@ const maxTimeAssociative = Time.makeAssociative({
 })
 const maybeMaxTimeAssociative = makeAssociative(maxTimeAssociative)
 
+/**
+ * TODO: ScheduleState should track Exit values to allow exiting early w/ custom logic
+ */
 export class ScheduleState {
   constructor(
     /**

package/src/Scheduler/RootScheduler.ts

@@ -1,5 +1,3 @@
-import { identity } from 'hkt-ts'
-
 import { Scheduler } from './Scheduler.js'
 import { callbackScheduler } from './callbackScheduler.js'
 import { runSchedule } from './runSchedule.js'
@@ -18,6 +16,7 @@ import { complete } from '@/Future/complete.js'
 import { wait } from '@/Future/wait.js'
 import { Fx } from '@/Fx/Fx.js'
 import { Schedule } from '@/Schedule/Schedule.js'
+import { ScheduleState } from '@/Schedule/ScheduleState.js'
 import { Delay } from '@/Time/index.js'
 import { SetTimeoutTimer } from '@/Timer/SetTimeoutTimer.js'
 import { Timer } from '@/Timer/Timer.js'
@@ -45,15 +44,14 @@ class RootSchedulerImpl implements Scheduler {
     }
   }
 
-  readonly asap: Scheduler['asap'] = <R, E, A, E2 = E, B = A>(
+  readonly asap: Scheduler['asap'] = <R, E, A>(
     fx: Fx<R, E, A>,
     env: Env<R>,
     context: FiberContext<FiberId.Live>,
-    transform: (fx: Fx<R, E, A>) => Fx<R, E2, B> = identity as any,
-  ): Live<E2, B> => {
+  ): Live<E, A> => {
     setFiberRef(CurrentEnv, env)(context.fiberRefs)
 
-    const runtime = new FiberRuntime(this.runAt(transform(fx), Delay(0)), context)
+    const runtime = new FiberRuntime(this.runAt(fx, Delay(0)), context)
 
     // Safe to call sync since it will be run by the Timeline.
     runtime.startSync()
@@ -61,17 +59,17 @@ class RootSchedulerImpl implements Scheduler {
     return runtime
   }
 
-  readonly schedule: Scheduler['schedule'] = <R, E, A, E2 = E, B = A>(
+  readonly schedule: Scheduler['schedule'] = <R, E, A, B>(
     fx: Fx<R, E, A>,
     env: Env<R>,
     schedule: Schedule,
     context: FiberContext<FiberId.Live>,
-    transform: (fx: Fx<R, E, A>) => Fx<R, E2, B> = identity as any,
+    onEnd?: (state: ScheduleState) => Fx<R, E, B>,
   ) => {
     setFiberRef(CurrentEnv, env)(context.fiberRefs)
 
     const runtime = new FiberRuntime(
-      runSchedule(transform(fx), schedule, this.timer, this.runAt),
+      runSchedule(fx, schedule, this.timer, this.runAt, onEnd),
       context,
     )
 

package/src/Scheduler/Scheduler.ts

@@ -9,20 +9,19 @@ import { ScheduleState } from '@/Schedule/ScheduleState.js'
 import { Service } from '@/Service/Service.js'
 
 export interface Scheduler extends Disposable {
-  readonly asap: <R, E, A, E2 = E, B = A>(
+  readonly asap: <R, E, A>(
     fx: Fx<R, E, A>,
     env: Env<R>,
     context: FiberContext<FiberId.Live>,
-    transform?: (fx: Fx<R, E, A>) => Fx<R, E2, B>,
-  ) => Live<E2, B>
+  ) => Live<E, A>
 
-  readonly schedule: <R, E, A, E2 = E, B = A>(
+  readonly schedule: <R, E, A, B>(
     fx: Fx<R, E, A>,
     env: Env<R>,
     schedule: Schedule,
     context: FiberContext<FiberId.Live>,
-    transform?: (fx: Fx<R, E, A>) => Fx<R, E2, B>,
-  ) => Live<E2, ScheduleState>
+    onEnd?: (state: ScheduleState) => Fx<R, E, B>,
+  ) => Live<E, ScheduleState>
 }
 
 export const Scheduler = Service<Scheduler>('Scheduler')

package/src/Scheduler/callbackScheduler.ts

@@ -34,6 +34,7 @@ export function callbackScheduler(
   }
 
   function runReadyTasks() {
+    nextArrival = null
     timeline.getReadyTasks(Clock.timeToUnixTime(timer.getCurrentTime())(timer)).forEach((f) => f())
 
     scheduleNextRun()

package/src/Scheduler/runSchedule.ts

@@ -1,5 +1,5 @@
 import * as Clock from '@/Clock/Clock.js'
-import { Fx } from '@/Fx/Fx.js'
+import { Fx, unit } from '@/Fx/Fx.js'
 import { Schedule } from '@/Schedule/Schedule.js'
 import { ScheduleState } from '@/Schedule/ScheduleState.js'
 import { Delay } from '@/Time/index.js'
@@ -7,11 +7,12 @@ import { Delay } from '@/Time/index.js'
 /**
  * Runs an Fx on a given Schedule
  */
-export function runSchedule<R, E, A>(
+export function runSchedule<R, E, A, B>(
   fx: Fx<R, E, A>,
   schedule: Schedule,
   clock: Clock.Clock,
   runAt: (fx: Fx<R, E, A>, delay: Delay) => Fx<R, E, A>,
+  onEnd?: (state: ScheduleState) => Fx<R, E, B>,
 ): Fx<R, E, ScheduleState> {
   return Fx(function* () {
     let [state, decision] = schedule.step(clock.getCurrentTime(), new ScheduleState())
@@ -26,6 +27,8 @@ export function runSchedule<R, E, A>(
       decision = nextDecision
     }
 
+    yield* onEnd?.(state) ?? unit
+
     // Return the final state
     return state
   })

package/src/Scope/LocalScope.ts

@@ -2,7 +2,6 @@ import { mapTo } from 'hkt-ts/Either'
 import * as Maybe from 'hkt-ts/Maybe'
 import { First } from 'hkt-ts/Typeclass/Associative'
 import { pipe } from 'hkt-ts/function'
-import { NonNegativeInteger } from 'hkt-ts/number'
 
 import { Closeable } from './Closeable.js'
 import { ReleaseMap } from './ReleaseMap.js'
@@ -18,7 +17,7 @@ const { concat: concatExits } = makeSequentialAssociative<any, any>(First)
 export class LocalScope implements Closeable {
   protected _state: ScopeState = Open
   protected _releaseMap = new ReleaseMap(this.strategy)
-  protected _refCount = AtomicCounter(NonNegativeInteger(1))
+  protected _refCount = AtomicCounter()
   protected _exit: Maybe.Maybe<Exit<any, any>> = Maybe.Nothing
 
   constructor(readonly strategy: FinalizationStrategy) {}
@@ -44,9 +43,12 @@ export class LocalScope implements Closeable {
 
     const extended = new LocalScope(strategy)
 
-    // Mutually track resources
-    extended.ensuring(() => this.release)
-    extended.ensuring(this.ensuring(() => extended.release))
+    extended.ensuring(() => {
+      decrement(this._refCount)
+
+      return this.release
+    })
+
     increment(this._refCount)
 
     return extended
@@ -64,7 +66,7 @@ export class LocalScope implements Closeable {
   // Internals
 
   protected release = lazy(() => {
-    if (decrement(this._refCount) > 0 || Maybe.isNothing(this._exit) || this.isClosed) {
+    if (this._refCount.get() > 0 || Maybe.isNothing(this._exit) || this.isClosed) {
       return success(false)
     }