@typed/fx 1.22.2 → 1.23.0

package/src/Stream.ts

@@ -19,8 +19,8 @@ import * as Sink from "./Sink.js"
  * @since 1.18.0
  * @category conversions
  */
-export function toStream<R, E, A>(fx: Fx.Fx<R, E, A>): Stream.Stream<R, E, A> {
-  return Stream.asyncScoped<R | Scope.Scope, E, A>((emit) =>
+export function toStream<R, E, A>(fx: Fx.Fx<R, E, A>): Stream.Stream<A, E, R> {
+  return Stream.asyncScoped<A, E, R | Scope.Scope>((emit) =>
     fx.run(
       Sink.make(
         (cause) => Effect.promise(() => emit(Effect.failCause(Cause.map(cause, Option.some)))),
@@ -42,17 +42,17 @@ export function toStream<R, E, A>(fx: Fx.Fx<R, E, A>): Stream.Stream<R, E, A> {
  */
 export const toStreamQueued: {
   <E, A, R2, E2>(
-    make: Effect.Effect<R2, E2, Queue.Queue<Exit.Exit<Option.Option<E>, A>>>
-  ): <R>(fx: Fx.Fx<R, E, A>) => Stream.Stream<R | R2, E | E2, A>
+    make: Effect.Effect<Queue.Queue<Exit.Exit<A, Option.Option<E>>>, E2, R2>
+  ): <R>(fx: Fx.Fx<R, E, A>) => Stream.Stream<A, E | E2, R | R2>
 
   <R, E, A, R2, E2>(
     fx: Fx.Fx<R, E, A>,
-    make: Effect.Effect<R2, E2, Queue.Queue<Exit.Exit<Option.Option<E>, A>>>
-  ): Stream.Stream<R | R2, E | E2, A>
+    make: Effect.Effect<Queue.Queue<Exit.Exit<A, Option.Option<E>>>, E2, R2>
+  ): Stream.Stream<A, E | E2, R | R2>
 } = dual(2, function toStreamQueued<R, E, A, R2, E2>(
   fx: Fx.Fx<R, E, A>,
-  make: Effect.Effect<R2, E2, Queue.Queue<Exit.Exit<Option.Option<E>, A>>>
-): Stream.Stream<R | R2, E | E2, A> {
+  make: Effect.Effect<Queue.Queue<Exit.Exit<A, Option.Option<E>>>, E2, R2>
+): Stream.Stream<A, E | E2, R | R2> {
   return make.pipe(
     Effect.tap((queue) =>
       fx.pipe(
@@ -76,11 +76,11 @@ export const toStreamQueued: {
  * @category conversions
  */
 export const toStreamSliding: {
-  (capacity: number): <R, E, A>(fx: Fx.Fx<R, E, A>) => Stream.Stream<R, E, A>
-  <R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<R, E, A>
+  (capacity: number): <R, E, A>(fx: Fx.Fx<R, E, A>) => Stream.Stream<A, E, R>
+  <R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<A, E, R>
 } = dual(
   2,
-  function toStreamSliding<R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<R, E, A> {
+  function toStreamSliding<R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<A, E, R> {
     return toStreamQueued(fx, Queue.sliding(capacity))
   }
 )
@@ -92,11 +92,11 @@ export const toStreamSliding: {
  * @category conversions
  */
 export const toStreamDropping: {
-  (capacity: number): <R, E, A>(fx: Fx.Fx<R, E, A>) => Stream.Stream<R, E, A>
-  <R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<R, E, A>
+  (capacity: number): <R, E, A>(fx: Fx.Fx<R, E, A>) => Stream.Stream<A, E, R>
+  <R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<A, E, R>
 } = dual(
   2,
-  function toStreamDropping<R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<R, E, A> {
+  function toStreamDropping<R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<A, E, R> {
     return toStreamQueued(fx, Queue.dropping(capacity))
   }
 )
@@ -108,11 +108,11 @@ export const toStreamDropping: {
  * @category conversions
  */
 export const toStreamBounded: {
-  (capacity: number): <R, E, A>(fx: Fx.Fx<R, E, A>) => Stream.Stream<R, E, A>
-  <R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<R, E, A>
+  (capacity: number): <R, E, A>(fx: Fx.Fx<R, E, A>) => Stream.Stream<A, E, R>
+  <R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<A, E, R>
 } = dual(
   2,
-  function toStreamBounded<R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<R, E, A> {
+  function toStreamBounded<R, E, A>(fx: Fx.Fx<R, E, A>, capacity: number): Stream.Stream<A, E, R> {
     return toStreamQueued(fx, Queue.bounded(capacity))
   }
 )
@@ -123,7 +123,7 @@ export const toStreamBounded: {
  * @category conversions
  */
 export function fromStream<R, E, A>(
-  stream: Stream.Stream<R, E, A>
+  stream: Stream.Stream<A, E, R>
 ): Fx.Fx<R, E, A> {
   return Fx.make<R, E, A>((sink) => Effect.catchAllCause(Stream.runForEach(stream, sink.onSuccess), sink.onFailure))
 }
@@ -133,7 +133,7 @@ export function fromStream<R, E, A>(
  * @since 1.18.0
  * @category conversions
  */
-export function fromStreamChunked<R, E, A>(stream: Stream.Stream<R, E, A>): Fx.Fx<R, E, Chunk.Chunk<A>> {
+export function fromStreamChunked<R, E, A>(stream: Stream.Stream<A, E, R>): Fx.Fx<R, E, Chunk.Chunk<A>> {
   return Fx.make<R, E, Chunk.Chunk<A>>((sink) =>
     Effect.catchAllCause(Stream.runForEachChunk(stream, sink.onSuccess), sink.onFailure)
   )

package/src/Subject.ts

@@ -27,8 +27,8 @@ import { TypeId } from "./TypeId.js"
  * @since 1.20.0
  */
 export interface Subject<out R, in out E, in out A> extends Push<R, E, A, R | Scope.Scope, E, A>, Pipeable.Pipeable {
-  readonly subscriberCount: Effect.Effect<R, never, number>
-  readonly interrupt: Effect.Effect<R, never, void>
+  readonly subscriberCount: Effect.Effect<number, never, R>
+  readonly interrupt: Effect.Effect<void, never, R>
 }
 
 /**
@@ -41,7 +41,7 @@ export namespace Subject {
   export interface Tagged<I, E, A> extends Subject<I, E, A> {
     readonly tag: C.Tagged<I, Subject<never, E, A>>
 
-    readonly make: (replay?: number) => Layer.Layer<never, never, I>
+    readonly make: (replay?: number) => Layer.Layer<I>
     readonly provide: Provide<I>
   }
 
@@ -63,10 +63,10 @@ export namespace Subject {
   ) => Args extends readonly [infer _ extends number] ? <T extends Fx<any, any, any> | Effect.Effect<any, any, any>>(
       fxOrEffect: T
     ) => [T] extends [Fx<infer R2, infer E2, infer B>] ? Fx<Exclude<R2, I>, E2, B>
-      : [T] extends [Effect.Effect<infer R2, infer E2, infer B>] ? Effect.Effect<Exclude<R2, I>, E2, B>
+      : [T] extends [Effect.Effect<infer B, infer E2, infer R2>] ? Effect.Effect<B, E2, Exclude<R2, I>>
       : never
     : Args extends readonly [Fx<infer R2, infer E2, infer B>] ? Fx<Exclude<R2, I>, E2, B>
-    : Args extends readonly [Effect.Effect<infer R2, infer E2, infer B>] ? Effect.Effect<Exclude<R2, I>, E2, B>
+    : Args extends readonly [Effect.Effect<infer B, infer E2, infer R2>] ? Effect.Effect<B, E2, Exclude<R2, I>>
     : never
 }
 
@@ -85,7 +85,7 @@ export class SubjectImpl<E, A> extends FxBase<Scope.Scope, E, A> implements Subj
     this.onSuccess = this.onSuccess.bind(this)
   }
 
-  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R2 | Scope.Scope, never, unknown> {
+  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<unknown, never, R2 | Scope.Scope> {
     return this.addSink(sink, awaitScopeClose)
   }
 
@@ -111,8 +111,8 @@ export class SubjectImpl<E, A> extends FxBase<Scope.Scope, E, A> implements Subj
 
   protected addSink<R, R2, B>(
     sink: Sink<R, E, A>,
-    f: (scope: Scope.Scope) => Effect.Effect<R2, never, B>
-  ): Effect.Effect<R2 | Scope.Scope, never, B> {
+    f: (scope: Scope.Scope) => Effect.Effect<B, never, R2>
+  ): Effect.Effect<B, never, R2 | Scope.Scope> {
     return withScope(
       (innerScope) =>
         Effect.contextWithEffect((ctx) => {
@@ -135,7 +135,7 @@ export class SubjectImpl<E, A> extends FxBase<Scope.Scope, E, A> implements Subj
     )
   }
 
-  readonly subscriberCount: Effect.Effect<never, never, number> = Effect.sync(() => this.sinks.size)
+  readonly subscriberCount: Effect.Effect<number> = Effect.sync(() => this.sinks.size)
 
   protected onEvent(a: A) {
     if (this.sinks.size === 0) return Effect.unit
@@ -167,7 +167,7 @@ export class HoldSubjectImpl<E, A> extends SubjectImpl<E, A> implements Subject<
       return this.onEvent(a)
     })
 
-  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R2 | Scope.Scope, never, unknown> {
+  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<unknown, never, R2 | Scope.Scope> {
     return this.addSink(sink, (scope) =>
       Option.match(MutableRef.get(this.lastValue), {
         onNone: () => awaitScopeClose(scope),
@@ -199,7 +199,7 @@ export class ReplaySubjectImpl<E, A> extends SubjectImpl<E, A> {
       return this.onEvent(a)
     })
 
-  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<R2 | Scope.Scope, never, unknown> {
+  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<unknown, never, R2 | Scope.Scope> {
     return this.addSink(
       sink,
       (scope) => Effect.zipRight(this.buffer.forEach((a) => sink.onSuccess(a)), awaitScopeClose(scope))
@@ -232,7 +232,7 @@ export function unsafeMake<E, A>(replay: number = 0): Subject<never, E, A> {
 /**
  * @since 1.20.0
  */
-export function make<E, A>(replay?: number): Effect.Effect<Scope.Scope, never, Subject<never, E, A>> {
+export function make<E, A>(replay?: number): Effect.Effect<Subject<never, E, A>, never, Scope.Scope> {
   return Effect.acquireRelease(Effect.sync(() => unsafeMake(replay)), (subject) => subject.interrupt)
 }
 
@@ -244,10 +244,10 @@ export function fromTag<I, S, R, E, A>(tag: C.Tag<I, S>, f: (s: S) => Subject<R,
 }
 
 class FromTag<I, S, R, E, A> extends FxBase<I | R | Scope.Scope, E, A> implements Subject<I | R, E, A> {
-  private get: Effect.Effect<I, never, Subject<R, E, A>>
+  private get: Effect.Effect<Subject<R, E, A>, never, I>
 
-  readonly subscriberCount: Effect.Effect<I | R, never, number>
-  readonly interrupt: Effect.Effect<I | R, never, void>
+  readonly subscriberCount: Effect.Effect<number, never, I | R>
+  readonly interrupt: Effect.Effect<void, never, I | R>
 
   constructor(readonly tag: C.Tag<I, S>, readonly f: (s: S) => Subject<R, E, A>) {
     super()
@@ -257,15 +257,15 @@ class FromTag<I, S, R, E, A> extends FxBase<I | R | Scope.Scope, E, A> implement
     this.interrupt = Effect.flatMap(this.get, (subject) => subject.interrupt)
   }
 
-  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<I | R | R2 | Scope.Scope, never, unknown> {
+  run<R2>(sink: Sink<R2, E, A>): Effect.Effect<unknown, never, I | R | R2 | Scope.Scope> {
     return Effect.flatMap(this.get, (subject) => subject.run(sink))
   }
 
-  onFailure(cause: Cause.Cause<E>): Effect.Effect<I | R, never, unknown> {
+  onFailure(cause: Cause.Cause<E>): Effect.Effect<unknown, never, I | R> {
     return Effect.flatMap(this.get, (subject) => subject.onFailure(cause))
   }
 
-  onSuccess(value: A): Effect.Effect<I | R, never, unknown> {
+  onSuccess(value: A): Effect.Effect<unknown, never, I | R> {
     return Effect.flatMap(this.get, (subject) => subject.onSuccess(value))
   }
 }
@@ -291,14 +291,14 @@ class TaggedImpl<I, E, A> extends FromTag<I, Subject<never, E, A>, never, E, A>
 
     this.provide = dual(
       isDataFirst,
-      <R2, E2, B>(fxOrEffect: Fx<R2, E2, B> | Effect.Effect<R2, E2, B>, replay?: number) => {
+      <R2, E2, B>(fxOrEffect: Fx<R2, E2, B> | Effect.Effect<B, E2, R2>, replay?: number) => {
         if (TypeId in fxOrEffect) return provide(fxOrEffect as Fx<Exclude<R2, I>, E2, B>, this.make(replay))
-        else return Effect.provide(fxOrEffect as Effect.Effect<R2, E2, B>, this.make(replay))
+        else return Effect.provide(fxOrEffect as Effect.Effect<B, E2, R2>, this.make(replay))
       }
     )
   }
 
-  make(replay?: number): Layer.Layer<never, never, I> {
+  make(replay?: number): Layer.Layer<I> {
     return this.tag.scoped(make(replay))
   }
 }

package/src/Versioned.ts

@@ -26,9 +26,9 @@ import type { Sink } from "./Sink.js"
  * @since 1.0.0
  */
 export interface Versioned<out R1, out E1, out R2, out E2, out A2, out R3, out E3, out A3>
-  extends Fx<R2, E2, A2>, Effect.Effect<R3, E3, A3>
+  extends Fx<R2, E2, A2>, Effect.Effect<A3, E3, R3>
 {
-  readonly version: Effect.Effect<R1, E1, number>
+  readonly version: Effect.Effect<number, E1, R1>
 }
 
 /**
@@ -59,9 +59,9 @@ export namespace Versioned {
  * @since 1.0.0
  */
 export function make<R1, E1, R2, E2, A2, R3, E3, A3>(
-  version: Effect.Effect<R1, E1, number>,
+  version: Effect.Effect<number, E1, R1>,
   fx: Fx<R2, E2, A2>,
-  effect: Effect.Effect<R3, E3, A3>
+  effect: Effect.Effect<A3, E3, R3>
 ): Versioned<R1, E1, R2, E2, A2, R3, E3, A3> {
   return new VersionedImpl(version, fx, effect)
 }
@@ -70,18 +70,18 @@ class VersionedImpl<R1, E1, R2, E2, A2, R3, E3, A3> extends FxEffectBase<R2, E2,
   implements Versioned<R1, E1, R2, E2, A2, R3, E3, A3>
 {
   constructor(
-    readonly version: Effect.Effect<R1, E1, number>,
+    readonly version: Effect.Effect<number, E1, R1>,
     readonly fx: Fx<R2, E2, A2>,
-    readonly effect: Effect.Effect<R3, E3, A3>
+    readonly effect: Effect.Effect<A3, E3, R3>
   ) {
     super()
   }
 
-  run<R3>(sink: Sink<R3, E2, A2>): Effect.Effect<R2 | R3, never, unknown> {
+  run<R3>(sink: Sink<R3, E2, A2>): Effect.Effect<unknown, never, R2 | R3> {
     return this.fx.run(sink)
   }
 
-  toEffect(): Effect.Effect<R3, E3, A3> {
+  toEffect(): Effect.Effect<A3, E3, R3> {
     return this.effect
   }
 }
@@ -92,7 +92,7 @@ class VersionedImpl<R1, E1, R2, E2, A2, R3, E3, A3> extends FxEffectBase<R2, E2,
 export function transform<R0, E0, R, E, A, R2, E2, B, R3, E3, C, R4, E4, D>(
   input: Versioned<R0, E0, R, E, A, R2, E2, B>,
   transformFx: (fx: Fx<R, E, A>) => Fx<R3, E3, C>,
-  transformGet: (effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R4, E4, D>
+  transformGet: (effect: Effect.Effect<B, E2, R2>) => Effect.Effect<D, E4, R4>
 ): Versioned<never, never, R3, E3, C, R0 | R4, E0 | E4, D> {
   if (isVersionedTransform(input)) {
     return new VersionedTransform(
@@ -119,7 +119,7 @@ export class VersionedTransform<R0, E0, R, E, A, R2, E2, B, R3, E3, C, R4, E4, D
   constructor(
     readonly input: Versioned<R0, E0, R, E, A, R2, E2, B>,
     readonly _transformFx: (fx: Fx<R, E, A>) => Fx<R3, E3, C>,
-    readonly _transformEffect: (effect: Effect.Effect<R2, E2, B>) => Effect.Effect<R4, E4, D>
+    readonly _transformEffect: (effect: Effect.Effect<B, E2, R2>) => Effect.Effect<D, E4, R4>
   ) {
     super()
 
@@ -128,12 +128,12 @@ export class VersionedTransform<R0, E0, R, E, A, R2, E2, B, R3, E3, C, R4, E4, D
 
   readonly version = Effect.sync(() => this._version)
 
-  run<R5>(sink: Sink<R5, E3, C>): Effect.Effect<R3 | R5, never, unknown> {
+  run<R5>(sink: Sink<R5, E3, C>): Effect.Effect<unknown, never, R3 | R5> {
     return this._fx.run(sink)
   }
 
-  toEffect(): Effect.Effect<R0 | R4, E0 | E4, D> {
-    const transformed = this._transformEffect(this.input as any as Effect.Effect<R2, E2, B>)
+  toEffect(): Effect.Effect<D, E0 | E4, R0 | R4> {
+    const transformed = this._transformEffect(this.input as any as Effect.Effect<B, E2, R2>)
     const update = (v: number) =>
       Effect.tap(
         transformed,
@@ -199,20 +199,20 @@ export const map: {
  */
 export const mapEffect: {
   <A, R3, E3, C, B, R4, E4, D>(
-    options: { onFx: (a: A) => Effect.Effect<R3, E3, C>; onEffect: (b: B) => Effect.Effect<R4, E4, D> }
+    options: { onFx: (a: A) => Effect.Effect<C, E3, R3>; onEffect: (b: B) => Effect.Effect<D, E4, R4> }
   ): <R0, E0, R, E, R2, E2>(
     versioned: Versioned<R0, E0, R, E, A, R2, E2, B>
   ) => Versioned<never, never, R | R3, E | E3, C, R0 | R2 | R4, E0 | E2 | E4, D>
 
   <R0, E0, R, E, A, R2, E2, B, R3, E3, C, R4, E4, D>(
     versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
-    options: { onFx: (a: A) => Effect.Effect<R3, E3, C>; onEffect: (b: B) => Effect.Effect<R4, E4, D> }
+    options: { onFx: (a: A) => Effect.Effect<C, E3, R3>; onEffect: (b: B) => Effect.Effect<D, E4, R4> }
   ): Versioned<never, never, R | R3, E | E3, C, R0 | R2 | R4, E0 | E2 | E4, D>
 } = dual(2, function mapEffect<R0, E0, R, E, A, R2, E2, B, R3, E3, C, R4, E4, D>(
   versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
   options: {
-    onFx: (a: A) => Effect.Effect<R3, E3, C>
-    onEffect: (b: B) => Effect.Effect<R4, E4, D>
+    onFx: (a: A) => Effect.Effect<C, E3, R3>
+    onEffect: (b: B) => Effect.Effect<D, E4, R4>
   }
 ): Versioned<never, never, R | R3, E | E3, C, R0 | R2 | R4, E0 | E2 | E4, D> {
   return transform(versioned, (fx) => core.mapEffect(fx, options.onFx), Effect.flatMap(options.onEffect))
@@ -270,7 +270,7 @@ export const provide: {
     versioned: Versioned<R0, E0, R, E, A, R2, E2, B>
   ) => Versioned<Exclude<R0, S>, E0, Exclude<R, S>, E, A, Exclude<R2, S>, E2, B>
 
-  <R3, S>(layer: Layer.Layer<R3, never, S>): <R0, E0, R, E, A, R2, E2, B>(
+  <R3, S>(layer: Layer.Layer<S, never, R3>): <R0, E0, R, E, A, R2, E2, B>(
     versioned: Versioned<R0, E0, R, E, A, R2, E2, B>
   ) => Versioned<R3 | Exclude<R0, S>, E0, R3 | Exclude<R, S>, E, A, R3 | Exclude<R2, S>, E2, B>
 
@@ -281,21 +281,21 @@ export const provide: {
 
   <R0, E0, R, E, A, R2, E2, B, R3 = never, S = never>(
     versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
-    context: Layer.Layer<R3, never, S>
+    context: Layer.Layer<S, never, R3>
   ): Versioned<R3 | Exclude<R0, S>, E0, R3 | Exclude<R, S>, E, A, R3 | Exclude<R2, S>, E2, B>
 
   <R0, E0, R, E, A, R2, E2, B, R3 = never, S = never>(
     versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
-    context: Context.Context<S> | Runtime.Runtime<S> | Layer.Layer<R3, never, S>
+    context: Context.Context<S> | Runtime.Runtime<S> | Layer.Layer<S, never, R3>
   ): Versioned<R3 | Exclude<R0, S>, E0, R3 | Exclude<R, S>, E, A, R3 | Exclude<R2, S>, E2, B>
 } = dual(2, function provide<R0, E0, R, E, A, R2, E2, B, R3 = never, S = never>(
   versioned: Versioned<R0, E0, R, E, A, R2, E2, B>,
-  context: Context.Context<S> | Runtime.Runtime<S> | Layer.Layer<R3, never, S>
+  context: Context.Context<S> | Runtime.Runtime<S> | Layer.Layer<S, never, R3>
 ): Versioned<R3 | Exclude<R0, S>, E0, R3 | Exclude<R, S>, E, A, R3 | Exclude<R2, S>, E2, B> {
   return make(
-    Effect.provide(versioned.version, context as Layer.Layer<R3, never, S>),
+    Effect.provide(versioned.version, context as Layer.Layer<S, never, R3>),
     core.provide(versioned, context),
-    Effect.provide(versioned, context as Layer.Layer<R3, never, S>)
+    Effect.provide(versioned, context as Layer.Layer<S, never, R3>)
   )
 })
 

package/src/internal/DeferredRef.ts

@@ -7,11 +7,11 @@ import { EffectBase } from "./protos.js"
 
 export class DeferredRef<E, A> extends EffectBase<never, E, A> {
   // Keep track of the latest value emitted by the stream
-  public current!: Option.Option<Exit.Exit<E, A>>
+  public current!: Option.Option<Exit.Exit<A, E>>
   public version!: number
-  public deferred!: Deferred.Deferred<E, A>
+  public deferred!: Deferred.Deferred<A, E>
 
-  constructor(private id: FiberId.FiberId, private eq: Equivalence.Equivalence<Exit.Exit<E, A>>) {
+  constructor(private id: FiberId.FiberId, private eq: Equivalence.Equivalence<Exit.Exit<A, E>>) {
     super()
     this.reset()
   }
@@ -26,7 +26,7 @@ export class DeferredRef<E, A> extends EffectBase<never, E, A> {
     })
   }
 
-  done(exit: Exit.Exit<E, A>) {
+  done(exit: Exit.Exit<A, E>) {
     const current = this.current
 
     this.current = Option.some(exit)
@@ -53,10 +53,10 @@ export class DeferredRef<E, A> extends EffectBase<never, E, A> {
   }
 }
 
-export function make<E, A>(eq: Equivalence.Equivalence<Exit.Exit<E, A>>) {
+export function make<E, A>(eq: Equivalence.Equivalence<Exit.Exit<A, E>>) {
   return Effect.map(Effect.fiberId, (id) => new DeferredRef(id, eq))
 }
 
-export function unsafeMake<E, A>(id: FiberId.FiberId, eq: Equivalence.Equivalence<Exit.Exit<E, A>>) {
+export function unsafeMake<E, A>(id: FiberId.FiberId, eq: Equivalence.Equivalence<Exit.Exit<A, E>>) {
   return new DeferredRef(id, eq)
 }