effect 2.2.5 → 2.3.1

package/src/internal/logSpan.ts

@@ -7,9 +7,7 @@ export const make = (label: string, startTime: number): LogSpan.LogSpan => ({
 })
 
 /** @internal */
-export const render = (now: number) => {
-  return (self: LogSpan.LogSpan): string => {
-    const label = self.label.replace(/[\s="]/g, "_")
-    return `${label}=${now - self.startTime}ms`
-  }
+export const render = (now: number) => (self: LogSpan.LogSpan): string => {
+  const label = self.label.replace(/[\s="]/g, "_")
+  return `${label}=${now - self.startTime}ms`
 }

package/src/internal/metric/polling.ts

@@ -22,7 +22,7 @@ export const MetricPollingTypeId: MetricPolling.MetricPollingTypeId = Symbol.for
 /** @internal */
 export const make = <Type, In, Out, R, E>(
   metric: Metric.Metric<Type, In, Out>,
-  poll: Effect.Effect<R, E, In>
+  poll: Effect.Effect<In, E, R>
 ): MetricPolling.MetricPolling<Type, In, R, E, Out> => {
   return {
     [MetricPollingTypeId]: MetricPollingTypeId,
@@ -68,11 +68,11 @@ export const launch = dual<
     schedule: Schedule.Schedule<R2, unknown, A2>
   ) => <Type, In, R, E, Out>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>
-  ) => Effect.Effect<R | R2 | Scope.Scope, never, Fiber.Fiber<E, A2>>,
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>,
   <Type, In, R, E, Out, R2, A2>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
     schedule: Schedule.Schedule<R2, unknown, A2>
-  ) => Effect.Effect<R | R2 | Scope.Scope, never, Fiber.Fiber<E, A2>>
+  ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>
 >(2, (self, schedule) =>
   pipe(
     pollAndUpdate(self),
@@ -83,12 +83,12 @@ export const launch = dual<
 /** @internal */
 export const poll = <Type, In, R, E, Out>(
   self: MetricPolling.MetricPolling<Type, In, R, E, Out>
-): Effect.Effect<R, E, In> => self.poll
+): Effect.Effect<In, E, R> => self.poll
 
 /** @internal */
 export const pollAndUpdate = <Type, In, R, E, Out>(
   self: MetricPolling.MetricPolling<Type, In, R, E, Out>
-): Effect.Effect<R, E, void> => core.flatMap(self.poll, (value) => metric.update(self.metric, value))
+): Effect.Effect<void, E, R> => core.flatMap(self.poll, (value) => metric.update(self.metric, value))
 
 /** @internal */
 export const retry = dual<

package/src/internal/metric.ts

@@ -53,7 +53,7 @@ export const make: Metric.MetricApply = function<Type, In, Out>(
   unsafeValue: (extraTags: ReadonlyArray<MetricLabel.MetricLabel>) => Out
 ): Metric.Metric<Type, In, Out> {
   const metric: Metric.Metric<Type, In, Out> = Object.assign(
-    <R, E, A extends In>(effect: Effect.Effect<R, E, A>): Effect.Effect<R, E, A> =>
+    <A extends In, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
       core.tap(
         effect,
         (a) => core.sync(() => unsafeUpdate(a, []))
@@ -173,18 +173,17 @@ export const histogram = (name: string, boundaries: MetricBoundaries.MetricBound
 /* @internal */
 export const increment = (
   self: Metric.Metric.Counter<number> | Metric.Metric.Counter<bigint>
-): Effect.Effect<never, never, void> =>
-  update(self as Metric.Metric.Counter<number>, self.keyType.bigint ? BigInt(1) as any : 1)
+): Effect.Effect<void> => update(self as Metric.Metric.Counter<number>, self.keyType.bigint ? BigInt(1) as any : 1)
 
 /* @internal */
 export const incrementBy = dual<
   {
-    (amount: number): (self: Metric.Metric.Counter<number>) => Effect.Effect<never, never, void>
-    (amount: bigint): (self: Metric.Metric.Counter<bigint>) => Effect.Effect<never, never, void>
+    (amount: number): (self: Metric.Metric.Counter<number>) => Effect.Effect<void>
+    (amount: bigint): (self: Metric.Metric.Counter<bigint>) => Effect.Effect<void>
   },
   {
-    (self: Metric.Metric.Counter<number>, amount: number): Effect.Effect<never, never, void>
-    (self: Metric.Metric.Counter<bigint>, amount: bigint): Effect.Effect<never, never, void>
+    (self: Metric.Metric.Counter<number>, amount: number): Effect.Effect<void>
+    (self: Metric.Metric.Counter<bigint>, amount: bigint): Effect.Effect<void>
   }
 >(2, (self, amount) => update(self as any, amount))
 
@@ -215,12 +214,12 @@ export const mapType = dual<
 /* @internal */
 export const set = dual<
   {
-    (value: number): (self: Metric.Metric.Gauge<number>) => Effect.Effect<never, never, void>
-    (value: bigint): (self: Metric.Metric.Gauge<bigint>) => Effect.Effect<never, never, void>
+    (value: number): (self: Metric.Metric.Gauge<number>) => Effect.Effect<void>
+    (value: bigint): (self: Metric.Metric.Gauge<bigint>) => Effect.Effect<void>
   },
   {
-    (self: Metric.Metric.Gauge<number>, value: number): Effect.Effect<never, never, void>
-    (self: Metric.Metric.Gauge<bigint>, value: bigint): Effect.Effect<never, never, void>
+    (self: Metric.Metric.Gauge<number>, value: number): Effect.Effect<void>
+    (self: Metric.Metric.Gauge<bigint>, value: bigint): Effect.Effect<void>
   }
 >(2, (self, value) => update(self as any, value))
 
@@ -339,11 +338,11 @@ export const trackAll = dual<
     input: In
   ) => <Type, Out>(
     self: Metric.Metric<Type, In, Out>
-  ) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
   <Type, In, Out>(
     self: Metric.Metric<Type, In, Out>,
     input: In
-  ) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
 >(2, (self, input) => (effect) =>
   core.matchCauseEffect(effect, {
     onFailure: (cause) => {
@@ -360,11 +359,11 @@ export const trackAll = dual<
 export const trackDefect = dual<
   <Type, Out>(
     metric: Metric.Metric<Type, unknown, Out>
-  ) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A, Type, Out>(
-    self: Effect.Effect<R, E, A>,
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R, Type, Out>(
+    self: Effect.Effect<A, E, R>,
     metric: Metric.Metric<Type, unknown, Out>
-  ) => Effect.Effect<R, E, A>
+  ) => Effect.Effect<A, E, R>
 >(2, (self, metric) => trackDefectWith(self, metric, identity))
 
 /* @internal */
@@ -372,12 +371,12 @@ export const trackDefectWith = dual<
   <Type, In, Out>(
     metric: Metric.Metric<Type, In, Out>,
     f: (defect: unknown) => In
-  ) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A, Type, In, Out>(
-    self: Effect.Effect<R, E, A>,
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R, Type, In, Out>(
+    self: Effect.Effect<A, E, R>,
     metric: Metric.Metric<Type, In, Out>,
     f: (defect: unknown) => In
-  ) => Effect.Effect<R, E, A>
+  ) => Effect.Effect<A, E, R>
 >(3, (self, metric, f) => {
   const updater = (defect: unknown): void => metric.unsafeUpdate(f(defect), [])
   return _effect.tapDefect(self, (cause) =>
@@ -393,11 +392,11 @@ export const trackDefectWith = dual<
 export const trackDuration = dual<
   <Type, Out>(
     metric: Metric.Metric<Type, Duration.Duration, Out>
-  ) => <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A, Type, Out>(
-    self: Effect.Effect<R, E, A>,
+  ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R, Type, Out>(
+    self: Effect.Effect<A, E, R>,
     metric: Metric.Metric<Type, Duration.Duration, Out>
-  ) => Effect.Effect<R, E, A>
+  ) => Effect.Effect<A, E, R>
 >(2, (self, metric) => trackDurationWith(self, metric, identity))
 
 /* @internal */
@@ -405,12 +404,12 @@ export const trackDurationWith = dual<
   <Type, In, Out>(
     metric: Metric.Metric<Type, In, Out>,
     f: (duration: Duration.Duration) => In
-  ) => <R, E, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A, Type, In, Out>(
-    self: Effect.Effect<R, E, A>,
+  ) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E, R, Type, In, Out>(
+    self: Effect.Effect<A, E, R>,
     metric: Metric.Metric<Type, In, Out>,
     f: (duration: Duration.Duration) => In
-  ) => Effect.Effect<R, E, A>
+  ) => Effect.Effect<A, E, R>
 >(3, (self, metric, f) =>
   Clock.clockWith((clock) => {
     const startTime = clock.unsafeCurrentTimeNanos()
@@ -426,13 +425,13 @@ export const trackDurationWith = dual<
 export const trackError = dual<
   <Type, In, Out>(
     metric: Metric.Metric<Type, In, Out>
-  ) => <R, E extends In, A>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  ) => <R, E extends In, A>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
   <R, E extends In, A, Type, In, Out>(
-    self: Effect.Effect<R, E, A>,
+    self: Effect.Effect<A, E, R>,
     metric: Metric.Metric<Type, In, Out>
-  ) => Effect.Effect<R, E, A>
+  ) => Effect.Effect<A, E, R>
 >(2, <R, E extends In, A, Type, In, Out>(
-  self: Effect.Effect<R, E, A>,
+  self: Effect.Effect<A, E, R>,
   metric: Metric.Metric<Type, In, Out>
 ) => trackErrorWith(self, metric, (a: In) => a))
 
@@ -441,18 +440,18 @@ export const trackErrorWith = dual<
   <Type, In, Out, In2>(
     metric: Metric.Metric<Type, In, Out>,
     f: (error: In2) => In
-  ) => <R, E extends In2, A>(effect: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
+  ) => <R, E extends In2, A>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
   <R, E extends In2, A, Type, In, Out, In2>(
-    self: Effect.Effect<R, E, A>,
+    self: Effect.Effect<A, E, R>,
     metric: Metric.Metric<Type, In, Out>,
     f: (error: In2) => In
-  ) => Effect.Effect<R, E, A>
+  ) => Effect.Effect<A, E, R>
 >(3, <R, E extends In2, A, Type, In, Out, In2>(
-  self: Effect.Effect<R, E, A>,
+  self: Effect.Effect<A, E, R>,
   metric: Metric.Metric<Type, In, Out>,
   f: (error: In2) => In
 ) => {
-  const updater = (error: E): Effect.Effect<never, never, void> => update(metric, f(error))
+  const updater = (error: E): Effect.Effect<void> => update(metric, f(error))
   return _effect.tapError(self, updater)
 })
 
@@ -460,13 +459,13 @@ export const trackErrorWith = dual<
 export const trackSuccess = dual<
   <Type, In, Out>(
     metric: Metric.Metric<Type, In, Out>
-  ) => <R, E, A extends In>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A extends In, Type, In, Out>(
-    self: Effect.Effect<R, E, A>,
+  ) => <A extends In, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A extends In, E, R, Type, In, Out>(
+    self: Effect.Effect<A, E, R>,
     metric: Metric.Metric<Type, In, Out>
-  ) => Effect.Effect<R, E, A>
->(2, <R, E, A extends In, Type, In, Out>(
-  self: Effect.Effect<R, E, A>,
+  ) => Effect.Effect<A, E, R>
+>(2, <A extends In, E, R, Type, In, Out>(
+  self: Effect.Effect<A, E, R>,
   metric: Metric.Metric<Type, In, Out>
 ) => trackSuccessWith(self, metric, (a: In) => a))
 
@@ -475,25 +474,25 @@ export const trackSuccessWith = dual<
   <Type, In, Out, In2>(
     metric: Metric.Metric<Type, In, Out>,
     f: (value: In2) => In
-  ) => <R, E, A extends In2>(self: Effect.Effect<R, E, A>) => Effect.Effect<R, E, A>,
-  <R, E, A extends In2, Type, In, Out, In2>(
-    self: Effect.Effect<R, E, A>,
+  ) => <A extends In2, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A extends In2, E, R, Type, In, Out, In2>(
+    self: Effect.Effect<A, E, R>,
     metric: Metric.Metric<Type, In, Out>,
     f: (value: In2) => In
-  ) => Effect.Effect<R, E, A>
->(3, <R, E, A extends In2, Type, In, Out, In2>(
-  self: Effect.Effect<R, E, A>,
+  ) => Effect.Effect<A, E, R>
+>(3, <A extends In2, E, R, Type, In, Out, In2>(
+  self: Effect.Effect<A, E, R>,
   metric: Metric.Metric<Type, In, Out>,
   f: (value: In2) => In
 ) => {
-  const updater = (value: A): Effect.Effect<never, never, void> => update(metric, f(value))
+  const updater = (value: A): Effect.Effect<void> => update(metric, f(value))
   return core.tap(self, updater)
 })
 
 /* @internal */
 export const update = dual<
-  <In>(input: In) => <Type, Out>(self: Metric.Metric<Type, In, Out>) => Effect.Effect<never, never, void>,
-  <Type, In, Out>(self: Metric.Metric<Type, In, Out>, input: In) => Effect.Effect<never, never, void>
+  <In>(input: In) => <Type, Out>(self: Metric.Metric<Type, In, Out>) => Effect.Effect<void>,
+  <Type, In, Out>(self: Metric.Metric<Type, In, Out>, input: In) => Effect.Effect<void>
 >(2, (self, input) =>
   core.fiberRefGetWith(
     core.currentMetricLabels,
@@ -503,7 +502,7 @@ export const update = dual<
 /* @internal */
 export const value = <Type, In, Out>(
   self: Metric.Metric<Type, In, Out>
-): Effect.Effect<never, never, Out> =>
+): Effect.Effect<Out> =>
   core.fiberRefGetWith(
     core.currentMetricLabels,
     (tags) => core.sync(() => self.unsafeValue(tags))
@@ -543,6 +542,6 @@ export const zip = dual<
 export const unsafeSnapshot = (): ReadonlyArray<MetricPair.MetricPair.Untyped> => globalMetricRegistry.snapshot()
 
 /** @internal */
-export const snapshot: Effect.Effect<never, never, ReadonlyArray<MetricPair.MetricPair.Untyped>> = core.sync(
+export const snapshot: Effect.Effect<ReadonlyArray<MetricPair.MetricPair.Untyped>> = core.sync(
   unsafeSnapshot
 )

package/src/internal/pool.ts

@@ -39,9 +39,9 @@ interface PoolState {
   readonly free: number
 }
 
-interface Attempted<E, A> {
-  readonly result: Exit.Exit<E, A>
-  readonly finalizer: Effect.Effect<never, never, unknown>
+interface Attempted<A, E> {
+  readonly result: Exit.Exit<A, E>
+  readonly finalizer: Effect.Effect<unknown>
 }
 
 /**
@@ -52,20 +52,20 @@ interface Strategy<S, R, E, A> {
   /**
    * Describes how the initial state of the strategy should be allocated.
    */
-  initial(): Effect.Effect<R, never, S>
+  initial(): Effect.Effect<S, never, R>
   /**
    * Describes how the state of the strategy should be updated when an item is
    * added to the pool or returned to the pool.
    */
-  track(state: S, attempted: Exit.Exit<E, A>): Effect.Effect<never, never, void>
+  track(state: S, attempted: Exit.Exit<A, E>): Effect.Effect<void>
   /**
    * Describes how excess items that are not being used should shrink down.
    */
   run(
     state: S,
-    getExcess: Effect.Effect<never, never, number>,
-    shrink: Effect.Effect<never, never, void>
-  ): Effect.Effect<never, never, void>
+    getExcess: Effect.Effect<number>,
+    shrink: Effect.Effect<void>
+  ): Effect.Effect<void>
 }
 
 /**
@@ -74,13 +74,13 @@ interface Strategy<S, R, E, A> {
  * nothing to do.
  */
 class NoneStrategy implements Strategy<unknown, never, never, never> {
-  initial(): Effect.Effect<never, never, void> {
+  initial(): Effect.Effect<void> {
     return core.unit
   }
-  track(): Effect.Effect<never, never, void> {
+  track(): Effect.Effect<void> {
     return core.unit
   }
-  run(): Effect.Effect<never, never, void> {
+  run(): Effect.Effect<void> {
     return core.unit
   }
 }
@@ -91,7 +91,7 @@ class NoneStrategy implements Strategy<unknown, never, never, never> {
  */
 class TimeToLiveStrategy implements Strategy<readonly [Clock.Clock, Ref.Ref<number>], never, never, never> {
   constructor(readonly timeToLive: Duration.Duration) {}
-  initial(): Effect.Effect<never, never, readonly [Clock.Clock, Ref.Ref<number>]> {
+  initial(): Effect.Effect<readonly [Clock.Clock, Ref.Ref<number>]> {
     return core.flatMap(effect.clock, (clock) =>
       core.flatMap(clock.currentTimeMillis, (now) =>
         core.map(
@@ -99,7 +99,7 @@ class TimeToLiveStrategy implements Strategy<readonly [Clock.Clock, Ref.Ref<numb
           (ref) => [clock, ref] as const
         )))
   }
-  track(state: readonly [Clock.Clock, Ref.Ref<number>]): Effect.Effect<never, never, void> {
+  track(state: readonly [Clock.Clock, Ref.Ref<number>]): Effect.Effect<void> {
     return core.asUnit(core.flatMap(
       state[0].currentTimeMillis,
       (now) => ref.set(state[1], now)
@@ -107,9 +107,9 @@ class TimeToLiveStrategy implements Strategy<readonly [Clock.Clock, Ref.Ref<numb
   }
   run(
     state: readonly [Clock.Clock, Ref.Ref<number>],
-    getExcess: Effect.Effect<never, never, number>,
-    shrink: Effect.Effect<never, never, void>
-  ): Effect.Effect<never, never, void> {
+    getExcess: Effect.Effect<number>,
+    shrink: Effect.Effect<void>
+  ): Effect.Effect<void> {
     return core.flatMap(getExcess, (excess) =>
       excess <= 0
         ? core.zipRight(
@@ -133,17 +133,17 @@ class TimeToLiveStrategy implements Strategy<readonly [Clock.Clock, Ref.Ref<numb
   }
 }
 
-class PoolImpl<in out E, in out A> implements Pool.Pool<E, A> {
+class PoolImpl<in out A, in out E> implements Pool.Pool<A, E> {
   readonly [PoolTypeId] = poolVariance
   constructor(
-    readonly creator: Effect.Effect<Scope.Scope, E, A>,
+    readonly creator: Effect.Effect<A, E, Scope.Scope>,
     readonly min: number,
     readonly max: number,
     readonly isShuttingDown: Ref.Ref<boolean>,
     readonly state: Ref.Ref<PoolState>,
-    readonly items: Queue.Queue<Attempted<E, A>>,
+    readonly items: Queue.Queue<Attempted<A, E>>,
     readonly invalidated: Ref.Ref<HashSet.HashSet<A>>,
-    readonly track: (exit: Exit.Exit<E, A>) => Effect.Effect<never, never, unknown>
+    readonly track: (exit: Exit.Exit<A, E>) => Effect.Effect<unknown>
   ) {}
 
   [Hash.symbol](): number {
@@ -161,24 +161,24 @@ class PoolImpl<in out E, in out A> implements Pool.Pool<E, A> {
 
   [Equal.symbol](that: unknown): boolean {
     return isPool(that) &&
-      Equal.equals(this.creator, (that as PoolImpl<E, A>).creator) &&
-      this.min === (that as PoolImpl<E, A>).min &&
-      this.max === (that as PoolImpl<E, A>).max &&
-      Equal.equals(this.isShuttingDown, (that as PoolImpl<E, A>).isShuttingDown) &&
-      Equal.equals(this.state, (that as PoolImpl<E, A>).state) &&
-      Equal.equals(this.items, (that as PoolImpl<E, A>).items) &&
-      Equal.equals(this.invalidated, (that as PoolImpl<E, A>).invalidated) &&
-      Equal.equals(this.track, (that as PoolImpl<E, A>).track)
+      Equal.equals(this.creator, (that as PoolImpl<A, E>).creator) &&
+      this.min === (that as PoolImpl<A, E>).min &&
+      this.max === (that as PoolImpl<A, E>).max &&
+      Equal.equals(this.isShuttingDown, (that as PoolImpl<A, E>).isShuttingDown) &&
+      Equal.equals(this.state, (that as PoolImpl<A, E>).state) &&
+      Equal.equals(this.items, (that as PoolImpl<A, E>).items) &&
+      Equal.equals(this.invalidated, (that as PoolImpl<A, E>).invalidated) &&
+      Equal.equals(this.track, (that as PoolImpl<A, E>).track)
   }
 
   pipe() {
     return pipeArguments(this, arguments)
   }
 
-  get get(): Effect.Effect<Scope.Scope, E, A> {
+  get get(): Effect.Effect<A, E, Scope.Scope> {
     const acquire = (
-      restore: <RX, EX, AX>(effect: Effect.Effect<RX, EX, AX>) => Effect.Effect<RX, EX, AX>
-    ): Effect.Effect<never, never, Attempted<E, A>> =>
+      restore: <AX, EX, RX>(effect: Effect.Effect<AX, EX, RX>) => Effect.Effect<AX, EX, RX>
+    ): Effect.Effect<Attempted<A, E>> =>
       core.flatMap(ref.get(this.isShuttingDown), (down) =>
         down
           ? core.interrupt
@@ -214,7 +214,7 @@ class PoolImpl<in out E, in out A> implements Pool.Pool<E, A> {
             return [core.interrupt, state] as const
           })))
 
-    const release = (attempted: Attempted<E, A>): Effect.Effect<never, never, unknown> =>
+    const release = (attempted: Attempted<A, E>): Effect.Effect<unknown> =>
       core.exitMatch(attempted.result, {
         onFailure: () =>
           core.flatten(ref.modify(this.state, (state) => {
@@ -252,22 +252,22 @@ class PoolImpl<in out E, in out A> implements Pool.Pool<E, A> {
     )
   }
 
-  invalidate(item: A): Effect.Effect<never, never, void> {
+  invalidate(item: A): Effect.Effect<void> {
     return ref.update(this.invalidated, HashSet.add(item))
   }
 }
 
-const allocate = <E, A>(
-  self: PoolImpl<E, A>,
-  restore: <RX, EX, AX>(effect: Effect.Effect<RX, EX, AX>) => Effect.Effect<RX, EX, AX>
-): Effect.Effect<never, never, unknown> =>
+const allocate = <A, E>(
+  self: PoolImpl<A, E>,
+  restore: <AX, EX, RX>(effect: Effect.Effect<AX, EX, RX>) => Effect.Effect<AX, EX, RX>
+): Effect.Effect<unknown> =>
   core.flatMap(fiberRuntime.scopeMake(), (scope) =>
     core.flatMap(
       core.exit(restore(fiberRuntime.scopeExtend(self.creator, scope))),
       (exit) =>
         core.flatMap(
-          core.succeed<Attempted<E, A>>({
-            result: exit as Exit.Exit<E, A>,
+          core.succeed<Attempted<A, E>>({
+            result: exit as Exit.Exit<A, E>,
             finalizer: core.scopeClose(scope, core.exitSucceed(void 0))
           }),
           (attempted) =>
@@ -280,20 +280,20 @@ const allocate = <E, A>(
         )
     ))
 
-const allocateUinterruptible = <E, A>(
-  self: PoolImpl<E, A>
-): Effect.Effect<never, never, unknown> => core.uninterruptibleMask((restore) => allocate(self, restore))
+const allocateUinterruptible = <A, E>(
+  self: PoolImpl<A, E>
+): Effect.Effect<unknown> => core.uninterruptibleMask((restore) => allocate(self, restore))
 
 /**
  * Returns the number of items in the pool in excess of the minimum size.
  */
-const excess = <E, A>(self: PoolImpl<E, A>): Effect.Effect<never, never, number> =>
+const excess = <A, E>(self: PoolImpl<A, E>): Effect.Effect<number> =>
   core.map(ref.get(self.state), (state) => state.size - Math.min(self.min, state.free))
 
-const finalizeInvalid = <E, A>(
-  self: PoolImpl<E, A>,
-  attempted: Attempted<E, A>
-): Effect.Effect<never, never, unknown> =>
+const finalizeInvalid = <A, E>(
+  self: PoolImpl<A, E>,
+  attempted: Attempted<A, E>
+): Effect.Effect<unknown> =>
   pipe(
     forEach(attempted, (a) => ref.update(self.invalidated, HashSet.remove(a))),
     core.zipRight(attempted.finalizer),
@@ -311,7 +311,7 @@ const finalizeInvalid = <E, A>(
  * Gets items from the pool and shuts them down as long as there are items
  * free, signalling shutdown of the pool if the pool is empty.
  */
-const getAndShutdown = <E, A>(self: PoolImpl<E, A>): Effect.Effect<never, never, void> =>
+const getAndShutdown = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
   core.flatten(ref.modify(self.state, (state) => {
     if (state.free > 0) {
       return [
@@ -337,7 +337,7 @@ const getAndShutdown = <E, A>(self: PoolImpl<E, A>): Effect.Effect<never, never,
 /**
  * Begins pre-allocating pool entries based on minimum pool size.
  */
-const initialize = <E, A>(self: PoolImpl<E, A>): Effect.Effect<never, never, void> =>
+const initialize = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
   fiberRuntime.replicateEffect(
     core.uninterruptibleMask((restore) =>
       core.flatten(ref.modify(self.state, (state) => {
@@ -357,7 +357,7 @@ const initialize = <E, A>(self: PoolImpl<E, A>): Effect.Effect<never, never, voi
 /**
  * Shrinks the pool down, but never to less than the minimum size.
  */
-const shrink = <E, A>(self: PoolImpl<E, A>): Effect.Effect<never, never, void> =>
+const shrink = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
   core.uninterruptible(
     core.flatten(ref.modify(self.state, (state) => {
       if (state.size > self.min && state.free > 0) {
@@ -379,50 +379,50 @@ const shrink = <E, A>(self: PoolImpl<E, A>): Effect.Effect<never, never, void> =
     }))
   )
 
-const shutdown = <E, A>(self: PoolImpl<E, A>): Effect.Effect<never, never, void> =>
+const shutdown = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
   core.flatten(ref.modify(self.isShuttingDown, (down) =>
     down
       ? [queue.awaitShutdown(self.items), true] as const
       : [core.zipRight(getAndShutdown(self), queue.awaitShutdown(self.items)), true]))
 
-const isFailure = <E, A>(self: Attempted<E, A>): boolean => core.exitIsFailure(self.result)
+const isFailure = <A, E>(self: Attempted<A, E>): boolean => core.exitIsFailure(self.result)
 
-const forEach = <E, A, R, E2>(
-  self: Attempted<E, A>,
-  f: (a: A) => Effect.Effect<R, E2, unknown>
-): Effect.Effect<R, E2, unknown> =>
+const forEach = <E, A, E2, R>(
+  self: Attempted<A, E>,
+  f: (a: A) => Effect.Effect<unknown, E2, R>
+): Effect.Effect<unknown, E2, R> =>
   core.exitMatch(self.result, {
     onFailure: () => core.unit,
     onSuccess: f
   })
 
-const toEffect = <E, A>(self: Attempted<E, A>): Effect.Effect<never, E, A> => self.result
+const toEffect = <A, E>(self: Attempted<A, E>): Effect.Effect<A, E> => self.result
 
 /**
  * A more powerful variant of `make` that allows specifying a `Strategy` that
  * describes how a pool whose excess items are not being used will be shrunk
  * down to the minimum size.
  */
-const makeWith = <R, E, A, S, R2>(
+const makeWith = <A, E, R, S, R2>(
   options: {
-    readonly acquire: Effect.Effect<R, E, A>
+    readonly acquire: Effect.Effect<A, E, R>
     readonly min: number
     readonly max: number
     readonly strategy: Strategy<S, R2, E, A>
   }
-): Effect.Effect<R | R2 | Scope.Scope, never, Pool.Pool<E, A>> =>
+): Effect.Effect<Pool.Pool<A, E>, never, R | R2 | Scope.Scope> =>
   core.uninterruptibleMask((restore) =>
     pipe(
       fiberRuntime.all([
         core.context<R>(),
         ref.make(false),
         ref.make<PoolState>({ size: 0, free: 0 }),
-        queue.bounded<Attempted<E, A>>(options.max),
+        queue.bounded<Attempted<A, E>>(options.max),
         ref.make(HashSet.empty<A>()),
         options.strategy.initial()
       ]),
       core.flatMap(([context, down, state, items, inv, initial]) => {
-        const pool = new PoolImpl<E, A>(
+        const pool = new PoolImpl<A, E>(
           core.mapInputContext(options.acquire, (old) => Context.merge(old)(context)),
           options.min,
           options.max,
@@ -447,7 +447,7 @@ const makeWith = <R, E, A, S, R2>(
                 )
             )
           ),
-          core.as<Pool.Pool<E, A>>(pool)
+          core.as<Pool.Pool<A, E>>(pool)
         )
       })
     )
@@ -457,12 +457,12 @@ const makeWith = <R, E, A, S, R2>(
 export const isPool = (u: unknown): u is Pool.Pool<unknown, unknown> => hasProperty(u, PoolTypeId)
 
 /** @internal */
-export const make = <R, E, A>(
+export const make = <A, E, R>(
   options: {
-    readonly acquire: Effect.Effect<R, E, A>
+    readonly acquire: Effect.Effect<A, E, R>
     readonly size: number
   }
-): Effect.Effect<R | Scope.Scope, never, Pool.Pool<E, A>> =>
+): Effect.Effect<Pool.Pool<A, E>, never, R | Scope.Scope> =>
   makeWith({
     acquire: options.acquire,
     min: options.size,
@@ -471,14 +471,14 @@ export const make = <R, E, A>(
   })
 
 /** @internal */
-export const makeWithTTL = <R, E, A>(
+export const makeWithTTL = <A, E, R>(
   options: {
-    readonly acquire: Effect.Effect<R, E, A>
+    readonly acquire: Effect.Effect<A, E, R>
     readonly min: number
     readonly max: number
     readonly timeToLive: Duration.DurationInput
   }
-): Effect.Effect<R | Scope.Scope, never, Pool.Pool<E, A>> =>
+): Effect.Effect<Pool.Pool<A, E>, never, R | Scope.Scope> =>
   makeWith({
     acquire: options.acquire,
     min: options.min,
@@ -487,10 +487,10 @@ export const makeWithTTL = <R, E, A>(
   })
 
 /** @internal */
-export const get = <E, A>(self: Pool.Pool<E, A>): Effect.Effect<Scope.Scope, E, A> => self.get
+export const get = <A, E>(self: Pool.Pool<A, E>): Effect.Effect<A, E, Scope.Scope> => self.get
 
 /** @internal */
 export const invalidate = dual<
-  <A>(value: A) => <E>(self: Pool.Pool<E, A>) => Effect.Effect<Scope.Scope, never, void>,
-  <E, A>(self: Pool.Pool<E, A>, value: A) => Effect.Effect<Scope.Scope, never, void>
+  <A>(value: A) => <E>(self: Pool.Pool<A, E>) => Effect.Effect<void, never, Scope.Scope>,
+  <A, E>(self: Pool.Pool<A, E>, value: A) => Effect.Effect<void, never, Scope.Scope>
 >(2, (self, value) => self.invalidate(value))