effect 2.3.8 → 2.4.1

package/src/internal/core.ts

@@ -480,22 +480,6 @@ export const async = <A, E = never, R = never>(
       effect
   })
 
-/* @internal */
-export const asyncEither = <A, E = never, R = never>(
-  register: (
-    resume: (effect: Effect.Effect<A, E, R>) => void
-  ) => Either.Either<Effect.Effect<void, never, R>, Effect.Effect<A, E, R>>,
-  blockingOn: FiberId.FiberId = FiberId.none
-): Effect.Effect<A, E, R> =>
-  async<A, E, R>((resume) => {
-    const result = register(resume)
-    if (Either.isRight(result)) {
-      resume(result.right)
-    } else {
-      return result.left
-    }
-  }, blockingOn)
-
 /* @internal */
 export const catchAllCause = dual<
   <E, A2, E2, R2>(
@@ -530,15 +514,6 @@ export const catchAll: {
   ): Effect.Effect<A2 | A, E2, R2 | R> => matchEffect(self, { onFailure: f, onSuccess: succeed })
 )
 
-/**
- * @macro identity
- * @internal
- */
-export const unified = <Args extends ReadonlyArray<any>, Ret extends Effect.Effect<any, any, any>>(
-  f: (...args: Args) => Ret
-) =>
-(...args: Args): Effect.Effect.Unify<Ret> => f(...args)
-
 /* @internal */
 export const catchIf: {
   <E, EB extends E, A2, E2, R2>(
@@ -650,7 +625,7 @@ export const dieMessage = (message: string): Effect.Effect<never> =>
 export const dieSync = (evaluate: LazyArg<unknown>): Effect.Effect<never> => flatMap(sync(evaluate), die)
 
 /* @internal */
-export const either = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<Either.Either<E, A>, never, R> =>
+export const either = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<Either.Either<A, E>, never, R> =>
   matchEffect(self, {
     onFailure: (e) => succeed(Either.left(e)),
     onSuccess: (a) => succeed(Either.right(a))
@@ -728,13 +703,13 @@ export const andThen: {
   ) => [X] extends [Effect.Effect<infer A1, infer E1, infer R1>] ? Effect.Effect<A1, E | E1, R | R1>
     : [X] extends [Promise<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
     : Effect.Effect<X, E, R>
-  <A, R, E, X>(
+  <A, E, R, X>(
     self: Effect.Effect<A, E, R>,
     f: (a: NoInfer<A>) => X
   ): [X] extends [Effect.Effect<infer A1, infer E1, infer R1>] ? Effect.Effect<A1, E | E1, R | R1>
     : [X] extends [Promise<infer A1>] ? Effect.Effect<A1, E | Cause.UnknownException, R>
     : Effect.Effect<X, E, R>
-  <A, R, E, X>(
+  <A, E, R, X>(
     self: Effect.Effect<A, E, R>,
     f: X
   ): [X] extends [Effect.Effect<infer A1, infer E1, infer R1>] ? Effect.Effect<A1, E | E1, R | R1>
@@ -941,7 +916,7 @@ export const if_ = dual<
   (self: boolean | Effect.Effect<unknown, unknown, unknown>, { onFalse, onTrue }: {
     readonly onTrue: Effect.Effect<unknown, unknown, unknown>
     readonly onFalse: Effect.Effect<unknown, unknown, unknown>
-  }) => typeof self === "boolean" ? (self ? onTrue : onFalse) : flatMap(self, unified((b) => (b ? onTrue : onFalse)))
+  }) => typeof self === "boolean" ? (self ? onTrue : onFalse) : flatMap(self, (b) => (b ? onTrue : onFalse))
 )
 
 /* @internal */
@@ -1051,7 +1026,7 @@ export const onError: {
 } = dual(2, <A, E, R, X, R2>(
   self: Effect.Effect<A, E, R>,
   cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>
-): Effect.Effect<A, E, R2 | R> => onExit(self, unified((exit) => exitIsSuccess(exit) ? unit : cleanup(exit.i0))))
+): Effect.Effect<A, E, R2 | R> => onExit(self, (exit) => exitIsSuccess(exit) ? unit : cleanup(exit.i0)))
 
 /* @internal */
 export const onExit: {
@@ -1142,7 +1117,7 @@ export const orDieWith: {
 /* @internal */
 export const partitionMap = <A, A1, A2>(
   elements: Iterable<A>,
-  f: (a: A) => Either.Either<A1, A2>
+  f: (a: A) => Either.Either<A2, A1>
 ): [left: Array<A1>, right: Array<A2>] =>
   ReadonlyArray.fromIterable(elements).reduceRight(
     ([lefts, rights], current) => {
@@ -1462,11 +1437,11 @@ export const zipWith: {
 ): Effect.Effect<B, E | E2, R | R2> => flatMap(self, (a) => map(that, (b) => f(a, b))))
 
 /* @internal */
-export const never: Effect.Effect<never> = asyncEither<never>(() => {
+export const never: Effect.Effect<never> = async<never>(() => {
   const interval = setInterval(() => {
     //
   }, 2 ** 31 - 1)
-  return Either.left(sync(() => clearInterval(interval)))
+  return sync(() => clearInterval(interval))
 })
 
 // -----------------------------------------------------------------------------
@@ -1723,7 +1698,7 @@ const requestResolverVariance = {
 }
 
 /** @internal */
-export class RequestResolverImpl<out R, in A> implements RequestResolver.RequestResolver<A, R> {
+export class RequestResolverImpl<in A, out R> implements RequestResolver.RequestResolver<A, R> {
   readonly [RequestResolverTypeId] = requestResolverVariance
   constructor(
     readonly runAll: (
@@ -1773,7 +1748,7 @@ export const resolverLocally = dual<
   self: FiberRef.FiberRef<A>,
   value: A
 ): RequestResolver.RequestResolver<B, R> =>
-  new RequestResolverImpl<R, B>(
+  new RequestResolverImpl<B, R>(
     (requests) =>
       fiberRefLocally(
         use.runAll(requests),
@@ -2538,7 +2513,7 @@ export const exitForEachEffect: {
 })
 
 /** @internal */
-export const exitFromEither = <E, A>(either: Either.Either<E, A>): Exit.Exit<A, E> => {
+export const exitFromEither = <R, L>(either: Either.Either<R, L>): Exit.Exit<R, L> => {
   switch (either._tag) {
     case "Left":
       return exitFail(either.left)
@@ -2844,18 +2819,18 @@ export const deferredMakeAs = <A, E = never>(fiberId: FiberId.FiberId): Effect.E
 
 /* @internal */
 export const deferredAwait = <A, E>(self: Deferred.Deferred<A, E>): Effect.Effect<A, E> =>
-  asyncEither<A, E>((k) => {
+  async<A, E>((resume) => {
     const state = MutableRef.get(self.state)
     switch (state._tag) {
       case DeferredOpCodes.OP_STATE_DONE: {
-        return Either.right(state.effect)
+        return resume(state.effect)
       }
       case DeferredOpCodes.OP_STATE_PENDING: {
         pipe(
           self.state,
-          MutableRef.set(deferred.pending([k, ...state.joiners]))
+          MutableRef.set(deferred.pending([resume, ...state.joiners]))
         )
-        return Either.left(deferredInterruptJoiner(self, k))
+        return deferredInterruptJoiner(self, resume)
       }
     }
   }, self.blockingOn)

package/src/internal/dataSource.ts

@@ -13,21 +13,21 @@ import { invokeWithInterrupt, zipWithOptions } from "./fiberRuntime.js"
 import { complete } from "./request.js"
 
 /** @internal */
-export const make = <R, A>(
+export const make = <A, R>(
   runAll: (requests: Array<Array<A>>) => Effect.Effect<void, never, R>
 ): RequestResolver.RequestResolver<A, R> =>
   new core.RequestResolverImpl((requests) => runAll(requests.map((_) => _.map((_) => _.request))))
 
 /** @internal */
-export const makeWithEntry = <R, A>(
+export const makeWithEntry = <A, R>(
   runAll: (requests: Array<Array<Request.Entry<A>>>) => Effect.Effect<void, never, R>
 ): RequestResolver.RequestResolver<A, R> => new core.RequestResolverImpl((requests) => runAll(requests))
 
 /** @internal */
-export const makeBatched = <R, A extends Request.Request<any, any>>(
+export const makeBatched = <A extends Request.Request<any, any>, R>(
   run: (requests: Array<A>) => Effect.Effect<void, never, R>
 ): RequestResolver.RequestResolver<A, R> =>
-  new core.RequestResolverImpl<R, A>(
+  new core.RequestResolverImpl<A, R>(
     (requests) =>
       requests.length > 1 ?
         core.forEachSequentialDiscard(requests, (block) =>
@@ -50,16 +50,16 @@ export const makeBatched = <R, A extends Request.Request<any, any>>(
 
 /** @internal */
 export const around = dual<
-  <R2, A2, R3, _>(
+  <A2, R2, X, R3>(
     before: Effect.Effect<A2, never, R2>,
-    after: (a: A2) => Effect.Effect<_, never, R3>
-  ) => <R, A>(
+    after: (a: A2) => Effect.Effect<X, never, R3>
+  ) => <A, R>(
     self: RequestResolver.RequestResolver<A, R>
   ) => RequestResolver.RequestResolver<A, R | R2 | R3>,
-  <R, A, R2, A2, R3, _>(
+  <A, R, A2, R2, X, R3>(
     self: RequestResolver.RequestResolver<A, R>,
     before: Effect.Effect<A2, never, R2>,
-    after: (a: A2) => Effect.Effect<_, never, R3>
+    after: (a: A2) => Effect.Effect<X, never, R3>
   ) => RequestResolver.RequestResolver<A, R | R2 | R3>
 >(3, (self, before, after) =>
   new core.RequestResolverImpl(
@@ -74,16 +74,16 @@ export const around = dual<
 
 /** @internal */
 export const aroundRequests = dual<
-  <A, R2, A2, R3, _>(
+  <A, A2, R2, X, R3>(
     before: (requests: ReadonlyArray<NoInfer<A>>) => Effect.Effect<A2, never, R2>,
-    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<_, never, R3>
+    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
   ) => <R>(
     self: RequestResolver.RequestResolver<A, R>
   ) => RequestResolver.RequestResolver<A, R | R2 | R3>,
-  <R, A, R2, A2, R3, _>(
+  <A, R, A2, R2, X, R3>(
     self: RequestResolver.RequestResolver<A, R>,
     before: (requests: ReadonlyArray<NoInfer<A>>) => Effect.Effect<A2, never, R2>,
-    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<_, never, R3>
+    after: (requests: ReadonlyArray<NoInfer<A>>, _: A2) => Effect.Effect<X, never, R3>
   ) => RequestResolver.RequestResolver<A, R | R2 | R3>
 >(3, (self, before, after) =>
   new core.RequestResolverImpl(
@@ -100,14 +100,14 @@ export const aroundRequests = dual<
 
 /** @internal */
 export const batchN = dual<
-  (n: number) => <R, A>(
+  (n: number) => <A, R>(
     self: RequestResolver.RequestResolver<A, R>
   ) => RequestResolver.RequestResolver<A, R>,
-  <R, A>(
+  <A, R>(
     self: RequestResolver.RequestResolver<A, R>,
     n: number
   ) => RequestResolver.RequestResolver<A, R>
->(2, <R, A>(
+>(2, <A, R>(
   self: RequestResolver.RequestResolver<A, R>,
   n: number
 ): RequestResolver.RequestResolver<A, R> =>
@@ -144,7 +144,7 @@ export const mapInputContext = dual<
   self: RequestResolver.RequestResolver<A, R>,
   f: (context: Context.Context<R0>) => Context.Context<R>
 ) =>
-  new core.RequestResolverImpl<R0, A>(
+  new core.RequestResolverImpl<A, R0>(
     (requests) =>
       core.mapInputContext(
         self.runAll(requests),
@@ -162,7 +162,7 @@ export const eitherWith = dual<
     C extends Request.Request<any, any>
   >(
     that: RequestResolver.RequestResolver<B, R2>,
-    f: (_: Request.Entry<C>) => Either.Either<Request.Entry<A>, Request.Entry<B>>
+    f: (_: Request.Entry<C>) => Either.Either<Request.Entry<B>, Request.Entry<A>>
   ) => <R>(
     self: RequestResolver.RequestResolver<A, R>
   ) => RequestResolver.RequestResolver<C, R | R2>,
@@ -175,7 +175,7 @@ export const eitherWith = dual<
   >(
     self: RequestResolver.RequestResolver<A, R>,
     that: RequestResolver.RequestResolver<B, R2>,
-    f: (_: Request.Entry<C>) => Either.Either<Request.Entry<A>, Request.Entry<B>>
+    f: (_: Request.Entry<C>) => Either.Either<Request.Entry<B>, Request.Entry<A>>
   ) => RequestResolver.RequestResolver<C, R | R2>
 >(3, <
   R,
@@ -186,9 +186,9 @@ export const eitherWith = dual<
 >(
   self: RequestResolver.RequestResolver<A, R>,
   that: RequestResolver.RequestResolver<B, R2>,
-  f: (_: Request.Entry<C>) => Either.Either<Request.Entry<A>, Request.Entry<B>>
+  f: (_: Request.Entry<C>) => Either.Either<Request.Entry<B>, Request.Entry<A>>
 ) =>
-  new core.RequestResolverImpl<R | R2, C>(
+  new core.RequestResolverImpl<C, R | R2>(
     (batch) =>
       pipe(
         core.forEachSequential(batch, (requests) => {
@@ -262,7 +262,7 @@ export const fromEffectTagged = <
   A,
   ReturnType<Fns[keyof Fns]> extends Effect.Effect<infer _A, infer _E, infer R> ? R : never
 > =>
-  makeBatched<any, A>((requests: Array<A>) => {
+  makeBatched<A, any>((requests: Array<A>) => {
     const grouped: Record<string, Array<A>> = {}
     const tags: Array<A["_tag"]> = []
     for (let i = 0, len = requests.length; i < len; i++) {
@@ -308,16 +308,16 @@ export const provideContext = dual<
 
 /** @internal */
 export const race = dual<
-  <R2, A2 extends Request.Request<any, any>>(
+  <A2 extends Request.Request<any, any>, R2>(
     that: RequestResolver.RequestResolver<A2, R2>
-  ) => <R, A extends Request.Request<any, any>>(
+  ) => <A extends Request.Request<any, any>, R>(
     self: RequestResolver.RequestResolver<A, R>
   ) => RequestResolver.RequestResolver<A | A2, R | R2>,
-  <R, A extends Request.Request<any, any>, R2, A2 extends Request.Request<any, any>>(
+  <A extends Request.Request<any, any>, R, A2 extends Request.Request<any, any>, R2>(
     self: RequestResolver.RequestResolver<A, R>,
     that: RequestResolver.RequestResolver<A2, R2>
   ) => RequestResolver.RequestResolver<A | A2, R | R2>
->(2, <R, A, R2, A2>(
+>(2, <A, R, A2, R2>(
   self: RequestResolver.RequestResolver<A, R>,
   that: RequestResolver.RequestResolver<A2, R2>
 ) =>

package/src/internal/differ/orPatch.ts

@@ -188,8 +188,8 @@ type Instruction =
 /** @internal */
 export const diff = <Value, Value2, Patch, Patch2>(
   options: {
-    readonly oldValue: Either<Value, Value2>
-    readonly newValue: Either<Value, Value2>
+    readonly oldValue: Either<Value2, Value>
+    readonly newValue: Either<Value2, Value>
     readonly left: Differ<Value, Patch>
     readonly right: Differ<Value2, Patch2>
   }
@@ -243,23 +243,23 @@ export const combine = Dual.dual<
 export const patch = Dual.dual<
   <Value, Value2, Patch, Patch2>(
     options: {
-      readonly oldValue: Either<Value, Value2>
+      readonly oldValue: Either<Value2, Value>
       readonly left: Differ<Value, Patch>
       readonly right: Differ<Value2, Patch2>
     }
-  ) => (self: Differ.Or.Patch<Value, Value2, Patch, Patch2>) => Either<Value, Value2>,
+  ) => (self: Differ.Or.Patch<Value, Value2, Patch, Patch2>) => Either<Value2, Value>,
   <Value, Value2, Patch, Patch2>(
     self: Differ.Or.Patch<Value, Value2, Patch, Patch2>,
     options: {
-      readonly oldValue: Either<Value, Value2>
+      readonly oldValue: Either<Value2, Value>
       readonly left: Differ<Value, Patch>
       readonly right: Differ<Value2, Patch2>
     }
-  ) => Either<Value, Value2>
+  ) => Either<Value2, Value>
 >(2, <Value, Value2, Patch, Patch2>(
   self: Differ.Or.Patch<Value, Value2, Patch, Patch2>,
   { left, oldValue, right }: {
-    oldValue: Either<Value, Value2>
+    oldValue: Either<Value2, Value>
     left: Differ<Value, Patch>
     right: Differ<Value2, Patch2>
   }

package/src/internal/differ.ts

@@ -86,11 +86,11 @@ export const hashSet = <Value>(): Differ.Differ<HashSet<Value>, Differ.Differ.Ha
 export const orElseEither = Dual.dual<
   <Value2, Patch2>(that: Differ.Differ<Value2, Patch2>) => <Value, Patch>(
     self: Differ.Differ<Value, Patch>
-  ) => Differ.Differ<Either<Value, Value2>, Differ.Differ.Or.Patch<Value, Value2, Patch, Patch2>>,
+  ) => Differ.Differ<Either<Value2, Value>, Differ.Differ.Or.Patch<Value, Value2, Patch, Patch2>>,
   <Value, Patch, Value2, Patch2>(
     self: Differ.Differ<Value, Patch>,
     that: Differ.Differ<Value2, Patch2>
-  ) => Differ.Differ<Either<Value, Value2>, Differ.Differ.Or.Patch<Value, Value2, Patch, Patch2>>
+  ) => Differ.Differ<Either<Value2, Value>, Differ.Differ.Or.Patch<Value, Value2, Patch, Patch2>>
 >(2, (self, that) =>
   make({
     empty: OrPatch.empty(),

package/src/internal/effect/circular.ts

@@ -2,7 +2,6 @@ import type * as Cause from "../../Cause.js"
 import type * as Deferred from "../../Deferred.js"
 import * as Duration from "../../Duration.js"
 import type * as Effect from "../../Effect.js"
-import * as Either from "../../Either.js"
 import * as Equal from "../../Equal.js"
 import type { Equivalence } from "../../Equivalence.js"
 import * as Exit from "../../Exit.js"
@@ -45,7 +44,7 @@ class Semaphore {
   }
 
   readonly take = (n: number): Effect.Effect<number> =>
-    core.asyncEither<number>((resume) => {
+    core.async<number>((resume) => {
       if (this.free < n) {
         const observer = () => {
           if (this.free < n) {
@@ -56,12 +55,12 @@ class Semaphore {
           resume(core.succeed(n))
         }
         this.waiters.add(observer)
-        return Either.left(core.sync(() => {
+        return core.sync(() => {
           this.waiters.delete(observer)
-        }))
+        })
       }
       this.taken += n
-      return Either.right(core.succeed(n))
+      return resume(core.succeed(n))
     })
 
   readonly updateTaken = (f: (n: number) => number): Effect.Effect<number> =>
@@ -84,7 +83,7 @@ class Semaphore {
 
   readonly releaseAll: Effect.Effect<number> = this.updateTaken((_) => 0)
 
-  readonly withPermits = (n: number) => <R, E, A>(self: Effect.Effect<R, E, A>) =>
+  readonly withPermits = (n: number) => <A, E, R>(self: Effect.Effect<A, E, R>) =>
     core.uninterruptibleMask((restore) =>
       core.flatMap(
         restore(this.take(n)),
@@ -376,14 +375,14 @@ export const raceFirst = dual<
 
 /** @internal */
 export const scheduleForked = dual<
-  <R2, Out>(
-    schedule: Schedule.Schedule<R2, unknown, Out>
+  <Out, R2>(
+    schedule: Schedule.Schedule<Out, unknown, R2>
   ) => <A, E, R>(
     self: Effect.Effect<A, E, R>
   ) => Effect.Effect<Fiber.RuntimeFiber<Out, E>, never, R | R2 | Scope.Scope>,
-  <A, E, R, R2, Out>(
+  <A, E, R, Out, R2>(
     self: Effect.Effect<A, E, R>,
-    schedule: Schedule.Schedule<R2, unknown, Out>
+    schedule: Schedule.Schedule<Out, unknown, R2>
   ) => Effect.Effect<Fiber.RuntimeFiber<Out, E>, never, R | R2 | Scope.Scope>
 >(2, (self, schedule) => pipe(self, _schedule.schedule_Effect(schedule), forkScoped))
 

package/src/internal/either.ts

@@ -20,12 +20,12 @@ export const TypeId: Either.TypeId = Symbol.for("effect/Either") as Either.TypeI
 const CommonProto = {
   ...EffectPrototype,
   [TypeId]: {
-    _A: (_: never) => _
+    _R: (_: never) => _
   },
-  [NodeInspectSymbol]<E, A>(this: Either.Either<E, A>) {
+  [NodeInspectSymbol]<L, R>(this: Either.Either<R, L>) {
     return this.toJSON()
   },
-  toString<E, A>(this: Either.Left<E, A>) {
+  toString<L, R>(this: Either.Left<L, R>) {
     return format(this.toJSON())
   }
 }
@@ -33,13 +33,13 @@ const CommonProto = {
 const RightProto = Object.assign(Object.create(CommonProto), {
   _tag: "Right",
   _op: "Right",
-  [Equal.symbol]<E, A>(this: Either.Right<E, A>, that: unknown): boolean {
+  [Equal.symbol]<L, R>(this: Either.Right<L, R>, that: unknown): boolean {
     return isEither(that) && isRight(that) && Equal.equals(that.right, this.right)
   },
-  [Hash.symbol]<E, A>(this: Either.Right<E, A>) {
-    return Hash.cached(this, Hash.combine(Hash.hash(this._tag))(Hash.hash(this.right)))
+  [Hash.symbol]<L, R>(this: Either.Right<L, R>) {
+    return Hash.combine(Hash.hash(this._tag))(Hash.hash(this.right))
   },
-  toJSON<E, A>(this: Either.Right<E, A>) {
+  toJSON<L, R>(this: Either.Right<L, R>) {
     return {
       _id: "Either",
       _tag: this._tag,
@@ -51,11 +51,11 @@ const RightProto = Object.assign(Object.create(CommonProto), {
 const LeftProto = Object.assign(Object.create(CommonProto), {
   _tag: "Left",
   _op: "Left",
-  [Equal.symbol]<E, A>(this: Either.Left<E, A>, that: unknown): boolean {
+  [Equal.symbol]<L, R>(this: Either.Left<L, R>, that: unknown): boolean {
     return isEither(that) && isLeft(that) && Equal.equals(that.left, this.left)
   },
-  [Hash.symbol]<E, A>(this: Either.Left<E, A>) {
-    return Hash.cached(this, Hash.combine(Hash.hash(this._tag))(Hash.hash(this.left)))
+  [Hash.symbol]<L, R>(this: Either.Left<L, R>) {
+    return Hash.combine(Hash.hash(this._tag))(Hash.hash(this.left))
   },
   toJSON<E, A>(this: Either.Left<E, A>) {
     return {
@@ -70,38 +70,41 @@ const LeftProto = Object.assign(Object.create(CommonProto), {
 export const isEither = (input: unknown): input is Either.Either<unknown, unknown> => hasProperty(input, TypeId)
 
 /** @internal */
-export const isLeft = <E, A>(ma: Either.Either<E, A>): ma is Either.Left<E, A> => ma._tag === "Left"
+export const isLeft = <R, L>(ma: Either.Either<R, L>): ma is Either.Left<L, R> => ma._tag === "Left"
 
 /** @internal */
-export const isRight = <E, A>(ma: Either.Either<E, A>): ma is Either.Right<E, A> => ma._tag === "Right"
+export const isRight = <R, L>(ma: Either.Either<R, L>): ma is Either.Right<L, R> => ma._tag === "Right"
 
 /** @internal */
-export const left = <E>(left: E): Either.Either<E, never> => {
+export const left = <L>(left: L): Either.Either<never, L> => {
   const a = Object.create(LeftProto)
   a.left = left
   return a
 }
 
 /** @internal */
-export const right = <A>(right: A): Either.Either<never, A> => {
+export const right = <R>(right: R): Either.Either<R> => {
   const a = Object.create(RightProto)
   a.right = right
   return a
 }
 
 /** @internal */
-export const getLeft = <E, A>(
-  self: Either.Either<E, A>
-): Option<E> => (isRight(self) ? option.none : option.some(self.left))
+export const getLeft = <R, L>(
+  self: Either.Either<R, L>
+): Option<L> => (isRight(self) ? option.none : option.some(self.left))
 
 /** @internal */
-export const getRight = <E, A>(
-  self: Either.Either<E, A>
-): Option<A> => (isLeft(self) ? option.none : option.some(self.right))
+export const getRight = <R, L>(
+  self: Either.Either<R, L>
+): Option<R> => (isLeft(self) ? option.none : option.some(self.right))
 
 /** @internal */
-export const fromOption = dual(
+export const fromOption: {
+  <L>(onNone: () => L): <R>(self: Option<R>) => Either.Either<R, L>
+  <R, L>(self: Option<R>, onNone: () => L): Either.Either<R, L>
+} = dual(
   2,
-  <A, E>(self: Option<A>, onNone: () => E): Either.Either<E, A> =>
+  <R, L>(self: Option<R>, onNone: () => L): Either.Either<R, L> =>
     option.isNone(self) ? left(onNone()) : right(self.value)
 )

package/src/internal/encoding/base64.ts

@@ -35,7 +35,7 @@ export const encode = (bytes: Uint8Array) => {
 }
 
 /** @internal */
-export const decode = (str: string): Either.Either<Encoding.DecodeException, Uint8Array> => {
+export const decode = (str: string): Either.Either<Uint8Array, Encoding.DecodeException> => {
   const length = str.length
   if (length % 4 !== 0) {
     return Either.left(

package/src/internal/encoding/base64Url.ts

@@ -8,7 +8,7 @@ export const encode = (data: Uint8Array) =>
   Base64.encode(data).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_")
 
 /** @internal */
-export const decode = (str: string): Either.Either<Encoding.DecodeException, Uint8Array> => {
+export const decode = (str: string): Either.Either<Uint8Array, Encoding.DecodeException> => {
   const length = str.length
   if (length % 4 === 1) {
     return Either.left(

package/src/internal/encoding/hex.ts

@@ -13,7 +13,7 @@ export const encode = (bytes: Uint8Array) => {
 }
 
 /** @internal */
-export const decode = (str: string): Either.Either<Encoding.DecodeException, Uint8Array> => {
+export const decode = (str: string): Either.Either<Uint8Array, Encoding.DecodeException> => {
   const bytes = new TextEncoder().encode(str)
   if (bytes.length % 2 !== 0) {
     return Either.left(DecodeException(str, `Length must be a multiple of 2, but is ${bytes.length}`))

package/src/internal/fiber.ts

@@ -260,8 +260,8 @@ export const orElse = dual<
 
 /** @internal */
 export const orElseEither = dual<
-  <A2, E2>(that: Fiber.Fiber<A2, E2>) => <A, E>(self: Fiber.Fiber<A, E>) => Fiber.Fiber<Either.Either<A, A2>, E | E2>,
-  <A, E, A2, E2>(self: Fiber.Fiber<A, E>, that: Fiber.Fiber<A2, E2>) => Fiber.Fiber<Either.Either<A, A2>, E | E2>
+  <A2, E2>(that: Fiber.Fiber<A2, E2>) => <A, E>(self: Fiber.Fiber<A, E>) => Fiber.Fiber<Either.Either<A2, A>, E | E2>,
+  <A, E, A2, E2>(self: Fiber.Fiber<A, E>, that: Fiber.Fiber<A2, E2>) => Fiber.Fiber<Either.Either<A2, A>, E | E2>
 >(2, (self, that) => orElse(map(self, Either.left), map(that, Either.right)))
 
 /** @internal */

package/src/internal/fiberRuntime.ts

@@ -1915,9 +1915,9 @@ export const forEachParUnbounded = <A, B, E, R>(
   })
 
 /** @internal */
-export const forEachConcurrentDiscard = <A, _, E, R>(
+export const forEachConcurrentDiscard = <A, X, E, R>(
   self: Iterable<A>,
-  f: (a: A, i: number) => Effect.Effect<_, E, R>,
+  f: (a: A, i: number) => Effect.Effect<X, E, R>,
   batching: boolean,
   processAll: boolean,
   n?: number
@@ -1933,7 +1933,7 @@ export const forEachConcurrentDiscard = <A, _, E, R>(
         let counter = 0
         let interrupted = false
         const fibersCount = n ? Math.min(todos.length, n) : todos.length
-        const fibers = new Set<FiberRuntime<Exit.Exit<_, E> | Effect.Blocked<_, E>>>()
+        const fibers = new Set<FiberRuntime<Exit.Exit<X, E> | Effect.Blocked<X, E>>>()
         const results = new Array()
         const interruptAll = () =>
           fibers.forEach((fiber) => {
@@ -1941,8 +1941,8 @@ export const forEachConcurrentDiscard = <A, _, E, R>(
               fiber.unsafeInterruptAsFork(parent.id())
             }, 0)
           })
-        const startOrder = new Array<FiberRuntime<Exit.Exit<_, E> | Effect.Blocked<_, E>>>()
-        const joinOrder = new Array<FiberRuntime<Exit.Exit<_, E> | Effect.Blocked<_, E>>>()
+        const startOrder = new Array<FiberRuntime<Exit.Exit<X, E> | Effect.Blocked<X, E>>>()
+        const joinOrder = new Array<FiberRuntime<Exit.Exit<X, E> | Effect.Blocked<X, E>>>()
         const residual = new Array<core.Blocked>()
         const collectExits = () => {
           const exits: Array<Exit.Exit<any, E>> = results
@@ -1978,7 +1978,7 @@ export const forEachConcurrentDiscard = <A, _, E, R>(
         const stepOrExit = batching ? core.step : core.exit
         const processingFiber = runFiber(
           core.async<any, any, any>((resume) => {
-            const pushResult = <_, E>(res: Exit.Exit<_, E> | Effect.Blocked<_, E>, index: number) => {
+            const pushResult = <X, E>(res: Exit.Exit<X, E> | Effect.Blocked<X, E>, index: number) => {
               if (res._op === "Blocked") {
                 residual.push(res as core.Blocked)
               } else {
@@ -2002,8 +2002,8 @@ export const forEachConcurrentDiscard = <A, _, E, R>(
                     ))
                 }
                 const onRes = (
-                  res: Exit.Exit<_, E> | Effect.Blocked<_, E>
-                ): Effect.Effect<Exit.Exit<_, E> | Effect.Blocked<_, E>, never, R> => {
+                  res: Exit.Exit<X, E> | Effect.Blocked<X, E>
+                ): Effect.Effect<Exit.Exit<X, E> | Effect.Blocked<X, E>, never, R> => {
                   if (todos.length > 0) {
                     pushResult(res, index)
                     if (todos.length > 0) {
@@ -3315,7 +3315,7 @@ export const raceFibersWith = dual<
     }, FiberId.combine(leftFiber.id(), rightFiber.id()))
   }))
 
-const completeRace = <R, R1, R2, E2, A2, R3, E3, A3>(
+const completeRace = <A2, A3, E2, E3, R, R1, R2, R3>(
   winner: Fiber.RuntimeFiber<any, any>,
   loser: Fiber.RuntimeFiber<any, any>,
   cont: (winner: Fiber.RuntimeFiber<any, any>, loser: Fiber.RuntimeFiber<any, any>) => Effect.Effect<any, any, any>,