@typed/fx 0.0.3 → 0.0.4

package/src/Logger/Console.ts

@@ -1,3 +1,5 @@
+import { pipe } from 'hkt-ts'
+
 import { LogAnnotation } from './LogAnnotation.js'
 import { LogLevel } from './LogLevel.js'
 import { LogSpan } from './LogSpan.js'
@@ -5,29 +7,43 @@ import { Logger } from './Logger.js'
 
 import { Clock, timeToUnixTime } from '@/Clock/index.js'
 import { format, fromTime } from '@/Duration/Duration.js'
-import { Fx, getFiberContext } from '@/Fx/Fx.js'
+import * as Fx from '@/Fx/Fx.js'
 import { Time } from '@/Time/index.js'
+import * as Trace from '@/Trace/index.js'
 
 export const Console: Logger<string, void> = {
-  log: (input, level, id, logSpans, logAnnotations) =>
-    Fx(function* () {
+  log: (input, level, id, logSpans, logAnnotations, trace) =>
+    Fx.lazy(() => {
       if (level === LogLevel.None) {
-        return
+        return Fx.unit
       }
 
-      const { platform } = yield* getFiberContext
-      const now = platform.timer.getCurrentTime()
+      return pipe(
+        Fx.getPlatform,
+        Fx.flatMap((platform) =>
+          Fx.lazy(() => {
+            const now = platform.timer.getCurrentTime()
+
+            const message = [
+              `timestamp=${getIsoString(now, platform.timer)}`,
+              `level=${formatLogLevel(level)}`,
+              `fiber=${id.sequenceNumber}`,
+              ...logSpans.map(formatLogSpan(now)),
+              ...logAnnotations.map(formatlogAnnotation),
+              `message=${input}`,
+            ].join('; ')
 
-      const message = [
-        `timestamp=${getIsoString(now, platform.timer)}`,
-        `level=${formatLogLevel(level)}`,
-        `fiber=${id.sequenceNumber}`,
-        ...logSpans.map(formatLogSpan(now)),
-        ...logAnnotations.map(formatlogAnnotation),
-        `message=${input}`,
-      ].join('; ')
+            logWithLevel(
+              trace.tag !== 'EmptyTrace'
+                ? message + '\n    ' + Trace.debug(trace).replaceAll('\n', '\n    ')
+                : message,
+              level,
+            )
 
-      logWithLevel(message, level)
+            return Fx.unit
+          }),
+        ),
+      )
     }),
 }
 
@@ -62,9 +78,8 @@ function logWithLevel(message: string, level: LogLevel) {
     case LogLevel.Info:
       return console.info(message)
     case LogLevel.Log:
-      return console.log(message)
     case LogLevel.Trace:
-      return console.trace(message)
+      return console.log(message)
     case LogLevel.Debug:
       return console.debug(message)
   }

package/src/Logger/Logger.ts

@@ -11,6 +11,7 @@ import { LogSpan } from './LogSpan.js'
 
 import { FiberId } from '@/FiberId/FiberId.js'
 import * as Fx from '@/Fx/Fx.js'
+import { Trace } from '@/Trace/Trace.js'
 
 // TODO: Console as a Logger
 // TODO: Build into Fx runtime
@@ -22,6 +23,7 @@ export interface Logger<A, B> {
     id: FiberId.Live,
     logSpans: ReadonlyArray<LogSpan>,
     logAnnotations: ReadonlyArray<LogAnnotation>,
+    trace: Trace,
   ) => Fx.Of<B>
 }
 
@@ -47,8 +49,8 @@ export const Divariant: D.Divariant2<LoggerHKT> = {
   dimap:
     <A, B, C, D>(f: Unary<A, B>, g: Unary<C, D>) =>
     (logger: Logger<B, C>) =>
-      Logger((i: A, level, id, logSpans, logAnnotations) =>
-        Fx.map(g)(logger.log(f(i), level, id, logSpans, logAnnotations)),
+      Logger((i: A, level, id, logSpans, logAnnotations, trace) =>
+        Fx.map(g)(logger.log(f(i), level, id, logSpans, logAnnotations, trace)),
       ),
 }
 

package/src/Node/Runtime.ts

@@ -0,0 +1,26 @@
+import { gracefulShutdown } from './gracefulShutdown.js'
+
+import { Atomic } from '@/Atomic/index.js'
+import { AnyLiveFiber } from '@/Fiber/Fiber.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.js'
+import { MainPlatform } from '@/Fx/run.js'
+import { Runtime } from '@/Runtime/Runtime.js'
+import { GlobalScope } from '@/Scope/GlobalScope.js'
+
+export const NodeFibers = Atomic<ReadonlyMap<FiberId.Live, AnyLiveFiber>>(new Map())
+export const NodeSupervisor = gracefulShutdown(NodeFibers)
+export const NodeRuntime = Runtime(
+  FiberContext({
+    platform: MainPlatform,
+    id: FiberId.None,
+    scope: GlobalScope,
+    supervisor: NodeSupervisor,
+  }),
+)
+
+export const {
+  run: runMainNode,
+  runExit: runMainNodeExit,
+  runFiber: runMainNodeFiber,
+} = NodeRuntime

package/src/Node/gracefulShutdown.ts

@@ -0,0 +1,54 @@
+import process from 'node:process'
+
+import { Atomic } from '@/Atomic/Atomic.js'
+import * as Duration from '@/Duration/Duration.js'
+import { AnyLiveFiber } from '@/Fiber/Fiber.js'
+import { FiberId } from '@/FiberId/FiberId.js'
+import { runMain, zipAll } from '@/Fx/index.js'
+import { trackIn } from '@/Supervisor/trackIn.js'
+
+const DELAY = Duration.toMilliseconds(Duration.Duration(1, Duration.Unit.Hour)).value
+
+export function gracefulShutdown(
+  fibers: Atomic<ReadonlyMap<FiberId.Live, AnyLiveFiber>> = Atomic<
+    ReadonlyMap<FiberId.Live, AnyLiveFiber>
+  >(new Map()),
+) {
+  // Used to forcefully keep the process (e.g. Node.js) alive even when fibers are idle.
+  let id: ReturnType<typeof setTimeout> | undefined
+
+  const gracefulExit = () =>
+    void runMain(
+      zipAll(Array.from(fibers.get().values()).map((fiber) => fiber.interruptAs(FiberId.None))),
+    ).then(
+      () => process.exit(0),
+      () => process.exit(1),
+    )
+
+  return trackIn(fibers).extend({
+    onStart: (parent) => (fiber, fx) => {
+      parent(fiber, fx)
+
+      if (!id) {
+        // Force the process to stay alive, even when fibers are idle.
+        id = setTimeout(() => {
+          id = undefined
+        }, DELAY)
+
+        // Add a listener to the process to gracefully exit when the process is killed.
+        process.addListener('SIGTERM', gracefulExit)
+        process.addListener('SIGINT', gracefulExit)
+      }
+    },
+    onEnd: (parent) => (fiber, exit) => {
+      parent(fiber, exit)
+
+      if (fibers.get().size === 0 && id) {
+        clearTimeout(id)
+        id = undefined
+        process.removeListener('SIGTERM', gracefulExit)
+        process.removeListener('SIGINT', gracefulExit)
+      }
+    },
+  })
+}

package/src/Node/index.ts

@@ -0,0 +1,2 @@
+export * from './gracefulShutdown.js'
+export * from './Runtime.js'

package/src/Platform/Platform.ts

@@ -1,6 +1,7 @@
 import { NonNegativeInteger } from 'hkt-ts/number'
 
 import { AtomicCounter } from '@/Atomic/AtomicCounter.js'
+import { Renderer, defaultRenderer } from '@/Cause/Renderer.js'
 import { SetTimeoutTimer } from '@/Timer/SetTimeoutTimer.js'
 import * as Timer from '@/Timer/Timer.js'
 
@@ -9,6 +10,7 @@ export interface Platform {
   readonly maxOpCount: NonNegativeInteger
   readonly maxTraceCount: NonNegativeInteger
   readonly timer: Timer.Timer
+  readonly renderer: Renderer<any>
   readonly reportFailure: (message: string) => void
   readonly fork: () => Platform
 }
@@ -18,6 +20,7 @@ export function Platform(
   maxOpCount: NonNegativeInteger = NonNegativeInteger(500),
   maxTraceCount: NonNegativeInteger = NonNegativeInteger(50),
   timer: Timer.Timer = SetTimeoutTimer(),
+  renderer: Renderer<any> = defaultRenderer,
   reportFailure: (message: string) => void = console.error,
 ): Platform {
   const platform: Platform = {
@@ -25,6 +28,7 @@ export function Platform(
     maxOpCount,
     maxTraceCount,
     timer,
+    renderer,
     reportFailure,
     fork: () => fork(platform),
   }
@@ -32,11 +36,13 @@ export function Platform(
   return platform
 }
 
-export function fork(platform: Platform): Platform {
+export function fork(platform: Platform, overrides?: Partial<Omit<Platform, 'fork'>>): Platform {
   return Platform(
-    platform.sequenceNumber,
-    platform.maxOpCount,
-    platform.maxTraceCount,
-    Timer.fork(platform.timer),
+    overrides?.sequenceNumber ?? platform.sequenceNumber,
+    overrides?.maxOpCount ?? platform.maxOpCount,
+    overrides?.maxTraceCount ?? platform.maxTraceCount,
+    overrides?.timer ?? Timer.fork(platform.timer),
+    overrides?.renderer ?? platform.renderer,
+    overrides?.reportFailure ?? platform.reportFailure,
   )
 }

package/src/Runtime/Runtime.ts

@@ -8,12 +8,12 @@ import { FiberRuntime } from '@/FiberRuntime/FiberRuntime.js'
 import { Fx } from '@/Fx/Fx.js'
 
 export interface Runtime<R> {
-  readonly runFiber: <E, A>(fx: Fx<R, E, A>) => Live<E, A>
-  readonly runExit: <E, A>(fx: Fx<R, E, A>) => Promise<Exit<E, A>>
-  readonly run: <E, A>(fx: Fx<R, E, A>) => Promise<A>
+  readonly runFiber: <E = never, A = any>(fx: Fx<R, E, A>) => Live<E, A>
+  readonly runExit: <E = never, A = any>(fx: Fx<R, E, A>) => Promise<Exit<E, A>>
+  readonly run: <E = never, A = any>(fx: Fx<R, E, A>) => Promise<A>
 }
 
-export function Runtime<R>(context: FiberContext): Runtime<R> {
+export function Runtime<R = never>(context: FiberContext): Runtime<R> {
   return {
     runFiber: <E, A>(fx: Fx<R, E, A>) => {
       const r = new FiberRuntime(fx, context.fork())
@@ -35,7 +35,9 @@ export function Runtime<R>(context: FiberContext): Runtime<R> {
       new Promise<A>((resolve, reject) => {
         const r = new FiberRuntime(fx, context.fork())
 
-        r.addObserver(match((cause) => reject(new CauseError(cause, context.renderer)), resolve))
+        r.addObserver(
+          match((cause) => reject(new CauseError(cause, context.platform.renderer)), resolve),
+        )
         r.startSync()
 
         return r

package/src/Scheduler/RootScheduler.ts

@@ -1,13 +1,16 @@
+import { identity } from 'hkt-ts'
+
 import { Scheduler } from './Scheduler.js'
 import { callbackScheduler } from './callbackScheduler.js'
-import { scheduled } from './scheduled.js'
+import { runSchedule } from './runSchedule.js'
 
 import { delayToUnixTime } from '@/Clock/index.js'
 import { Disposable } from '@/Disposable/Disposable.js'
 import { Env } from '@/Env/Env.js'
 import { Live } from '@/Fiber/index.js'
 import { FiberContext } from '@/FiberContext/FiberContext.js'
-import { CurrentEnv } from '@/FiberRef/FiberRef.js'
+import * as FiberId from '@/FiberId/index.js'
+import { CurrentEnv } from '@/FiberRef/builtins.js'
 import { setFiberRef } from '@/FiberRefs/FiberRefs.js'
 import { FiberRuntime } from '@/FiberRuntime/FiberRuntime.js'
 import { Pending } from '@/Future/Future.js'
@@ -42,14 +45,15 @@ class RootSchedulerImpl implements Scheduler {
     }
   }
 
-  readonly asap: Scheduler['asap'] = <R, E, A>(
+  readonly asap: Scheduler['asap'] = <R, E, A, E2 = E, B = A>(
     fx: Fx<R, E, A>,
     env: Env<R>,
-    context: FiberContext,
-  ): Live<E, A> => {
+    context: FiberContext<FiberId.Live>,
+    transform: (fx: Fx<R, E, A>) => Fx<R, E2, B> = identity as any,
+  ): Live<E2, B> => {
     setFiberRef(CurrentEnv, env)(context.fiberRefs)
 
-    const runtime = new FiberRuntime(this.runAt(fx, Delay(0)), context)
+    const runtime = new FiberRuntime(this.runAt(transform(fx), Delay(0)), context)
 
     // Safe to call sync since it will be run by the Timeline.
     runtime.startSync()
@@ -57,15 +61,19 @@ class RootSchedulerImpl implements Scheduler {
     return runtime
   }
 
-  readonly schedule: Scheduler['schedule'] = <R, E, A>(
+  readonly schedule: Scheduler['schedule'] = <R, E, A, E2 = E, B = A>(
     fx: Fx<R, E, A>,
-    schedule: Schedule,
     env: Env<R>,
-    context: FiberContext,
+    schedule: Schedule,
+    context: FiberContext<FiberId.Live>,
+    transform: (fx: Fx<R, E, A>) => Fx<R, E2, B> = identity as any,
   ) => {
     setFiberRef(CurrentEnv, env)(context.fiberRefs)
 
-    const runtime = new FiberRuntime(scheduled(fx, schedule, this.timer, this.runAt), context)
+    const runtime = new FiberRuntime(
+      runSchedule(transform(fx), schedule, this.timer, this.runAt),
+      context,
+    )
 
     // Safe to call sync since it will be run by the Timeline.
     runtime.startSync()

package/src/Scheduler/Scheduler.ts

@@ -2,20 +2,27 @@ import { Disposable } from '@/Disposable/Disposable.js'
 import { Env } from '@/Env/Env.js'
 import { Live } from '@/Fiber/Fiber.js'
 import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.js'
 import { Fx } from '@/Fx/Fx.js'
 import { Schedule } from '@/Schedule/Schedule.js'
 import { ScheduleState } from '@/Schedule/ScheduleState.js'
 import { Service } from '@/Service/Service.js'
 
 export interface Scheduler extends Disposable {
-  readonly asap: <R, E, A>(fx: Fx<R, E, A>, env: Env<R>, context: FiberContext) => Live<E, A>
+  readonly asap: <R, E, A, E2 = E, B = 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>
 
-  readonly schedule: <R, E, A>(
+  readonly schedule: <R, E, A, E2 = E, B = A>(
     fx: Fx<R, E, A>,
-    schedule: Schedule,
     env: Env<R>,
-    context: FiberContext,
-  ) => Live<E, ScheduleState>
+    schedule: Schedule,
+    context: FiberContext<FiberId.Live>,
+    transform?: (fx: Fx<R, E, A>) => Fx<R, E2, B>,
+  ) => Live<E2, ScheduleState>
 }
 
 export const Scheduler = Service<Scheduler>('Scheduler')

package/src/Scheduler/index.ts

@@ -0,0 +1,2 @@
+export * from './RootScheduler.js'
+export * from './Scheduler.js'

package/src/Scheduler/{scheduled.ts → runSchedule.ts}

@@ -7,7 +7,7 @@ import { Delay } from '@/Time/index.js'
 /**
  * Runs an Fx on a given Schedule
  */
-export function scheduled<R, E, A>(
+export function runSchedule<R, E, A>(
   fx: Fx<R, E, A>,
   schedule: Schedule,
   clock: Clock.Clock,

package/src/Scope/Closeable.test.ts

@@ -8,6 +8,7 @@ import { Closed, Closing, Open, ScopeState } from './ScopeState.js'
 
 import { CauseError } from '@/Cause/CauseError.js'
 import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.js'
 import { FiberRuntime } from '@/FiberRuntime/FiberRuntime.js'
 import { Finalizer } from '@/Finalizer/Finalizer.js'
 import { Fx, IO, fork, fromLazy } from '@/Fx/Fx.js'
@@ -87,7 +88,10 @@ const stateCloseable = (_state: ScopeState): Closeable => {
   return scope
 }
 
-function runTest<E, A>(io: IO<E, A>, context: FiberContext = FiberContext()): Promise<A> {
+function runTest<E, A>(
+  io: IO<E, A>,
+  context: FiberContext<FiberId.Live> = FiberContext(),
+): Promise<A> {
   return new Promise((resolve, reject) => {
     const runtime = new FiberRuntime(io, context)
     runtime.addObserver((exit) =>

package/src/Scope/LocalScope.ts

@@ -1,3 +1,4 @@
+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'
@@ -10,7 +11,7 @@ import { Closed, Closing, Open, ScopeState } from './ScopeState.js'
 import { AtomicCounter, decrement, increment } from '@/Atomic/AtomicCounter.js'
 import { Exit, makeSequentialAssociative } from '@/Exit/Exit.js'
 import { FinalizationStrategy, Finalizer } from '@/Finalizer/Finalizer.js'
-import { Fx, Of, lazy, success, unit } from '@/Fx/Fx.js'
+import { Of, flatMap, fromExit, fromLazy, lazy, success, uninterruptable, unit } from '@/Fx/Fx.js'
 
 const { concat: concatExits } = makeSequentialAssociative<any, any>(First)
 
@@ -67,19 +68,19 @@ export class LocalScope implements Closeable {
       return success(false)
     }
 
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const that = this
     const exit = this._exit.value
 
-    return Fx(function* () {
-      that._state = Closing(exit)
-
-      yield* that._releaseMap.releaseAll(exit)
-
-      that._state = Closed(exit)
-
-      return true
-    })
+    return pipe(
+      fromLazy(() => (this._state = Closing(exit))),
+      flatMap(() => this._releaseMap.releaseAll(exit)),
+      flatMap((exit) =>
+        pipe(
+          fromLazy(() => (this._state = Closed(exit))),
+          flatMap(() => pipe(exit, mapTo(true), fromExit) as Of<boolean>),
+        ),
+      ),
+      uninterruptable,
+    )
   })
 
   protected get isClosed() {

package/src/Scope/ReleaseMap.ts

@@ -1,20 +1,25 @@
 /* eslint-disable @typescript-eslint/no-this-alias */
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 
+import * as A from 'hkt-ts/Array'
 import { Just, Maybe, Nothing } from 'hkt-ts/Maybe'
+import { First } from 'hkt-ts/Typeclass/Associative'
 import { pipe } from 'hkt-ts/function'
 
-import { Exit } from '@/Exit/Exit.js'
+import * as Exit from '@/Exit/Exit.js'
 import {
   FinalizationStrategy,
   Finalizer,
   FinalizerKey,
   finalizationStrategyToConcurrency,
 } from '@/Finalizer/Finalizer.js'
-import { Fx, Of, lazy, mapTo, unit, withConcurrency, zipAll } from '@/Fx/Fx.js'
+import { Fx, Of, attempt, lazy, unit, withConcurrency, zipAll } from '@/Fx/Fx.js'
 
 let nextId = 0
 
+const concatExitSeq = Exit.makeSequentialAssociative<any, any>(First).concat
+const concatExitPar = Exit.makeParallelAssociative<any, any>(First).concat
+
 /**
  * ReleaseMap is an underlying class utilizing in the implementation of Managed. It allows
  * tracking multiple Finalizers and closing them.
@@ -46,7 +51,7 @@ export class ReleaseMap {
     return Just(finalizer)
   }
 
-  readonly release = (key: FinalizerKey, exit: Exit<any, any>): Of<void> =>
+  readonly release = (key: FinalizerKey, exit: Exit.Exit<any, any>): Of<void> =>
     lazy(() =>
       this.finalizers.has(key)
         ? lazy(() => {
@@ -59,21 +64,29 @@ export class ReleaseMap {
         : unit,
     )
 
-  readonly releaseAll = (exit: Exit<any, any>): Of<void> => {
+  readonly releaseAll = (exit: Exit.AnyExit): Of<Exit.AnyExit> => {
     const toBeReleased = () =>
       Array.from(this.finalizers.keys())
         .reverse()
-        .map((key) => this.release(key, exit))
+        .map((key) => attempt(this.release(key, exit)))
 
     const isEmpty = () => this.isEmpty()
 
     if (this.strategy.strategy === 'Sequential') {
       return Fx(function* () {
+        const exits: Array<Exit.AnyExit> = []
+
         while (!isEmpty()) {
           for (const fx of toBeReleased()) {
-            yield* fx
+            exits.push(yield* fx)
           }
         }
+
+        if (A.isNonEmpty(exits)) {
+          return exits.reduce(concatExitSeq, exit)
+        }
+
+        return exit
       })
     }
 
@@ -81,15 +94,20 @@ export class ReleaseMap {
       pipe(
         zipAll(toBeReleased()),
         withConcurrency(finalizationStrategyToConcurrency(this.strategy)),
-        mapTo(undefined),
       )
 
     return Fx(function* () {
-      yield* releaseAll_()
+      const exits: Array<Exit.AnyExit> = []
 
       while (!isEmpty()) {
-        yield* releaseAll_()
+        exits.push((yield* releaseAll_()).reduce(concatExitPar as any))
+      }
+
+      if (A.isNonEmpty(exits)) {
+        return exits.reduce(concatExitSeq, exit)
       }
+
+      return exit
     })
   }
 }

package/src/Semaphore/Semaphore.ts

@@ -1,31 +1,32 @@
-import { constant } from 'hkt-ts/function'
+import { constant, pipe } from 'hkt-ts/function'
 import { NonNegativeInteger } from 'hkt-ts/number'
 
+import { AtomicCounter, decrement, increment } from '@/Atomic/AtomicCounter.js'
 import { MutableFutureQueue } from '@/Future/MutableFutureQueue.js'
 import { wait } from '@/Future/wait.js'
-import { Fx, Of, fromLazy, unit } from '@/Fx/Fx.js'
+import { Fx, Of, flatMap, fromLazy, tap, unit } from '@/Fx/Fx.js'
 import { fiberScoped, managed, scoped } from '@/Fx/scoped.js'
 
 export class Semaphore {
   protected waiting = MutableFutureQueue<never, never, void>()
-  protected running = 0
+  protected running = AtomicCounter()
 
   constructor(readonly maxPermits: NonNegativeInteger) {}
 
   // Retrieve the number of permits still available
   get available(): NonNegativeInteger {
-    return NonNegativeInteger(Math.max(0, this.maxPermits - this.running))
+    return NonNegativeInteger(Math.max(0, this.maxPermits - this.running.get()))
   }
 
   get acquired(): NonNegativeInteger {
-    return NonNegativeInteger(this.running)
+    return this.running.get()
   }
 
   readonly prepare = fromLazy(() => {
     if (this.available > 0) {
       return new Acquisition(
         fromLazy(() => {
-          this.running++
+          increment(this.running)
         }),
         this.release,
       )
@@ -36,11 +37,14 @@ export class Semaphore {
     // eslint-disable-next-line @typescript-eslint/no-this-alias
     const that = this
     const acquisition = new Acquisition(
-      Fx(function* () {
-        yield* wait(future)
-
-        that.running++
-      }),
+      pipe(
+        wait(future),
+        tap(() =>
+          fromLazy(() => {
+            increment(that.running)
+          }),
+        ),
+      ),
       this.release,
     )
 
@@ -48,7 +52,7 @@ export class Semaphore {
   })
 
   protected release = fromLazy(() => {
-    this.running = Math.max(0, this.running - 1)
+    decrement(this.running)
 
     if (this.waiting.size() > 0) {
       this.waiting.next(unit)
@@ -74,11 +78,10 @@ export class Lock extends Semaphore {
  * Must be used with Fx.scoped() to release the permit at the desired time.
  */
 export function acquirePermit(semaphore: Semaphore) {
-  return Fx(function* () {
-    const { acquire, release } = yield* semaphore.prepare
-
-    return yield* managed(acquire, constant(release))
-  })
+  return pipe(
+    semaphore.prepare,
+    flatMap(({ acquire, release }) => managed(acquire, constant(release))),
+  )
 }
 
 /**
@@ -86,12 +89,10 @@ export function acquirePermit(semaphore: Semaphore) {
  */
 export function acquire(semaphore: Semaphore) {
   return <R, E, A>(fx: Fx<R, E, A>) =>
-    scoped(
-      Fx(function* () {
-        yield* acquirePermit(semaphore)
-
-        return yield* fx
-      }),
+    pipe(
+      acquirePermit(semaphore),
+      flatMap(() => fx),
+      scoped,
     )
 }
 
@@ -100,11 +101,9 @@ export function acquire(semaphore: Semaphore) {
  */
 export function acquireFiber(semaphore: Semaphore) {
   return <R, E, A>(fx: Fx<R, E, A>) =>
-    fiberScoped(
-      Fx(function* () {
-        yield* acquirePermit(semaphore)
-
-        return yield* fx
-      }),
+    pipe(
+      acquirePermit(semaphore),
+      flatMap(() => fx),
+      fiberScoped,
     )
 }