@typed/fx 1.22.2 → 1.24.0

package/src/AsyncData.ts

@@ -20,7 +20,7 @@ import { RefSubjectTypeId } from "./TypeId.js"
 /**
  * @since 1.20.0
  */
-export function asyncDataRequest<R, E, A>(effect: Effect.Effect<R, E, A>): Fx.Fx<R, never, AsyncData.AsyncData<E, A>> {
+export function asyncDataRequest<A, E, R>(effect: Effect.Effect<A, E, R>): Fx.Fx<AsyncData.AsyncData<A, E>, never, R> {
   return Fx.make((sink) =>
     Effect.flatMap(
       Effect.zipRight(sink.onSuccess(AsyncData.loading()), Effect.exit(effect)),
@@ -32,23 +32,25 @@ export function asyncDataRequest<R, E, A>(effect: Effect.Effect<R, E, A>): Fx.Fx
 /**
  * @since 1.20.0
  */
-export interface RefAsyncData<R, E, A> extends RefSubject.RefSubject<R, never, AsyncData.AsyncData<E, A>> {}
+export interface RefAsyncData<A, E = never, R = never>
+  extends RefSubject.RefSubject<AsyncData.AsyncData<A, E>, never, R>
+{}
 
 /**
  * @since 1.20.0
  */
 export const runAsyncData: {
-  <R2, E, A>(
-    effect: Effect.Effect<R2, E, A>
-  ): <R>(ref: RefAsyncData<R, E, A>) => Effect.Effect<R | R2, never, AsyncData.AsyncData<E, A>>
-  <R, E, A, R2>(
-    ref: RefAsyncData<R, E, A>,
-    effect: Effect.Effect<R2, E, A>
-  ): Effect.Effect<R | R2, never, AsyncData.AsyncData<E, A>>
-} = dual(2, function runAsyncData<R, E, A, R2>(
-  ref: RefAsyncData<R, E, A>,
-  effect: Effect.Effect<R2, E, A>
-): Effect.Effect<R | R2, never, AsyncData.AsyncData<E, A>> {
+  <R2, A, E>(
+    effect: Effect.Effect<A, E, R2>
+  ): <R>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2>
+  <A, E, R, R2>(
+    ref: RefAsyncData<A, E, R>,
+    effect: Effect.Effect<A, E, R2>
+  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2>
+} = dual(2, function runAsyncData<A, E, R, R2>(
+  ref: RefAsyncData<A, E, R>,
+  effect: Effect.Effect<A, E, R2>
+): Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2> {
   return ref.runUpdates(({ get, set }) =>
     Effect.uninterruptibleMask((restore) =>
       Effect.flatMap(
@@ -66,52 +68,52 @@ export const runAsyncData: {
  * @since 1.20.0
  */
 export const matchAsyncData: {
-  <E1, A, R2, E2, B, R3, E3, C, R4, E4, D, R5, E5, F>(
+  <E1, A, B, E2, R2, C, E3, R3, D, E4, R4, F, E5, R5>(
     matchers: {
-      readonly NoData: Fx.Fx<R2, E2, B>
-      readonly Loading: (progress: RefSubject.Filtered<never, never, Progress>) => Fx.Fx<R3, E3, C>
-      readonly Failure: (error: RefSubject.Computed<never, never, E1>) => Fx.Fx<R4, E4, D>
-      readonly Success: (value: RefSubject.RefSubject<never, never, A>) => Fx.Fx<R5, E5, F>
+      readonly NoData: Fx.Fx<B, E2, R2>
+      readonly Loading: (progress: RefSubject.Filtered<Progress>) => Fx.Fx<C, E3, R3>
+      readonly Failure: (error: RefSubject.Computed<E1>) => Fx.Fx<D, E4, R4>
+      readonly Success: (value: RefSubject.RefSubject<A>) => Fx.Fx<F, E5, R5>
     }
-  ): <R, E>(
-    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, A>>
-  ) => Fx.Fx<R | R2 | R3 | R4 | R5, E | E2 | E3 | E4 | E5, B | C | D | F>
+  ): <E, R>(
+    fx: Fx.Fx<AsyncData.AsyncData<A, E1>, E, R>
+  ) => Fx.Fx<B | C | D | F, E | E2 | E3 | E4 | E5, R | R2 | R3 | R4 | R5>
 
-  <R, E, E1, A, R2, E2, B, R3, E3, C, R4, E4, D, R5, E5, F>(fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, A>>, matchers: {
-    readonly NoData: Fx.Fx<R2, E2, B>
-    readonly Loading: (progress: RefSubject.Filtered<never, never, Progress>) => Fx.Fx<R3, E3, C>
-    readonly Failure: (error: RefSubject.Computed<never, never, E1>) => Fx.Fx<R4, E4, D>
-    readonly Success: (value: RefSubject.RefSubject<never, never, A>) => Fx.Fx<R5, E5, F>
-  }): Fx.Fx<R | R2 | R3 | R4 | R5, E | E2 | E3 | E4 | E5, B | C | D | F>
-} = dual(2, function matchAsyncData<R, E, E1, A, R2, E2, B, R3, E3, C, R4, E4, D, R5, E5, F>(
-  fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, A>>,
+  <R, E, E1, A, B, E2, R2, C, E3, R3, D, E4, R4, F, E5, R5>(fx: Fx.Fx<AsyncData.AsyncData<A, E1>, E, R>, matchers: {
+    readonly NoData: Fx.Fx<B, E2, R2>
+    readonly Loading: (progress: RefSubject.Filtered<Progress>) => Fx.Fx<C, E3, R3>
+    readonly Failure: (error: RefSubject.Computed<E1>) => Fx.Fx<D, E4, R4>
+    readonly Success: (value: RefSubject.RefSubject<A>) => Fx.Fx<F, E5, R5>
+  }): Fx.Fx<B | C | D | F, E | E2 | E3 | E4 | E5, R | R2 | R3 | R4 | R5>
+} = dual(2, function matchAsyncData<R, E, E1, A, B, E2, R2, C, E3, R3, D, E4, R4, F, E5, R5>(
+  fx: Fx.Fx<AsyncData.AsyncData<A, E1>, E, R>,
   matchers: {
-    readonly NoData: Fx.Fx<R2, E2, B>
-    readonly Loading: (progress: RefSubject.Filtered<never, never, Progress>) => Fx.Fx<R3, E3, C>
+    readonly NoData: Fx.Fx<B, E2, R2>
+    readonly Loading: (progress: RefSubject.Filtered<Progress>) => Fx.Fx<C, E3, R3>
     readonly Failure: (
-      error: RefSubject.Computed<never, never, E1>,
-      failure: RefSubject.RefSubject<never, never, AsyncData.Failure<E1>>
-    ) => Fx.Fx<R4, E4, D>
+      error: RefSubject.Computed<E1>,
+      failure: RefSubject.RefSubject<AsyncData.Failure<E1>>
+    ) => Fx.Fx<D, E4, R4>
     readonly Success: (
-      value: RefSubject.RefSubject<never, never, A>,
-      data: RefSubject.RefSubject<never, never, AsyncData.Success<A> | AsyncData.Optimistic<E1, A>>
-    ) => Fx.Fx<R5, E5, F>
+      value: RefSubject.RefSubject<A>,
+      data: RefSubject.RefSubject<AsyncData.Success<A> | AsyncData.Optimistic<A, E1>>
+    ) => Fx.Fx<F, E5, R5>
   }
-): Fx.Fx<R | R2 | R3 | R4 | R5, E | E2 | E3 | E4 | E5, B | C | D | F> {
+): Fx.Fx<B | C | D | F, E | E2 | E3 | E4 | E5, R | R2 | R3 | R4 | R5> {
   return Fx.withKey(
     fx,
     {
-      getKey: (a: AsyncData.AsyncData<E1, A>) => a._tag === "Optimistic" ? "Success" : a._tag,
-      onValue: (ref, key): Fx.Fx<R | R2 | R3 | R4 | R5, E | E2 | E3 | E4 | E5, B | C | D | F> => {
+      getKey: (a: AsyncData.AsyncData<A, E1>) => a._tag === "Optimistic" ? "Success" : a._tag,
+      onValue: (ref, key): Fx.Fx<B | C | D | F, E | E2 | E3 | E4 | E5, R | R2 | R3 | R4 | R5> => {
         switch (key) {
           case "NoData":
             return matchers.NoData
           case "Loading":
             return matchers.Loading(
-              RefSubject.filterMap(ref as RefSubject.RefSubject<never, never, AsyncData.Loading>, (l) => l.progress)
+              RefSubject.filterMap(ref as RefSubject.RefSubject<AsyncData.Loading>, (l) => l.progress)
             )
           case "Failure": {
-            const failure = ref as RefSubject.RefSubject<never, never, AsyncData.Failure<E1>>
+            const failure = ref as RefSubject.RefSubject<AsyncData.Failure<E1>>
             return matchers.Failure(
               RefSubject.mapEffect(
                 failure,
@@ -125,11 +127,7 @@ export const matchAsyncData: {
             )
           }
           case "Success": {
-            const success = ref as RefSubject.RefSubject<
-              never,
-              never,
-              AsyncData.Success<A> | AsyncData.Optimistic<E1, A>
-            >
+            const success = ref as RefSubject.RefSubject<AsyncData.Success<A> | AsyncData.Optimistic<A, E1>>
 
             return matchers.Success(
               RefSubject.transformOrFail(
@@ -138,7 +136,7 @@ export const matchAsyncData: {
                 (value) =>
                   Effect.map(
                     success,
-                    (d) => AsyncData.map(d, () => value) as AsyncData.Success<A> | AsyncData.Optimistic<E1, A>
+                    (d) => AsyncData.map(d, () => value) as AsyncData.Success<A> | AsyncData.Optimistic<A, E1>
                   )
               ),
               success
@@ -154,43 +152,43 @@ export const matchAsyncData: {
  * @since 1.20.0
  */
 export const matchAsyncDataArray: {
-  <E1, A, K extends PropertyKey, R2, E2, B, R3, E3, C, R4, E4, D, R5, E5, F>(
+  <E1, A, K extends PropertyKey, B, E2, R2, C, E3, R3, D, E4, R4, F, E5, R5>(
     getKey: (a: A) => K,
     matchers: {
-      readonly NoData: Fx.Fx<R2, E2, B>
-      readonly Loading: (progress: RefSubject.Filtered<never, never, Progress>) => Fx.Fx<R3, E3, C>
-      readonly Failure: (error: RefSubject.Computed<never, never, E1>) => Fx.Fx<R4, E4, D>
-      readonly Success: (value: RefSubject.RefSubject<never, never, A>, key: K) => Fx.Fx<R5, E5, F>
+      readonly NoData: Fx.Fx<B, E2, R2>
+      readonly Loading: (progress: RefSubject.Filtered<Progress>) => Fx.Fx<C, E3, R3>
+      readonly Failure: (error: RefSubject.Computed<E1>) => Fx.Fx<D, E4, R4>
+      readonly Success: (value: RefSubject.RefSubject<A>, key: K) => Fx.Fx<F, E5, R5>
     }
-  ): <R, E>(
-    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, ReadonlyArray<A>>>
-  ) => Fx.Fx<Scope.Scope | R | R2 | R3 | R4 | R5, E | E2 | E3 | E4 | E5, B | C | D | ReadonlyArray<F>>
+  ): <E, R>(
+    fx: Fx.Fx<AsyncData.AsyncData<ReadonlyArray<A>, E1>, E, R>
+  ) => Fx.Fx<B | C | D | ReadonlyArray<F>, E | E2 | E3 | E4 | E5, Scope.Scope | R | R2 | R3 | R4 | R5>
 
-  <R, E, E1, A, K extends PropertyKey, R2, E2, B, R3, E3, C, R4, E4, D, R5, E5, F>(
-    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, ReadonlyArray<A>>>,
+  <R, E, E1, A, K extends PropertyKey, B, E2, R2, C, E3, R3, D, E4, R4, F, E5, R5>(
+    fx: Fx.Fx<AsyncData.AsyncData<ReadonlyArray<A>, E1>, E, R>,
     getKey: (a: A) => K,
     matchers: {
-      readonly NoData: Fx.Fx<R2, E2, B>
-      readonly Loading: (progress: RefSubject.Filtered<never, never, Progress>) => Fx.Fx<R3, E3, C>
-      readonly Failure: (error: RefSubject.Computed<never, never, E1>) => Fx.Fx<R4, E4, D>
-      readonly Success: (value: RefSubject.RefSubject<never, never, A>, key: K) => Fx.Fx<R5, E5, F>
+      readonly NoData: Fx.Fx<B, E2, R2>
+      readonly Loading: (progress: RefSubject.Filtered<Progress>) => Fx.Fx<C, E3, R3>
+      readonly Failure: (error: RefSubject.Computed<E1>) => Fx.Fx<D, E4, R4>
+      readonly Success: (value: RefSubject.RefSubject<A>, key: K) => Fx.Fx<F, E5, R5>
     }
-  ): Fx.Fx<Scope.Scope | R | R2 | R3 | R4 | R5, E | E2 | E3 | E4 | E5, B | C | D | ReadonlyArray<F>>
+  ): Fx.Fx<B | C | D | ReadonlyArray<F>, E | E2 | E3 | E4 | E5, Scope.Scope | R | R2 | R3 | R4 | R5>
 } = dual(
   3,
-  function matchAsyncDataArray<R, E, E1, A, K extends PropertyKey, R2, E2, B, R3, E3, C, R4, E4, D, R5, E5, F>(
-    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, ReadonlyArray<A>>>,
+  function matchAsyncDataArray<R, E, E1, A, K extends PropertyKey, B, E2, R2, C, E3, R3, D, E4, R4, F, E5, R5>(
+    fx: Fx.Fx<AsyncData.AsyncData<ReadonlyArray<A>, E1>, E, R>,
     getKey: (a: A) => K,
     matchers: {
-      readonly NoData: Fx.Fx<R2, E2, B>
-      readonly Loading: (progress: RefSubject.Filtered<never, never, Progress>) => Fx.Fx<R3, E3, C>
+      readonly NoData: Fx.Fx<B, E2, R2>
+      readonly Loading: (progress: RefSubject.Filtered<Progress>) => Fx.Fx<C, E3, R3>
       readonly Failure: (
-        error: RefSubject.Computed<never, never, E1>
-      ) => Fx.Fx<R4, E4, D>
+        error: RefSubject.Computed<E1>
+      ) => Fx.Fx<D, E4, R4>
       readonly Success: (
-        value: RefSubject.RefSubject<never, never, A>,
+        value: RefSubject.RefSubject<A>,
         key: K
-      ) => Fx.Fx<R5, E5, F>
+      ) => Fx.Fx<F, E5, R5>
     }
   ) {
     return matchAsyncData(fx, {
@@ -206,17 +204,17 @@ export const matchAsyncDataArray: {
  * @since 1.20.0
  */
 export const runIfNoData: {
-  <R2, E, A>(
-    effect: Effect.Effect<R2, E, A>
-  ): <R>(ref: RefAsyncData<R, E, A>) => Effect.Effect<R | R2, never, AsyncData.AsyncData<E, A>>
-  <R, E, A, R2>(
-    ref: RefAsyncData<R, E, A>,
-    effect: Effect.Effect<R2, E, A>
-  ): Effect.Effect<R | R2, never, AsyncData.AsyncData<E, A>>
-} = dual(2, function runIfNoData<R, E, A, R2>(
-  ref: RefAsyncData<R, E, A>,
-  effect: Effect.Effect<R2, E, A>
-): Effect.Effect<R | R2, never, AsyncData.AsyncData<E, A>> {
+  <R2, A, E>(
+    effect: Effect.Effect<A, E, R2>
+  ): <R>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2>
+  <A, E, R, R2>(
+    ref: RefAsyncData<A, E, R>,
+    effect: Effect.Effect<A, E, R2>
+  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2>
+} = dual(2, function runIfNoData<A, E, R, R2>(
+  ref: RefAsyncData<A, E, R>,
+  effect: Effect.Effect<A, E, R2>
+): Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2> {
   return Effect.flatMap(
     ref,
     (current) => AsyncData.isNoData(current) ? runAsyncData(ref, effect) : Effect.succeed(current)
@@ -227,21 +225,21 @@ export const runIfNoData: {
  * @since 1.20.0
  */
 export const runIfExpired: {
-  <R2, E, A>(
-    effect: Effect.Effect<R2, E, A>,
+  <R2, A, E>(
+    effect: Effect.Effect<A, E, R2>,
     options: { readonly ttl: Duration.DurationInput; readonly now?: number }
-  ): <R>(ref: RefAsyncData<R, E, A>) => Effect.Effect<R | R2, never, AsyncData.AsyncData<E, A>>
+  ): <R>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2>
 
-  <R, E, A, R2>(
-    ref: RefAsyncData<R, E, A>,
-    effect: Effect.Effect<R2, E, A>,
+  <A, E, R, R2>(
+    ref: RefAsyncData<A, E, R>,
+    effect: Effect.Effect<A, E, R2>,
     options: { readonly ttl: Duration.DurationInput; readonly now?: number }
-  ): Effect.Effect<R | R2, never, AsyncData.AsyncData<E, A>>
-} = dual(3, function runIfExpired<R, E, A, R2>(
-  ref: RefAsyncData<R, E, A>,
-  effect: Effect.Effect<R2, E, A>,
+  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2>
+} = dual(3, function runIfExpired<A, E, R, R2>(
+  ref: RefAsyncData<A, E, R>,
+  effect: Effect.Effect<A, E, R2>,
   { now, ttl }: { readonly ttl: Duration.DurationInput; readonly now?: number }
-): Effect.Effect<R | R2, never, AsyncData.AsyncData<E, A>> {
+): Effect.Effect<AsyncData.AsyncData<A, E>, never, R | R2> {
   return Effect.flatMap(
     ref,
     (current) => AsyncData.isExpired(current, ttl, now) ? runAsyncData(ref, effect) : Effect.succeed(current)
@@ -253,9 +251,9 @@ export const runIfExpired: {
  * @since 1.20.0
  * @category updates
  */
-export const awaitLoading = <R, E, A>(
-  data: RefAsyncData<R, E, A>
-): Effect.Effect<R | Scope.Scope, never, Exclude<AsyncData.AsyncData<E, A>, AsyncData.Loading>> =>
+export const awaitLoading = <A, E, R>(
+  data: RefAsyncData<A, E, R>
+): Effect.Effect<Exclude<AsyncData.AsyncData<A, E>, AsyncData.Loading>, never, R | Scope.Scope> =>
   data.pipe(
     Fx.dropWhile(AsyncData.isLoading),
     Fx.take(1),
@@ -268,9 +266,9 @@ export const awaitLoading = <R, E, A>(
  * @since 1.20.0
  * @category updates
  */
-export const awaitLoadingOrRefreshing = <R, E, A>(
-  data: RefAsyncData<R, E, A>
-): Effect.Effect<R | Scope.Scope, never, Exclude<AsyncData.AsyncData<E, A>, AsyncData.Loading>> =>
+export const awaitLoadingOrRefreshing = <A, E, R>(
+  data: RefAsyncData<A, E, R>
+): Effect.Effect<Exclude<AsyncData.AsyncData<A, E>, AsyncData.Loading>, never, R | Scope.Scope> =>
   data.pipe(
     Fx.dropWhile(AsyncData.isLoadingOrRefreshing),
     Fx.take(1),
@@ -283,9 +281,9 @@ export const awaitLoadingOrRefreshing = <R, E, A>(
  * @since 1.20.0
  * @category updates
  */
-export const startLoading: <R, E, A>(
-  ref: RefAsyncData<R, E, A>
-) => Effect.Effect<R, never, AsyncData.AsyncData<E, A>> = <R, E, A>(ref: RefAsyncData<R, E, A>) =>
+export const startLoading: <A, E, R>(
+  ref: RefAsyncData<A, E, R>
+) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R> = <A, E, R>(ref: RefAsyncData<A, E, R>) =>
   RefSubject.update(ref, AsyncData.startLoading)
 
 /**
@@ -293,9 +291,9 @@ export const startLoading: <R, E, A>(
  * @since 1.20.0
  * @category updates
  */
-export const stopLoading: <R, E, A>(
-  ref: RefAsyncData<R, E, A>
-) => Effect.Effect<R, never, AsyncData.AsyncData<E, A>> = <R, E, A>(ref: RefAsyncData<R, E, A>) =>
+export const stopLoading: <A, E, R>(
+  ref: RefAsyncData<A, E, R>
+) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R> = <A, E, R>(ref: RefAsyncData<A, E, R>) =>
   RefSubject.update(ref, AsyncData.stopLoading)
 
 /**
@@ -303,7 +301,7 @@ export const stopLoading: <R, E, A>(
  * @since 1.20.0
  * @category conversions
  */
-export const asSink = <R, E, A>(ref: RefAsyncData<R, E, A>): Sink.Sink<R, E, A> =>
+export const asSink = <A, E, R>(ref: RefAsyncData<A, E, R>): Sink.Sink<A, E, R> =>
   Sink.make(
     (cause) => RefSubject.set(ref, AsyncData.failCause(cause)),
     (a) => RefSubject.set(ref, AsyncData.success(a))
@@ -313,19 +311,19 @@ export const asSink = <R, E, A>(ref: RefAsyncData<R, E, A>): Sink.Sink<R, E, A>
  * Map the input value using an Effect
  * @since 1.20.0
  */
-export const mapInputEffect = <R, E, A, R2, B>(
-  ref: RefAsyncData<R, E, A>,
-  f: (b: B) => Effect.Effect<R2, E, A>
-): Sink.Sink<R | R2, E, B> => Sink.mapEffect(asSink(ref), f)
+export const mapInputEffect = <A, E, R, R2, B>(
+  ref: RefAsyncData<A, E, R>,
+  f: (b: B) => Effect.Effect<A, E, R2>
+): Sink.Sink<B, E, R | R2> => Sink.mapEffect(asSink(ref), f)
 
 /**
  * Map the input value
  * @since 1.20.0
  */
-export const mapInput = <R, E, A, B>(
-  ref: RefAsyncData<R, E, A>,
+export const mapInput = <A, E, R, B>(
+  ref: RefAsyncData<A, E, R>,
   f: (b: B) => A
-): Sink.Sink<R, E, B> => Sink.map(asSink(ref), f)
+): Sink.Sink<B, E, R> => Sink.map(asSink(ref), f)
 
 const isRefFirst = (args: IArguments) => args.length === 3 || RefSubjectTypeId in args[0]
 
@@ -337,15 +335,15 @@ export const failCause: {
   <E>(
     cause: Cause.Cause<E>,
     options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
-  ): <R, A>(ref: RefAsyncData<R, E, A>) => Effect.Effect<R, never, AsyncData.AsyncData<E, A>>
+  ): <R, A>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
 
-  <R, E, A>(
-    ref: RefAsyncData<R, E, A>,
+  <A, E, R>(
+    ref: RefAsyncData<A, E, R>,
     cause: Cause.Cause<E>,
     options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
-  ): Effect.Effect<R, never, AsyncData.AsyncData<E, A>>
-} = dual(isRefFirst, <R, E, A>(
-  ref: RefAsyncData<R, E, A>,
+  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
+} = dual(isRefFirst, <A, E, R>(
+  ref: RefAsyncData<A, E, R>,
   cause: Cause.Cause<E>,
   options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
 ) => RefSubject.set(ref, AsyncData.failCause(cause, options)))
@@ -358,15 +356,15 @@ export const fail: {
   <E>(
     error: E,
     options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
-  ): <R, A>(ref: RefAsyncData<R, E, A>) => Effect.Effect<R, never, AsyncData.AsyncData<E, A>>
+  ): <R, A>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
 
-  <R, E, A>(
-    ref: RefAsyncData<R, E, A>,
+  <A, E, R>(
+    ref: RefAsyncData<A, E, R>,
     error: E,
     options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
-  ): Effect.Effect<R, never, AsyncData.AsyncData<E, A>>
-} = dual(isRefFirst, <R, E, A>(
-  ref: RefAsyncData<R, E, A>,
+  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
+} = dual(isRefFirst, <A, E, R>(
+  ref: RefAsyncData<A, E, R>,
   error: E,
   options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
 ) => RefSubject.set(ref, AsyncData.fail(error, options)))
@@ -379,17 +377,17 @@ export const succeed: {
   <A>(
     value: A,
     options?: AsyncData.OptionalPartial<AsyncData.SuccessOptions>
-  ): <R, E>(ref: RefAsyncData<R, E, A>) => Effect.Effect<R, never, AsyncData.AsyncData<E, A>>
+  ): <E, R>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
 
-  <R, E, A>(
-    ref: RefAsyncData<R, E, A>,
+  <A, E, R>(
+    ref: RefAsyncData<A, E, R>,
     value: A,
     options?: AsyncData.OptionalPartial<AsyncData.SuccessOptions>
-  ): Effect.Effect<R, never, AsyncData.AsyncData<E, A>>
+  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
 } = dual(
   isRefFirst,
-  <R, E, A>(
-    ref: RefAsyncData<R, E, A>,
+  <A, E, R>(
+    ref: RefAsyncData<A, E, R>,
     value: A,
     options?: AsyncData.OptionalPartial<AsyncData.SuccessOptions>
   ) => RefSubject.set(ref, AsyncData.success(value, options))
@@ -403,17 +401,17 @@ export const optimistic: {
   <A>(
     value: A,
     options?: AsyncData.OptionalPartial<AsyncData.OptimisticOptions>
-  ): <R, E>(ref: RefAsyncData<R, E, A>) => Effect.Effect<R, never, AsyncData.AsyncData<E, A>>
+  ): <E, R>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
 
-  <R, E, A>(
-    ref: RefAsyncData<R, E, A>,
+  <A, E, R>(
+    ref: RefAsyncData<A, E, R>,
     value: A,
     options?: AsyncData.OptionalPartial<AsyncData.OptimisticOptions>
-  ): Effect.Effect<R, never, AsyncData.AsyncData<E, A>>
+  ): Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
 } = dual(
   isRefFirst,
-  <R, E, A>(
-    ref: RefAsyncData<R, E, A>,
+  <A, E, R>(
+    ref: RefAsyncData<A, E, R>,
     value: A,
     options?: AsyncData.OptionalPartial<AsyncData.OptimisticOptions>
   ) => RefSubject.update(ref, AsyncData.optimistic(value, options))
@@ -424,13 +422,13 @@ export const optimistic: {
  * @since 1.20.0
  */
 export const done: {
-  <E, A>(exit: Exit.Exit<E, A>): <R>(ref: RefAsyncData<R, E, A>) => Effect.Effect<R, never, AsyncData.AsyncData<E, A>>
-  <R, E, A>(ref: RefAsyncData<R, E, A>, exit: Exit.Exit<E, A>): Effect.Effect<R, never, AsyncData.AsyncData<E, A>>
+  <E, A>(exit: Exit.Exit<A, E>): <R>(ref: RefAsyncData<A, E, R>) => Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
+  <A, E, R>(ref: RefAsyncData<A, E, R>, exit: Exit.Exit<A, E>): Effect.Effect<AsyncData.AsyncData<A, E>, never, R>
 } = dual(
   2,
-  <R, E, A>(
-    ref: RefAsyncData<R, E, A>,
-    exit: Exit.Exit<E, A>
+  <A, E, R>(
+    ref: RefAsyncData<A, E, R>,
+    exit: Exit.Exit<A, E>
   ) => RefSubject.set(ref, AsyncData.done(exit))
 )
 
@@ -438,12 +436,12 @@ export const done: {
  * @since 1.20.0
  * @category Filtered
  */
-export const getFailure = <R, E, A>(ref: RefAsyncData<R, E, A>): RefSubject.Filtered<R, never, E> =>
+export const getFailure = <A, E, R>(ref: RefAsyncData<A, E, R>): RefSubject.Filtered<E, never, R> =>
   RefSubject.filterMap(ref, AsyncData.getFailure)
 
 /**
  * @since 1.20.0
  * @category Filtered
  */
-export const getSuccess = <R, E, A>(ref: RefAsyncData<R, E, A>): RefSubject.Filtered<R, never, A> =>
+export const getSuccess = <A, E, R>(ref: RefAsyncData<A, E, R>): RefSubject.Filtered<A, never, R> =>
   RefSubject.filterMap(ref, AsyncData.getSuccess)

package/src/Emitter.ts

@@ -14,34 +14,34 @@ import * as Sink from "./Sink.js"
 /**
  * @since 1.20.0
  */
-export interface Emitter<in E, in A> {
-  readonly succeed: (value: A) => Promise<Exit.Exit<never, unknown>>
-  readonly failCause: (cause: Cause.Cause<E>) => Promise<Exit.Exit<never, unknown>>
-  readonly fail: (error: E) => Promise<Exit.Exit<never, unknown>>
-  readonly die: (error: unknown) => Promise<Exit.Exit<never, unknown>>
-  readonly end: () => Promise<Exit.Exit<never, unknown>>
+export interface Emitter<in A, in E> {
+  readonly succeed: (value: A) => Promise<Exit.Exit<unknown>>
+  readonly failCause: (cause: Cause.Cause<E>) => Promise<Exit.Exit<unknown>>
+  readonly fail: (error: E) => Promise<Exit.Exit<unknown>>
+  readonly die: (error: unknown) => Promise<Exit.Exit<unknown>>
+  readonly end: () => Promise<Exit.Exit<unknown>>
 }
 
 /**
  * @since 1.20.0
  */
-export function withEmitter<R, E, A, R2, B>(
-  sink: Sink.Sink<R, E, A>,
-  f: (emitter: Emitter<E, A>) => Effect.Effect<R2, E, B>
-): Effect.Effect<R | R2 | Scope.Scope, never, void> {
+export function withEmitter<A, E, R, R2, B>(
+  sink: Sink.Sink<A, E, R>,
+  f: (emitter: Emitter<A, E>) => Effect.Effect<B, E, R2>
+): Effect.Effect<void, never, R | R2 | Scope.Scope> {
   return withScope(
     (scope) =>
       Sink.withEarlyExit(
         sink,
-        (sink): Effect.Effect<R | R2, E, B> => {
+        (sink): Effect.Effect<B, E, R | R2> => {
           return Effect.flatMap(Effect.runtime<R>(), (runtime) => {
             const runFork = Runtime.runFork(runtime)
-            const run = <E, A>(effect: Effect.Effect<R, E, A>): Promise<Exit.Exit<E, A>> =>
+            const run = <E, A>(effect: Effect.Effect<A, E, R>): Promise<Exit.Exit<A, E>> =>
               new Promise((resolve) => {
                 const fiber = runFork(effect, { scope })
                 fiber.addObserver(resolve)
               })
-            const emitter: Emitter<E, A> = {
+            const emitter: Emitter<A, E> = {
               succeed: (value) => run(sink.onSuccess(value)),
               failCause: (cause) => run(sink.onFailure(cause)),
               fail: (error) => run(sink.onFailure(Cause.fail(error))),