effect 2.3.8 → 2.4.0

package/src/internal/channel.ts

@@ -182,8 +182,8 @@ export const catchAll = dual<
 
 /** @internal */
 export const concatMap = dual<
-  <OutElem, OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>(
-    f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>
+  <OutElem, OutElem2, InElem2, OutErr2, InErr2, X, InDone2, Env2>(
+    f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, X, InDone2, Env2>
   ) => <Env, InErr, InElem, InDone, OutErr, OutDone>(
     self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
   ) => Channel.Channel<
@@ -195,9 +195,9 @@ export const concatMap = dual<
     InDone & InDone2,
     Env2 | Env
   >,
-  <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, OutElem2, Env2, InErr2, InElem2, InDone2, OutErr2, _>(
+  <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, OutElem2, Env2, InErr2, InElem2, InDone2, OutErr2, X>(
     self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-    f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>
+    f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, X, InDone2, Env2>
   ) => Channel.Channel<
     OutElem2,
     InElem & InElem2,
@@ -207,9 +207,9 @@ export const concatMap = dual<
     InDone & InDone2,
     Env2 | Env
   >
->(2, <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, OutElem2, Env2, InErr2, InElem2, InDone2, OutErr2, _>(
+>(2, <Env, InErr, InElem, InDone, OutErr, OutDone, OutElem, OutElem2, Env2, InErr2, InElem2, InDone2, OutErr2, X>(
   self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>,
-  f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, _, InDone2, Env2>
+  f: (o: OutElem) => Channel.Channel<OutElem2, InElem2, OutErr2, InErr2, X, InDone2, Env2>
 ): Channel.Channel<
   OutElem2,
   InElem & InElem2,
@@ -660,9 +660,9 @@ export const foldChannel = dual<
   }))
 
 /** @internal */
-export const fromEither = <E, A>(
-  either: Either.Either<E, A>
-): Channel.Channel<never, unknown, E, unknown, A, unknown> =>
+export const fromEither = <R, L>(
+  either: Either.Either<R, L>
+): Channel.Channel<never, unknown, L, unknown, R, unknown> =>
   core.suspend(() => Either.match(either, { onLeft: core.fail, onRight: core.succeed }))
 
 /** @internal */
@@ -679,13 +679,13 @@ export const fromInput = <Err, Elem, Done>(
 
 /** @internal */
 export const fromPubSub = <Done, Err, Elem>(
-  pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
+  pubsub: PubSub.PubSub<Either.Either<Elem, Exit.Exit<Done, Err>>>
 ): Channel.Channel<Elem, unknown, Err, unknown, Done, unknown> =>
   unwrapScoped(Effect.map(PubSub.subscribe(pubsub), fromQueue))
 
 /** @internal */
 export const fromPubSubScoped = <Done, Err, Elem>(
-  pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
+  pubsub: PubSub.PubSub<Either.Either<Elem, Exit.Exit<Done, Err>>>
 ): Effect.Effect<Channel.Channel<Elem, unknown, Err, unknown, Done, unknown>, never, Scope.Scope> =>
   Effect.map(PubSub.subscribe(pubsub), fromQueue)
 
@@ -702,12 +702,12 @@ export const fromOption = <A>(
 
 /** @internal */
 export const fromQueue = <Done, Err, Elem>(
-  queue: Queue.Dequeue<Either.Either<Exit.Exit<Done, Err>, Elem>>
+  queue: Queue.Dequeue<Either.Either<Elem, Exit.Exit<Done, Err>>>
 ): Channel.Channel<Elem, unknown, Err, unknown, Done, unknown> => core.suspend(() => fromQueueInternal(queue))
 
 /** @internal */
 const fromQueueInternal = <Done, Err, Elem>(
-  queue: Queue.Dequeue<Either.Either<Exit.Exit<Done, Err>, Elem>>
+  queue: Queue.Dequeue<Either.Either<Elem, Exit.Exit<Done, Err>>>
 ): Channel.Channel<Elem, unknown, Err, unknown, Done, unknown> =>
   pipe(
     core.fromEffect(Queue.take(queue)),
@@ -912,7 +912,7 @@ export const mapOutEffectPar = dual<
     Effect.gen(function*($) {
       const queue = yield* $(
         Effect.acquireRelease(
-          Queue.bounded<Effect.Effect<Either.Either<OutDone, OutElem1>, OutErr | OutErr1, Env1>>(n),
+          Queue.bounded<Effect.Effect<Either.Either<OutElem1, OutDone>, OutErr | OutErr1, Env1>>(n),
           (queue) => Queue.shutdown(queue)
         )
       )
@@ -1143,7 +1143,7 @@ export const mergeAllWith = (
       const queueReader = fromInput(input)
       const queue = yield* $(
         Effect.acquireRelease(
-          Queue.bounded<Effect.Effect<Either.Either<OutDone, OutElem>, OutErr | OutErr1, Env>>(bufferSize),
+          Queue.bounded<Effect.Effect<Either.Either<OutElem, OutDone>, OutErr | OutErr1, Env>>(bufferSize),
           (queue) => Queue.shutdown(queue)
         )
       )
@@ -1159,7 +1159,7 @@ export const mergeAllWith = (
         .withPermits
       const pull = yield* $(toPull(channels))
       const evaluatePull = (
-        pull: Effect.Effect<Either.Either<OutDone, OutElem>, OutErr | OutErr1, Env | Env1>
+        pull: Effect.Effect<Either.Either<OutElem, OutDone>, OutErr | OutErr1, Env | Env1>
       ) =>
         pipe(
           Effect.flatMap(
@@ -1622,9 +1622,9 @@ export const mergeWith = dual<
             >
 
             const handleSide = <Err, Done, Err2, Done2>(
-              exit: Exit.Exit<Either.Either<Done, OutElem | OutElem1>, Err>,
-              fiber: Fiber.Fiber<Either.Either<Done2, OutElem | OutElem1>, Err2>,
-              pull: Effect.Effect<Either.Either<Done, OutElem | OutElem1>, Err, Env | Env1>
+              exit: Exit.Exit<Either.Either<OutElem | OutElem1, Done>, Err>,
+              fiber: Fiber.Fiber<Either.Either<OutElem | OutElem1, Done2>, Err2>,
+              pull: Effect.Effect<Either.Either<OutElem | OutElem1, Done>, Err, Env | Env1>
             ) =>
             (
               done: (
@@ -1637,8 +1637,8 @@ export const mergeWith = dual<
                 OutDone2 | OutDone3
               >,
               both: (
-                f1: Fiber.Fiber<Either.Either<Done, OutElem | OutElem1>, Err>,
-                f2: Fiber.Fiber<Either.Either<Done2, OutElem | OutElem1>, Err2>
+                f1: Fiber.Fiber<Either.Either<OutElem | OutElem1, Done>, Err>,
+                f2: Fiber.Fiber<Either.Either<OutElem | OutElem1, Done2>, Err2>
               ) => State,
               single: (
                 f: (
@@ -2021,21 +2021,21 @@ export const mapInputContext = dual<
 
 /** @internal */
 export const provideSomeLayer = dual<
-  <Env2, OutErr2, Env0>(
-    layer: Layer.Layer<Env2, OutErr2, Env0>
+  <R2, OutErr2, Env0>(
+    layer: Layer.Layer<R2, OutErr2, Env0>
   ) => <OutElem, InElem, OutErr, InErr, OutDone, InDone, R>(
     self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R>
-  ) => Channel.Channel<OutElem, InElem, OutErr2 | OutErr, InErr, OutDone, InDone, Env0 | Exclude<R, Env2>>,
-  <OutElem, InElem, OutErr, InErr, OutDone, InDone, R, Env2, OutErr2, Env0>(
+  ) => Channel.Channel<OutElem, InElem, OutErr2 | OutErr, InErr, OutDone, InDone, Env0 | Exclude<R, R2>>,
+  <OutElem, InElem, OutErr, InErr, OutDone, InDone, R, R2, OutErr2, Env0>(
     self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R>,
-    layer: Layer.Layer<Env2, OutErr2, Env0>
-  ) => Channel.Channel<OutElem, InElem, OutErr2 | OutErr, InErr, OutDone, InDone, Env0 | Exclude<R, Env2>>
->(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, R, Env2, OutErr2, Env0>(
+    layer: Layer.Layer<R2, OutErr2, Env0>
+  ) => Channel.Channel<OutElem, InElem, OutErr2 | OutErr, InErr, OutDone, InDone, Env0 | Exclude<R, R2>>
+>(2, <OutElem, InElem, OutErr, InErr, OutDone, InDone, R, R2, OutErr2, Env0>(
   self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, R>,
-  layer: Layer.Layer<Env2, OutErr2, Env0>
-): Channel.Channel<OutElem, InElem, OutErr | OutErr2, InErr, OutDone, InDone, Env0 | Exclude<R, Env2>> =>
+  layer: Layer.Layer<R2, OutErr2, Env0>
+): Channel.Channel<OutElem, InElem, OutErr | OutErr2, InErr, OutDone, InDone, Env0 | Exclude<R, R2>> =>
   // @ts-expect-error
-  provideLayer(self, Layer.merge(Layer.context<Exclude<R, Env2>>(), layer)))
+  provideLayer(self, Layer.merge(Layer.context<Exclude<R, R2>>(), layer)))
 
 /** @internal */
 export const read = <In>(): Channel.Channel<never, In, Option.Option<never>, unknown, In, unknown> =>
@@ -2107,13 +2107,13 @@ export const serviceWithEffect = <T extends Context.Tag<any, any>>(tag: T) =>
 
 /** @internal */
 export const toPubSub = <Done, Err, Elem>(
-  pubsub: PubSub.PubSub<Either.Either<Exit.Exit<Done, Err>, Elem>>
+  pubsub: PubSub.PubSub<Either.Either<Elem, Exit.Exit<Done, Err>>>
 ): Channel.Channel<never, Elem, never, Err, unknown, Done> => toQueue(pubsub)
 
 /** @internal */
 export const toPull = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
   self: Channel.Channel<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<Effect.Effect<Either.Either<OutDone, OutElem>, OutErr, Env>, never, Env | Scope.Scope> =>
+): Effect.Effect<Effect.Effect<Either.Either<OutElem, OutDone>, OutErr, Env>, never, Env | Scope.Scope> =>
   Effect.map(
     Effect.acquireRelease(
       Effect.sync(() => new executor.ChannelExecutor(self, void 0, identity)),
@@ -2122,20 +2122,20 @@ export const toPull = <OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>(
         return finalize === undefined ? Effect.unit : finalize
       }
     ),
-    (exec) => Effect.suspend(() => interpretToPull(exec.run() as ChannelState.ChannelState<Env, OutErr>, exec))
+    (exec) => Effect.suspend(() => interpretToPull(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec))
   )
 
 /** @internal */
 const interpretToPull = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
-  channelState: ChannelState.ChannelState<Env, OutErr>,
+  channelState: ChannelState.ChannelState<OutErr, Env>,
   exec: executor.ChannelExecutor<OutElem, InElem, OutErr, InErr, OutDone, InDone, Env>
-): Effect.Effect<Either.Either<OutDone, OutElem>, OutErr, Env> => {
+): Effect.Effect<Either.Either<OutElem, OutDone>, OutErr, Env> => {
   const state = channelState as ChannelState.Primitive
   switch (state._tag) {
     case ChannelStateOpCodes.OP_DONE: {
       return Exit.match(exec.getDone(), {
         onFailure: Effect.failCause,
-        onSuccess: (done): Effect.Effect<Either.Either<OutDone, OutElem>, OutErr, Env> =>
+        onSuccess: (done): Effect.Effect<Either.Either<OutElem, OutDone>, OutErr, Env> =>
           Effect.succeed(Either.left(done))
       })
     }
@@ -2144,15 +2144,15 @@ const interpretToPull = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
     }
     case ChannelStateOpCodes.OP_FROM_EFFECT: {
       return pipe(
-        state.effect as Effect.Effect<Either.Either<OutDone, OutElem>, OutErr, Env>,
-        Effect.flatMap(() => interpretToPull(exec.run() as ChannelState.ChannelState<Env, OutErr>, exec))
+        state.effect as Effect.Effect<Either.Either<OutElem, OutDone>, OutErr, Env>,
+        Effect.flatMap(() => interpretToPull(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec))
       )
     }
     case ChannelStateOpCodes.OP_READ: {
       return executor.readUpstream(
         state,
-        () => interpretToPull(exec.run() as ChannelState.ChannelState<Env, OutErr>, exec),
-        (cause) => Effect.failCause(cause) as Effect.Effect<Either.Either<OutDone, OutElem>, OutErr, Env>
+        () => interpretToPull(exec.run() as ChannelState.ChannelState<OutErr, Env>, exec),
+        (cause) => Effect.failCause(cause) as Effect.Effect<Either.Either<OutElem, OutDone>, OutErr, Env>
       )
     }
   }
@@ -2160,12 +2160,12 @@ const interpretToPull = <Env, InErr, InElem, InDone, OutErr, OutElem, OutDone>(
 
 /** @internal */
 export const toQueue = <Done, Err, Elem>(
-  queue: Queue.Enqueue<Either.Either<Exit.Exit<Done, Err>, Elem>>
+  queue: Queue.Enqueue<Either.Either<Elem, Exit.Exit<Done, Err>>>
 ): Channel.Channel<never, Elem, never, Err, unknown, Done> => core.suspend(() => toQueueInternal(queue))
 
 /** @internal */
 const toQueueInternal = <Err, Done, Elem>(
-  queue: Queue.Enqueue<Either.Either<Exit.Exit<Done, Err>, Elem>>
+  queue: Queue.Enqueue<Either.Either<Elem, Exit.Exit<Done, Err>>>
 ): Channel.Channel<never, Elem, never, Err, unknown, Done> => {
   return core.readWithCause({
     onInput: (elem) =>

package/src/internal/clock.ts

@@ -2,7 +2,6 @@ import type * as Clock from "../Clock.js"
 import * as Context from "../Context.js"
 import * as Duration from "../Duration.js"
 import type * as Effect from "../Effect.js"
-import * as Either from "../Either.js"
 import { constFalse } from "../Function.js"
 import * as core from "./core.js"
 
@@ -85,9 +84,9 @@ class ClockImpl implements Clock.Clock {
   }
 
   sleep(duration: Duration.Duration): Effect.Effect<void> {
-    return core.asyncEither<void>((cb) => {
-      const canceler = globalClockScheduler.unsafeSchedule(() => cb(core.unit), duration)
-      return Either.left(core.asUnit(core.sync(canceler)))
+    return core.async<void>((resume) => {
+      const canceler = globalClockScheduler.unsafeSchedule(() => resume(core.unit), duration)
+      return core.asUnit(core.sync(canceler))
     })
   }
 }

package/src/internal/config.ts

@@ -60,7 +60,7 @@ export type Op<Tag extends string, Body = {}> = Config.Config<never> & Body & {
 export interface Constant extends
   Op<OpCodes.OP_CONSTANT, {
     readonly value: unknown
-    parse(text: string): Either.Either<ConfigError.ConfigError, unknown>
+    parse(text: string): Either.Either<unknown, ConfigError.ConfigError>
   }>
 {}
 
@@ -85,7 +85,7 @@ export interface Fallback extends
 export interface Fail extends
   Op<OpCodes.OP_FAIL, {
     readonly message: string
-    parse(text: string): Either.Either<ConfigError.ConfigError, unknown>
+    parse(text: string): Either.Either<unknown, ConfigError.ConfigError>
   }>
 {}
 
@@ -100,7 +100,7 @@ export interface Lazy extends
 export interface MapOrFail extends
   Op<OpCodes.OP_MAP_OR_FAIL, {
     readonly original: Config.Config<unknown>
-    mapOrFail(value: unknown): Either.Either<ConfigError.ConfigError, unknown>
+    mapOrFail(value: unknown): Either.Either<unknown, ConfigError.ConfigError>
   }>
 {}
 
@@ -116,7 +116,7 @@ export interface Nested extends
 export interface Primitive extends
   Op<OpCodes.OP_PRIMITIVE, {
     readonly description: string
-    parse(text: string): Either.Either<ConfigError.ConfigError, unknown>
+    parse(text: string): Either.Either<unknown, ConfigError.ConfigError>
   }>
 {}
 
@@ -314,8 +314,8 @@ export const mapAttempt = dual<
 
 /** @internal */
 export const mapOrFail = dual<
-  <A, B>(f: (a: A) => Either.Either<ConfigError.ConfigError, B>) => (self: Config.Config<A>) => Config.Config<B>,
-  <A, B>(self: Config.Config<A>, f: (a: A) => Either.Either<ConfigError.ConfigError, B>) => Config.Config<B>
+  <A, B>(f: (a: A) => Either.Either<B, ConfigError.ConfigError>) => (self: Config.Config<A>) => Config.Config<B>,
+  <A, B>(self: Config.Config<A>, f: (a: A) => Either.Either<B, ConfigError.ConfigError>) => Config.Config<B>
 >(2, (self, f) => {
   const mapOrFail = Object.create(proto)
   mapOrFail._tag = OpCodes.OP_MAP_OR_FAIL
@@ -385,7 +385,7 @@ export const option = <A>(self: Config.Config<A>): Config.Config<Option.Option<A
 /** @internal */
 export const primitive = <A>(
   description: string,
-  parse: (text: string) => Either.Either<ConfigError.ConfigError, A>
+  parse: (text: string) => Either.Either<A, ConfigError.ConfigError>
 ): Config.Config<A> => {
   const primitive = Object.create(proto)
   primitive._tag = OpCodes.OP_PRIMITIVE

package/src/internal/configError.ts

@@ -215,7 +215,7 @@ export const reduceWithContext = dual<
   <C, Z>(self: ConfigError.ConfigError, context: C, reducer: ConfigError.ConfigErrorReducer<C, Z>) => Z
 >(3, <C, Z>(self: ConfigError.ConfigError, context: C, reducer: ConfigError.ConfigErrorReducer<C, Z>) => {
   const input: Array<ConfigError.ConfigError> = [self]
-  const output: Array<Either.Either<ConfigErrorCase, Z>> = []
+  const output: Array<Either.Either<Z, ConfigErrorCase>> = []
   while (input.length > 0) {
     const error = input.pop()!
     switch (error._tag) {

package/src/internal/configProvider/pathPatch.ts

@@ -46,11 +46,11 @@ export const patch = dual<
     patch: PathPatch.PathPatch
   ) => (
     path: ReadonlyArray<string>
-  ) => Either.Either<ConfigError.ConfigError, ReadonlyArray<string>>,
+  ) => Either.Either<ReadonlyArray<string>, ConfigError.ConfigError>,
   (
     path: ReadonlyArray<string>,
     patch: PathPatch.PathPatch
-  ) => Either.Either<ConfigError.ConfigError, ReadonlyArray<string>>
+  ) => Either.Either<ReadonlyArray<string>, ConfigError.ConfigError>
 >(2, (path, patch) => {
   let input: List.List<PathPatch.PathPatch> = List.of(patch)
   let output: ReadonlyArray<string> = path

package/src/internal/configProvider.ts

@@ -438,7 +438,7 @@ const fromFlatLoop = <A>(
 }
 
 const fromFlatLoopFail =
-  (prefix: ReadonlyArray<string>, path: string) => (index: number): Either.Either<ConfigError.ConfigError, unknown> =>
+  (prefix: ReadonlyArray<string>, path: string) => (index: number): Either.Either<unknown, ConfigError.ConfigError> =>
     Either.left(
       configError.MissingData(
         prefix,

package/src/internal/core-effect.ts

@@ -4,9 +4,8 @@ import * as Clock from "../Clock.js"
 import * as Context from "../Context.js"
 import * as Duration from "../Duration.js"
 import type * as Effect from "../Effect.js"
-import * as Either from "../Either.js"
 import type * as Fiber from "../Fiber.js"
-import * as FiberId from "../FiberId.js"
+import type * as FiberId from "../FiberId.js"
 import type * as FiberRef from "../FiberRef.js"
 import * as FiberRefs from "../FiberRefs.js"
 import type * as FiberRefsPatch from "../FiberRefsPatch.js"
@@ -26,7 +25,7 @@ import * as ReadonlyArray from "../ReadonlyArray.js"
 import * as Ref from "../Ref.js"
 import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
-import type { NoInfer } from "../Types.js"
+import type { MergeRecord, NoInfer } from "../Types.js"
 import * as internalCause from "./cause.js"
 import * as core from "./core.js"
 import * as defaultServices from "./defaultServices.js"
@@ -75,26 +74,6 @@ export const asSome = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<Opt
 export const asSomeError = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, Option.Option<E>, R> =>
   core.mapError(self, Option.some)
 
-/* @internal */
-export const asyncOption = <A, E = never, R = never>(
-  register: (callback: (_: Effect.Effect<A, E, R>) => void) => Option.Option<Effect.Effect<A, E, R>>,
-  blockingOn: FiberId.FiberId = FiberId.none
-): Effect.Effect<A, E, R> =>
-  core.asyncEither(
-    (cb) => {
-      const option = register(cb)
-      switch (option._tag) {
-        case "None": {
-          return Either.left(core.unit)
-        }
-        case "Some": {
-          return Either.right(option.value)
-        }
-      }
-    },
-    blockingOn
-  )
-
 /* @internal */
 export const try_: {
   <A, E>(options: {
@@ -168,10 +147,13 @@ export const catchAllDefect = dual<
     self: Effect.Effect<A, E, R>,
     f: (defect: unknown) => Effect.Effect<A2, E2, R2>
   ) => Effect.Effect<A | A2, E | E2, R | R2>
->(2, (self, f) =>
+>(2, <A, E, R, A2, E2, R2>(
+  self: Effect.Effect<A, E, R>,
+  f: (defect: unknown) => Effect.Effect<A2, E2, R2>
+): Effect.Effect<A | A2, E | E2, R | R2> =>
   core.catchAllCause(
     self,
-    core.unified((cause) => {
+    (cause): Effect.Effect<A | A2, E | E2, R | R2> => {
       const option = internalCause.find(cause, (_) => internalCause.isDieType(_) ? Option.some(_) : Option.none())
       switch (option._tag) {
         case "None": {
@@ -181,7 +163,7 @@ export const catchAllDefect = dual<
           return f(option.value.defect)
         }
       }
-    })
+    }
   ))
 
 /* @internal */
@@ -226,10 +208,13 @@ export const catchSomeDefect = dual<
   ) => Effect.Effect<A | A2, E | E2, R | R2>
 >(
   2,
-  (self, pf) =>
+  <A, E, R, A2, E2, R2>(
+    self: Effect.Effect<A, E, R>,
+    pf: (defect: unknown) => Option.Option<Effect.Effect<A2, E2, R2>>
+  ): Effect.Effect<A | A2, E | E2, R | R2> =>
     core.catchAllCause(
       self,
-      core.unified((cause) => {
+      (cause): Effect.Effect<A | A2, E | E2, R | R2> => {
         const option = internalCause.find(cause, (_) => internalCause.isDieType(_) ? Option.some(_) : Option.none())
         switch (option._tag) {
           case "None": {
@@ -240,7 +225,7 @@ export const catchSomeDefect = dual<
             return optionEffect._tag === "Some" ? optionEffect.value : core.failCause(cause)
           }
         }
-      })
+      }
     )
 )
 
@@ -386,21 +371,21 @@ export const bind: {
   <N extends string, K, A, E2, R2>(
     tag: Exclude<N, keyof K>,
     f: (_: K) => Effect.Effect<A, E2, R2>
-  ): <E, R>(self: Effect.Effect<K, E, R>) => Effect.Effect<Effect.MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
+  ): <E, R>(self: Effect.Effect<K, E, R>) => Effect.Effect<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
   <K, E, R, N extends string, A, E2, R2>(
     self: Effect.Effect<K, E, R>,
     tag: Exclude<N, keyof K>,
     f: (_: K) => Effect.Effect<A, E2, R2>
-  ): Effect.Effect<Effect.MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
+  ): Effect.Effect<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R>
 } = dual(3, <K, E, R, N extends string, A, E2, R2>(
   self: Effect.Effect<K, E, R>,
   tag: Exclude<N, keyof K>,
   f: (_: K) => Effect.Effect<A, E2, R2>
-): Effect.Effect<Effect.MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R> =>
+): Effect.Effect<MergeRecord<K, { [k in N]: A }>, E2 | E, R2 | R> =>
   core.flatMap(self, (k) =>
     core.map(
       f(k),
-      (a): Effect.MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: a } as any)
+      (a): MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: a } as any)
     )))
 
 /* @internal */
@@ -418,20 +403,20 @@ export const let_: {
   <N extends string, K, A>(
     tag: Exclude<N, keyof K>,
     f: (_: K) => A
-  ): <E, R>(self: Effect.Effect<K, E, R>) => Effect.Effect<Effect.MergeRecord<K, { [k in N]: A }>, E, R>
+  ): <E, R>(self: Effect.Effect<K, E, R>) => Effect.Effect<MergeRecord<K, { [k in N]: A }>, E, R>
   <K, E, R, N extends string, A>(
     self: Effect.Effect<K, E, R>,
     tag: Exclude<N, keyof K>,
     f: (_: K) => A
-  ): Effect.Effect<Effect.MergeRecord<K, { [k in N]: A }>, E, R>
+  ): Effect.Effect<MergeRecord<K, { [k in N]: A }>, E, R>
 } = dual(3, <K, E, R, N extends string, A>(
   self: Effect.Effect<K, E, R>,
   tag: Exclude<N, keyof K>,
   f: (_: K) => A
-): Effect.Effect<Effect.MergeRecord<K, { [k in N]: A }>, E, R> =>
+): Effect.Effect<MergeRecord<K, { [k in N]: A }>, E, R> =>
   core.map(
     self,
-    (k): Effect.MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: f(k) } as any)
+    (k): MergeRecord<K, { [k in N]: A }> => ({ ...k, [tag]: f(k) } as any)
   ))
 
 /* @internal */
@@ -1012,7 +997,7 @@ export const loop: {
     ? loopDiscard(initial, options.while, options.step, options.body)
     : core.map(loopInternal(initial, options.while, options.step, options.body), Array.from)
 
-const loopInternal = <Z, R, E, A>(
+const loopInternal = <Z, A, E, R>(
   initial: Z,
   cont: Predicate.Predicate<Z>,
   inc: (z: Z) => Z,
@@ -1125,7 +1110,7 @@ export const merge = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<E |
   })
 
 /* @internal */
-export const negate = <R, E>(self: Effect.Effect<boolean, E, R>): Effect.Effect<boolean, E, R> =>
+export const negate = <E, R>(self: Effect.Effect<boolean, E, R>): Effect.Effect<boolean, E, R> =>
   core.map(self, (b) => !b)
 
 /* @internal */
@@ -1297,14 +1282,14 @@ export const reduceRight = dual<
 
 /* @internal */
 export const reduceWhile = dual<
-  <A, R, E, Z>(
+  <Z, A, E, R>(
     zero: Z,
     options: {
       readonly while: Predicate.Predicate<Z>
       readonly body: (s: Z, a: A, i: number) => Effect.Effect<Z, E, R>
     }
   ) => (elements: Iterable<A>) => Effect.Effect<Z, E, R>,
-  <A, R, E, Z>(
+  <A, Z, E, R>(
     elements: Iterable<A>,
     zero: Z,
     options: {
@@ -1312,7 +1297,7 @@ export const reduceWhile = dual<
       readonly body: (s: Z, a: A, i: number) => Effect.Effect<Z, E, R>
     }
   ) => Effect.Effect<Z, E, R>
->(3, <A, R, E, Z>(
+>(3, <A, Z, E, R>(
   elements: Iterable<A>,
   zero: Z,
   options: {
@@ -1867,7 +1852,7 @@ export const withMetric = dual<
 >(2, (self, metric) => metric(self))
 
 /** @internal */
-export const serviceFunctionEffect = <T extends Effect.Effect<any, any, any>, Args extends Array<any>, R, E, A>(
+export const serviceFunctionEffect = <T extends Effect.Effect<any, any, any>, Args extends Array<any>, A, E, R>(
   getService: T,
   f: (_: Effect.Effect.Success<T>) => (...args: Args) => Effect.Effect<A, E, R>
 ) =>