effect 2.3.7 → 2.4.0

package/src/internal/layer.ts

@@ -504,10 +504,10 @@ export const failCauseSync = <E>(evaluate: LazyArg<Cause.Cause<E>>): Layer.Layer
 
 /** @internal */
 export const flatMap = dual<
-  <A, R2, E2, A2>(
+  <A, A2, E2, R2>(
     f: (context: Context.Context<A>) => Layer.Layer<A2, E2, R2>
-  ) => <R, E>(self: Layer.Layer<A, E, R>) => Layer.Layer<A2, E | E2, R | R2>,
-  <R, E, A, R2, E2, A2>(
+  ) => <E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A2, E | E2, R | R2>,
+  <A, E, R, A2, E2, R2>(
     self: Layer.Layer<A, E, R>,
     f: (context: Context.Context<A>) => Layer.Layer<A2, E2, R2>
   ) => Layer.Layer<A2, E | E2, R | R2>
@@ -515,12 +515,12 @@ export const flatMap = dual<
 
 /** @internal */
 export const flatten = dual<
-  <R2, E2, A, I>(
+  <I, A, E2, R2>(
     tag: Context.Tag<I, Layer.Layer<A, E2, R2>>
-  ) => <R, E>(
+  ) => <E, R>(
     self: Layer.Layer<I, E, R>
   ) => Layer.Layer<A, E | E2, R | R2>,
-  <R, E, A, R2, E2, I>(
+  <I, E, R, A, E2, R2>(
     self: Layer.Layer<I, E, R>,
     tag: Context.Tag<I, Layer.Layer<A, E2, R2>>
   ) => Layer.Layer<A, E | E2, R | R2>
@@ -553,7 +553,7 @@ export const fromEffect = dual<
 })
 
 /** @internal */
-export const fromEffectDiscard = <_, E, R>(effect: Effect.Effect<_, E, R>) =>
+export const fromEffectDiscard = <X, E, R>(effect: Effect.Effect<X, E, R>) =>
   fromEffectContext(core.map(effect, () => Context.empty()))
 
 /** @internal */
@@ -569,7 +569,7 @@ export function fromEffectContext<A, E, R>(
 /** @internal */
 export const fiberRefLocally = dual<
   <X>(ref: FiberRef<X>, value: X) => <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
-  <R, E, A, X>(self: Layer.Layer<A, E, R>, ref: FiberRef<X>, value: X) => Layer.Layer<A, E, R>
+  <A, E, R, X>(self: Layer.Layer<A, E, R>, ref: FiberRef<X>, value: X) => Layer.Layer<A, E, R>
 >(3, (self, ref, value) => locallyEffect(self, core.fiberRefLocally(ref, value)))
 
 /** @internal */
@@ -592,7 +592,7 @@ export const locallyEffect = dual<
 /** @internal */
 export const fiberRefLocallyWith = dual<
   <X>(ref: FiberRef<X>, value: (_: X) => X) => <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E, R>,
-  <R, E, A, X>(self: Layer.Layer<A, E, R>, ref: FiberRef<X>, value: (_: X) => X) => Layer.Layer<A, E, R>
+  <A, E, R, X>(self: Layer.Layer<A, E, R>, ref: FiberRef<X>, value: (_: X) => X) => Layer.Layer<A, E, R>
 >(3, (self, ref, value) => locallyEffect(self, core.fiberRefLocallyWith(ref, value)))
 
 /** @internal */
@@ -624,8 +624,8 @@ export const launch = <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>): Effect.Ef
 export const map = dual<
   <A, B>(
     f: (context: Context.Context<A>) => Context.Context<B>
-  ) => <R, E>(self: Layer.Layer<A, E, R>) => Layer.Layer<B, E, R>,
-  <R, E, A, B>(
+  ) => <E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<B, E, R>,
+  <A, E, R, B>(
     self: Layer.Layer<A, E, R>,
     f: (context: Context.Context<A>) => Context.Context<B>
   ) => Layer.Layer<B, E, R>
@@ -633,19 +633,19 @@ export const map = dual<
 
 /** @internal */
 export const mapError = dual<
-  <E, E2>(f: (error: E) => E2) => <R, A>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E2, R>,
-  <R, E, A, E2>(self: Layer.Layer<A, E, R>, f: (error: E) => E2) => Layer.Layer<A, E2, R>
+  <E, E2>(f: (error: E) => E2) => <A, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A, E2, R>,
+  <A, E, R, E2>(self: Layer.Layer<A, E, R>, f: (error: E) => E2) => Layer.Layer<A, E2, R>
 >(2, (self, f) => catchAll(self, (error) => failSync(() => f(error))))
 
 /** @internal */
 export const matchCause = dual<
-  <E, A, R2, E2, A2, R3, E3, A3>(
+  <E, A2, E2, R2, A, A3, E3, R3>(
     options: {
       readonly onFailure: (cause: Cause.Cause<E>) => Layer.Layer<A2, E2, R2>
       readonly onSuccess: (context: Context.Context<A>) => Layer.Layer<A3, E3, R3>
     }
   ) => <R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A2 & A3, E2 | E3, R | R2 | R3>,
-  <R, E, A, R2, E2, A2, R3, E3, A3>(
+  <A, E, R, A2, E2, R2, A3, E3, R3>(
     self: Layer.Layer<A, E, R>,
     options: {
       readonly onFailure: (cause: Cause.Cause<E>) => Layer.Layer<A2, E2, R2>
@@ -663,13 +663,13 @@ export const matchCause = dual<
 
 /** @internal */
 export const match = dual<
-  <E, R2, E2, A2, A, R3, E3, A3>(
+  <E, A2, E2, R2, A, A3, E3, R3>(
     options: {
       readonly onFailure: (error: E) => Layer.Layer<A2, E2, R2>
       readonly onSuccess: (context: Context.Context<A>) => Layer.Layer<A3, E3, R3>
     }
   ) => <R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A2 & A3, E2 | E3, R | R2 | R3>,
-  <R, E, A, R2, E2, A2, R3, E3, A3>(
+  <A, E, R, A2, E2, R2, A3, E3, R3>(
     self: Layer.Layer<A, E, R>,
     options: {
       readonly onFailure: (error: E) => Layer.Layer<A2, E2, R2>
@@ -740,10 +740,10 @@ export const orDie = <A, E, R>(self: Layer.Layer<A, E, R>): Layer.Layer<A, never
 
 /** @internal */
 export const orElse = dual<
-  <R2, E2, A2>(
+  <A2, E2, R2>(
     that: LazyArg<Layer.Layer<A2, E2, R2>>
   ) => <A, E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<A & A2, E | E2, R | R2>,
-  <R, E, A, R2, E2, A2>(
+  <A, E, R, A2, E2, R2>(
     self: Layer.Layer<A, E, R>,
     that: LazyArg<Layer.Layer<A2, E2, R2>>
   ) => Layer.Layer<A & A2, E | E2, R | R2>
@@ -770,14 +770,14 @@ export const project = dual<
 
 /** @internal */
 export const retry = dual<
-  <RIn2, E, X>(
-    schedule: Schedule.Schedule<RIn2, E, X>
-  ) => <RIn, ROut>(
+  <X, E, RIn2>(
+    schedule: Schedule.Schedule<X, E, RIn2>
+  ) => <ROut, RIn>(
     self: Layer.Layer<ROut, E, RIn>
   ) => Layer.Layer<ROut, E, RIn | RIn2>,
-  <RIn, E, ROut, RIn2, X>(
+  <ROut, E, RIn, X, RIn2>(
     self: Layer.Layer<ROut, E, RIn>,
-    schedule: Schedule.Schedule<RIn2, E, X>
+    schedule: Schedule.Schedule<X, E, RIn2>
   ) => Layer.Layer<ROut, E, RIn | RIn2>
 >(2, (self, schedule) =>
   suspend(() => {
@@ -790,10 +790,9 @@ export const retry = dual<
     )
   }))
 
-/** @internal */
-const retryLoop = <RIn, E, ROut, RIn2, X>(
+const retryLoop = <ROut, E, RIn, X, RIn2>(
   self: Layer.Layer<ROut, E, RIn>,
-  schedule: Schedule.Schedule<RIn2, E, X>,
+  schedule: Schedule.Schedule<X, E, RIn2>,
   stateTag: Context.Tag<{ state: unknown }, { state: unknown }>,
   state: unknown
 ): Layer.Layer<ROut, E, RIn | RIn2> => {
@@ -808,9 +807,8 @@ const retryLoop = <RIn, E, ROut, RIn2, X>(
   )
 }
 
-/** @internal */
-const retryUpdate = <RIn, E, X>(
-  schedule: Schedule.Schedule<RIn, E, X>,
+const retryUpdate = <X, E, RIn>(
+  schedule: Schedule.Schedule<X, E, RIn>,
   stateTag: Context.Tag<{ state: unknown }, { state: unknown }>,
   error: E,
   state: unknown
@@ -840,10 +838,10 @@ const retryUpdate = <RIn, E, X>(
 export const scoped = dual<
   <T extends Context.Tag<any, any>>(
     tag: T
-  ) => <R, E>(
+  ) => <E, R>(
     effect: Effect.Effect<Context.Tag.Service<T>, E, R>
   ) => Layer.Layer<Context.Tag.Identifier<T>, E, Exclude<R, Scope.Scope>>,
-  <T extends Context.Tag<any, any>, R, E>(
+  <T extends Context.Tag<any, any>, E, R>(
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E, R>
   ) => Layer.Layer<Context.Tag.Identifier<T>, E, Exclude<R, Scope.Scope>>
@@ -855,8 +853,8 @@ export const scoped = dual<
 })
 
 /** @internal */
-export const scopedDiscard = <_, E, R>(
-  effect: Effect.Effect<_, E, R>
+export const scopedDiscard = <X, E, R>(
+  effect: Effect.Effect<X, E, R>
 ): Layer.Layer<never, E, Exclude<R, Scope.Scope>> => scopedContext(pipe(effect, core.as(Context.empty())))
 
 /** @internal */
@@ -1054,11 +1052,11 @@ export const provideMerge = dual<
 
 /** @internal */
 export const zipWith = dual<
-  <R2, E2, B, A, C>(
+  <B, E2, R2, A, C>(
     that: Layer.Layer<B, E2, R2>,
     f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
-  ) => <R, E>(self: Layer.Layer<A, E, R>) => Layer.Layer<C, E | E2, R | R2>,
-  <R, E, R2, E2, B, A, C>(
+  ) => <E, R>(self: Layer.Layer<A, E, R>) => Layer.Layer<C, E | E2, R | R2>,
+  <A, E, R, B, E2, R2, C>(
     self: Layer.Layer<A, E, R>,
     that: Layer.Layer<B, E2, R2>,
     f: (a: Context.Context<A>, b: Context.Context<B>) => Context.Context<C>
@@ -1074,7 +1072,7 @@ export const zipWith = dual<
   }))
 
 /** @internal */
-export const unwrapEffect = <R, E, R1, E1, A>(
+export const unwrapEffect = <A, E1, R1, E, R>(
   self: Effect.Effect<Layer.Layer<A, E1, R1>, E, R>
 ): Layer.Layer<A, E | E1, R | R1> => {
   const tag = Context.GenericTag<Layer.Layer<A, E1, R1>>("effect/Layer/unwrapEffect/Layer.Layer<R1, E1, A>")
@@ -1082,7 +1080,7 @@ export const unwrapEffect = <R, E, R1, E1, A>(
 }
 
 /** @internal */
-export const unwrapScoped = <R, E, R1, E1, A>(
+export const unwrapScoped = <A, E1, R1, E, R>(
   self: Effect.Effect<Layer.Layer<A, E1, R1>, E, R>
 ): Layer.Layer<A, E | E1, R1 | Exclude<R, Scope.Scope>> => {
   const tag = Context.GenericTag<Layer.Layer<A, E1, R1>>("effect/Layer/unwrapScoped/Layer.Layer<R1, E1, A>")
@@ -1139,10 +1137,10 @@ export const withParentSpan = dual<
 // circular with Effect
 
 const provideSomeLayer = dual<
-  <R2, E2, A2>(
+  <A2, E2, R2>(
     layer: Layer.Layer<A2, E2, R2>
   ) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R2 | Exclude<R, A2>>,
-  <R, E, A, R2, E2, A2>(
+  <A, E, R, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
     layer: Layer.Layer<A2, E2, R2>
   ) => Effect.Effect<A, E | E2, R2 | Exclude<R, A2>>
@@ -1188,9 +1186,9 @@ const provideSomeRuntime = dual<
 /** @internal */
 export const effect_provide = dual<
   {
-    <R2, E2, R3>(
-      layer: Layer.Layer<R3, E2, R2>
-    ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, R2 | Exclude<R, R3>>
+    <ROut, E2, RIn>(
+      layer: Layer.Layer<ROut, E2, RIn>
+    ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, RIn | Exclude<R, ROut>>
     <R2>(
       context: Context.Context<R2>
     ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, R2>>
@@ -1199,28 +1197,28 @@ export const effect_provide = dual<
     ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, R2>>
   },
   {
-    <A, E, R, R2, E2, R3>(
+    <A, E, R, ROut, E2, RIn>(
       self: Effect.Effect<A, E, R>,
-      layer: Layer.Layer<R3, E2, R2>
-    ): Effect.Effect<A, E | E2, R2 | Exclude<R, R3>>
-    <R, E, A, R2>(
+      layer: Layer.Layer<ROut, E2, RIn>
+    ): Effect.Effect<A, E | E2, RIn | Exclude<R, ROut>>
+    <A, E, R, R2>(
       self: Effect.Effect<A, E, R>,
       context: Context.Context<R2>
     ): Effect.Effect<A, E, Exclude<R, R2>>
-    <R, E, A, R2>(
+    <A, E, R, R2>(
       self: Effect.Effect<A, E, R>,
       runtime: Runtime.Runtime<R2>
     ): Effect.Effect<A, E, Exclude<R, R2>>
   }
 >(
   2,
-  <A, E, R, R2>(
+  <A, E, R, ROut>(
     self: Effect.Effect<A, E, R>,
-    source: Layer.Layer<R2, any, any> | Context.Context<R2> | Runtime.Runtime<R2>
-  ): Effect.Effect<any, any, Exclude<R, R2>> =>
+    source: Layer.Layer<ROut, any, any> | Context.Context<ROut> | Runtime.Runtime<ROut>
+  ): Effect.Effect<any, any, Exclude<R, ROut>> =>
     isLayer(source)
-      ? provideSomeLayer(self, source as Layer.Layer<R2, any, any>)
+      ? provideSomeLayer(self, source as Layer.Layer<ROut, any, any>)
       : Context.isContext(source)
       ? core.provideSomeContext(self, source)
-      : provideSomeRuntime(self, source as Runtime.Runtime<R2>)
+      : provideSomeRuntime(self, source as Runtime.Runtime<ROut>)
 )

package/src/internal/matcher.ts

@@ -87,7 +87,7 @@ const ValueMatcherProto: Omit<
 
 function makeValueMatcher<I, R, RA, A, Pr>(
   provided: Pr,
-  value: Either.Either<RA, Pr>
+  value: Either.Either<Pr, RA>
 ): ValueMatcher<I, R, RA, A, Pr> {
   const matcher = Object.create(ValueMatcherProto)
   matcher.provided = provided
@@ -514,8 +514,8 @@ export const orElseAbsurd = <I, R, RA, A, Pr>(
 /** @internal */
 export const either: <I, F, R, A, Pr>(
   self: Matcher<I, F, R, A, Pr>
-) => [Pr] extends [never] ? (input: I) => Either.Either<R, Unify<A>>
-  : Either.Either<R, Unify<A>> = (<I, R, RA, A>(self: Matcher<I, R, RA, A, I>) => {
+) => [Pr] extends [never] ? (input: I) => Either.Either<Unify<A>, R>
+  : Either.Either<Unify<A>, R> = (<I, R, RA, A>(self: Matcher<I, R, RA, A, I>) => {
     if (self._tag === "ValueMatcher") {
       return self.value
     }
@@ -523,7 +523,7 @@ export const either: <I, F, R, A, Pr>(
     const len = self.cases.length
     if (len === 1) {
       const _case = self.cases[0]
-      return (input: I): Either.Either<RA, A> => {
+      return (input: I): Either.Either<A, RA> => {
         if (_case._tag === "When" && _case.guard(input) === true) {
           return Either.right(_case.evaluate(input))
         } else if (_case._tag === "Not" && _case.guard(input) === false) {
@@ -532,7 +532,7 @@ export const either: <I, F, R, A, Pr>(
         return Either.left(input as any)
       }
     }
-    return (input: I): Either.Either<RA, A> => {
+    return (input: I): Either.Either<A, RA> => {
       for (let i = 0; i < len; i++) {
         const _case = self.cases[i]
         if (_case._tag === "When" && _case.guard(input) === true) {

package/src/internal/metric/keyType.ts

@@ -81,13 +81,14 @@ class CounterKeyType<A extends (number | bigint)> implements MetricKeyType.Metri
   }
 }
 
+const FrequencyKeyTypeHash = Hash.string(FrequencyKeyTypeSymbolKey)
+
 /** @internal */
 class FrequencyKeyType implements MetricKeyType.MetricKeyType.Frequency {
   readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
-  readonly [FrequencyKeyTypeTypeId]: MetricKeyType.FrequencyKeyTypeTypeId = FrequencyKeyTypeTypeId
-  readonly _hash = Hash.string(FrequencyKeyTypeSymbolKey);
+  readonly [FrequencyKeyTypeTypeId]: MetricKeyType.FrequencyKeyTypeTypeId = FrequencyKeyTypeTypeId;
   [Hash.symbol](): number {
-    return this._hash
+    return FrequencyKeyTypeHash
   }
   [Equal.symbol](that: unknown): boolean {
     return isFrequencyKey(that)
@@ -97,14 +98,15 @@ class FrequencyKeyType implements MetricKeyType.MetricKeyType.Frequency {
   }
 }
 
+const GaugeKeyTypeHash = Hash.string(GaugeKeyTypeSymbolKey)
+
 /** @internal */
 class GaugeKeyType<A extends (number | bigint)> implements MetricKeyType.MetricKeyType.Gauge<A> {
   readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
   readonly [GaugeKeyTypeTypeId]: MetricKeyType.GaugeKeyTypeTypeId = GaugeKeyTypeTypeId
   constructor(readonly bigint: boolean) {}
-  readonly _hash = Hash.string(GaugeKeyTypeSymbolKey);
   [Hash.symbol](): number {
-    return this._hash
+    return GaugeKeyTypeHash
   }
   [Equal.symbol](that: unknown): boolean {
     return isGaugeKey(that)

package/src/internal/metric/polling.ts

@@ -64,14 +64,14 @@ export const collectAll = <R, E, Out>(
 
 /** @internal */
 export const launch = dual<
-  <R2, A2>(
-    schedule: Schedule.Schedule<R2, unknown, A2>
+  <A2, R2>(
+    schedule: Schedule.Schedule<A2, unknown, R2>
   ) => <Type, In, R, E, Out>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>
   ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>,
-  <Type, In, R, E, Out, R2, A2>(
+  <Type, In, R, E, Out, A2, R2>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
-    schedule: Schedule.Schedule<R2, unknown, A2>
+    schedule: Schedule.Schedule<A2, unknown, R2>
   ) => Effect.Effect<Fiber.Fiber<A2, E>, never, R | R2 | Scope.Scope>
 >(2, (self, schedule) =>
   pipe(
@@ -92,14 +92,14 @@ export const pollAndUpdate = <Type, In, R, E, Out>(
 
 /** @internal */
 export const retry = dual<
-  <R2, E, _>(
-    policy: Schedule.Schedule<R2, E, _>
+  <X, E, R2>(
+    policy: Schedule.Schedule<X, E, R2>
   ) => <Type, In, R, Out>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>
   ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>,
-  <Type, In, R, Out, R2, E, _>(
+  <Type, In, R, E, Out, X, R2>(
     self: MetricPolling.MetricPolling<Type, In, R, E, Out>,
-    policy: Schedule.Schedule<R2, E, _>
+    policy: Schedule.Schedule<X, E, R2>
   ) => MetricPolling.MetricPolling<Type, In, R | R2, E, Out>
 >(2, (self, policy) => ({
   [MetricPollingTypeId]: MetricPollingTypeId,

package/src/internal/metric/state.ts

@@ -68,7 +68,8 @@ class CounterState<A extends (number | bigint)> implements MetricState.MetricSta
   [Hash.symbol](): number {
     return pipe(
       Hash.hash(CounterStateSymbolKey),
-      Hash.combine(Hash.hash(this.count))
+      Hash.combine(Hash.hash(this.count)),
+      Hash.cached(this)
     )
   }
   [Equal.symbol](that: unknown): boolean {
@@ -88,14 +89,11 @@ class FrequencyState implements MetricState.MetricState.Frequency {
   constructor(readonly occurrences: ReadonlyMap<string, number>) {}
   _hash: number | undefined;
   [Hash.symbol](): number {
-    if (this._hash !== undefined) {
-      return this._hash
-    }
-    this._hash = pipe(
+    return pipe(
       Hash.string(FrequencyStateSymbolKey),
-      Hash.combine(Hash.array(ReadonlyArray.fromIterable(this.occurrences.entries())))
+      Hash.combine(Hash.array(ReadonlyArray.fromIterable(this.occurrences.entries()))),
+      Hash.cached(this)
     )
-    return this._hash
   }
   [Equal.symbol](that: unknown): boolean {
     return isFrequencyState(that) && arrayEquals(
@@ -116,7 +114,8 @@ class GaugeState<A extends (number | bigint)> implements MetricState.MetricState
   [Hash.symbol](): number {
     return pipe(
       Hash.hash(GaugeStateSymbolKey),
-      Hash.combine(Hash.hash(this.value))
+      Hash.combine(Hash.hash(this.value)),
+      Hash.cached(this)
     )
   }
   [Equal.symbol](u: unknown): boolean {
@@ -145,7 +144,8 @@ export class HistogramState implements MetricState.MetricState.Histogram {
       Hash.combine(Hash.hash(this.count)),
       Hash.combine(Hash.hash(this.min)),
       Hash.combine(Hash.hash(this.max)),
-      Hash.combine(Hash.hash(this.sum))
+      Hash.combine(Hash.hash(this.sum)),
+      Hash.cached(this)
     )
   }
   [Equal.symbol](that: unknown): boolean {
@@ -181,7 +181,8 @@ export class SummaryState implements MetricState.MetricState.Summary {
       Hash.combine(Hash.hash(this.count)),
       Hash.combine(Hash.hash(this.min)),
       Hash.combine(Hash.hash(this.max)),
-      Hash.combine(Hash.hash(this.sum))
+      Hash.combine(Hash.hash(this.sum)),
+      Hash.cached(this)
     )
   }
   [Equal.symbol](that: unknown): boolean {

package/src/internal/metric.ts

@@ -425,12 +425,12 @@ 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<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E extends In, A, Type, In, Out>(
+  ) => <A, E extends In, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E extends In, R, Type, In, Out>(
     self: Effect.Effect<A, E, R>,
     metric: Metric.Metric<Type, In, Out>
   ) => Effect.Effect<A, E, R>
->(2, <R, E extends In, A, Type, In, Out>(
+>(2, <A, E extends In, R, Type, In, Out>(
   self: Effect.Effect<A, E, R>,
   metric: Metric.Metric<Type, In, Out>
 ) => trackErrorWith(self, metric, (a: In) => a))
@@ -440,13 +440,13 @@ 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<A, E, R>) => Effect.Effect<A, E, R>,
-  <R, E extends In2, A, Type, In, Out, In2>(
+  ) => <A, E extends In2, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  <A, E extends In2, R, Type, In, Out, In2>(
     self: Effect.Effect<A, E, R>,
     metric: Metric.Metric<Type, In, Out>,
     f: (error: In2) => In
   ) => Effect.Effect<A, E, R>
->(3, <R, E extends In2, A, Type, In, Out, In2>(
+>(3, <A, E extends In2, R, Type, In, Out, In2>(
   self: Effect.Effect<A, E, R>,
   metric: Metric.Metric<Type, In, Out>,
   f: (error: In2) => In

package/src/internal/option.ts

@@ -31,7 +31,7 @@ const SomeProto = Object.assign(Object.create(CommonProto), {
     return isOption(that) && isSome(that) && Equal.equals(that.value, this.value)
   },
   [Hash.symbol]<A>(this: Option.Some<A>) {
-    return Hash.combine(Hash.hash(this._tag))(Hash.hash(this.value))
+    return Hash.cached(this, Hash.combine(Hash.hash(this._tag))(Hash.hash(this.value)))
   },
   toJSON<A>(this: Option.Some<A>) {
     return {

package/src/internal/pool.ts

@@ -155,7 +155,8 @@ class PoolImpl<in out A, in out E> implements Pool.Pool<A, E> {
       Hash.combine(Hash.hash(this.state)),
       Hash.combine(Hash.hash(this.items)),
       Hash.combine(Hash.hash(this.invalidated)),
-      Hash.combine(Hash.hash(this.track))
+      Hash.combine(Hash.hash(this.track)),
+      Hash.cached(this)
     )
   }
 

package/src/internal/redBlackTree.ts

@@ -33,12 +33,12 @@ const redBlackTreeVariance = {
 
 const RedBlackTreeProto: RBT.RedBlackTree<unknown, unknown> = {
   [RedBlackTreeTypeId]: redBlackTreeVariance,
-  [Hash.symbol](): number {
+  [Hash.symbol](this: RBT.RedBlackTree<unknown, unknown>): number {
     let hash = Hash.hash(RedBlackTreeSymbolKey)
     for (const item of this) {
       hash ^= pipe(Hash.hash(item[0]), Hash.combine(Hash.hash(item[1])))
     }
-    return hash
+    return Hash.cached(this, hash)
   },
   [Equal.symbol]<K, V>(this: RedBlackTreeImpl<K, V>, that: unknown): boolean {
     if (isRedBlackTree(that)) {

package/src/internal/reloadable.ts

@@ -25,11 +25,11 @@ const reloadableVariance = {
 }
 
 /** @internal */
-export const auto = <Out extends Context.Tag<any, any>, In, E, R>(
+export const auto = <Out extends Context.Tag<any, any>, E, In, R>(
   tag: Out,
   options: {
     readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
-    readonly schedule: Schedule.Schedule<R, unknown, unknown>
+    readonly schedule: Schedule.Schedule<unknown, unknown, R>
   }
 ): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, R | In> =>
   _layer.scoped(
@@ -52,11 +52,11 @@ export const auto = <Out extends Context.Tag<any, any>, In, E, R>(
   )
 
 /** @internal */
-export const autoFromConfig = <Out extends Context.Tag<any, any>, In, E, R>(
+export const autoFromConfig = <Out extends Context.Tag<any, any>, E, In, R>(
   tag: Out,
   options: {
     readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
-    readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<R, unknown, unknown>
+    readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<unknown, unknown, R>
   }
 ): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, R | In> =>
   _layer.scoped(

package/src/internal/resource.ts

@@ -24,9 +24,9 @@ const resourceVariance = {
 }
 
 /** @internal */
-export const auto = <A, E, R, R2, Out>(
+export const auto = <A, E, R, Out, R2>(
   acquire: Effect.Effect<A, E, R>,
-  policy: Schedule.Schedule<R2, unknown, Out>
+  policy: Schedule.Schedule<Out, unknown, R2>
 ): Effect.Effect<Resource.Resource<A, E>, never, R | R2 | Scope.Scope> =>
   core.tap(manual(acquire), (manual) =>
     fiberRuntime.acquireRelease(

package/src/internal/runtime.ts

@@ -22,6 +22,7 @@ import * as core from "./core.js"
 import * as executionStrategy from "./executionStrategy.js"
 import * as FiberRuntime from "./fiberRuntime.js"
 import * as fiberScope from "./fiberScope.js"
+import { internalize } from "./internalize.js"
 import * as OpCodes from "./opCodes/effect.js"
 import * as runtimeFlags from "./runtimeFlags.js"
 import * as _supervisor from "./supervisor.js"
@@ -450,22 +451,34 @@ export const unsafeRunSyncExitEffect = unsafeRunSyncExit(defaultRuntime)
 // circular with Effect
 
 /** @internal */
-export const asyncEffect = <A, E, R, X, E2, R2>(
-  register: (callback: (_: Effect.Effect<A, E, R>) => void) => Effect.Effect<X, E2, R2>
-): Effect.Effect<A, E | E2, R | R2> =>
-  core.flatMap(
-    core.deferredMake<A, E | E2>(),
-    (deferred) =>
-      core.flatMap(runtime<R | R2>(), (runtime) =>
-        core.uninterruptibleMask((restore) =>
-          core.zipRight(
-            FiberRuntime.fork(restore(
-              core.catchAllCause(
-                register((cb) => unsafeRunCallback(runtime)(core.intoDeferred(cb, deferred))),
-                (cause) => core.deferredFailCause(deferred, cause)
-              )
-            )),
-            restore(core.deferredAwait(deferred))
-          )
-        ))
-  )
+export const asyncEffect = <A, E, R, R3, E2, R2>(
+  register: (
+    callback: (_: Effect.Effect<A, E, R>) => void
+  ) => Effect.Effect<Effect.Effect<void, never, R3> | void, E2, R2>
+): Effect.Effect<A, E | E2, R | R2 | R3> =>
+  core.suspend(() => {
+    internalize(register)
+    let cleanup: Effect.Effect<void, never, R3> | void = undefined
+    return core.flatMap(
+      core.deferredMake<A, E | E2>(),
+      (deferred) =>
+        core.flatMap(runtime<R | R2 | R3>(), (runtime) =>
+          core.uninterruptibleMask((restore) =>
+            core.zipRight(
+              FiberRuntime.fork(restore(
+                core.matchCauseEffect(
+                  register((cb) => unsafeRunCallback(runtime)(core.intoDeferred(cb, deferred))),
+                  {
+                    onFailure: (cause) => core.deferredFailCause(deferred, cause),
+                    onSuccess: (cleanup_) => {
+                      cleanup = cleanup_
+                      return core.unit
+                    }
+                  }
+                )
+              )),
+              restore(core.onInterrupt(core.deferredAwait(deferred), () => cleanup ?? core.unit))
+            )
+          ))
+    )
+  })