@typed/fx 1.17.4 → 1.18.0

package/src/RefAsyncData.ts

@@ -0,0 +1,547 @@
+/**
+ * A RefAsyncData is a RefSubject that holds an AsyncData value.
+ * @since 1.18.0
+ */
+
+import * as AsyncData from "@typed/async-data/AsyncData"
+import type { Progress } from "@typed/async-data/Progress"
+import type { IdentifierConstructor, IdentifierOf } from "@typed/context"
+import { Either, Option } from "effect"
+import type { Exit, Scope } from "effect"
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
+import type { Schedule } from "effect/Schedule"
+import type * as Computed from "./Computed"
+import type * as Filtered from "./Filtered"
+import * as Fx from "./Fx"
+import * as RefSubject from "./RefSubject"
+import * as Sink from "./Sink"
+import { RefSubjectTypeId } from "./TypeId"
+
+/**
+ * A RefAsyncData is a RefSubject that holds an AsyncData value.
+ * @since 1.18.0
+ * @category models
+ */
+export interface RefAsyncData<R, E, A> extends RefSubject.RefSubject<R, never, AsyncData.AsyncData<E, A>> {}
+
+/**
+ * @since 1.18.0
+ */
+export namespace RefAsyncData {
+  /**
+   * @since 1.18.0
+   */
+  export interface Tagged<I, E, A> extends RefSubject.RefSubject.Tagged<I, never, AsyncData.AsyncData<E, A>> {}
+}
+
+/**
+ * Create a RefAsyncData
+ * @since 1.18.0
+ * @category constructors
+ */
+export const make: <E, A>() => Effect.Effect<
+  Scope.Scope,
+  never,
+  RefAsyncData<never, E, A>
+> = <E, A>() => RefSubject.of(AsyncData.noData<E, A>(), AsyncData.getEquivalence())
+
+/**
+ * Create a Tagged RefAsyncData
+ * @since 1.18.0
+ * @category constructors
+ */
+export const tagged = <E, A>(): {
+  <const I extends IdentifierConstructor<any>>(
+    identifier: (id: <const T>(uniqueIdentifier: T) => IdentifierConstructor<T>) => I
+  ): RefAsyncData.Tagged<IdentifierOf<I>, E, A>
+  <const I>(identifier: I | string): RefAsyncData.Tagged<IdentifierOf<I>, E, A>
+} => RefSubject.tagged<never, AsyncData.AsyncData<E, A>>()
+
+/**
+ * Change the current value of a RefAsyncData to a loading or refreshing state.
+ * @since 1.18.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>) =>
+  ref.update(AsyncData.startLoading)
+
+/**
+ * Change the current value of a RefAsyncData to a non-loading/non-refreshing state.
+ * @since 1.18.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>) =>
+  ref.update(AsyncData.stopLoading)
+
+/**
+ * Run an Effect that will first start by setting the state to loading/refreshing, and
+ * then setting the value to the Exit of the Effect. If interrupted it will stop loading/refreshing
+ * the data.
+ * @since 1.18.0
+ * @category updates
+ */
+export const run: {
+  <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,
+  <R, E, A, R2>(ref: RefAsyncData<R, E, A>, effect: Effect.Effect<R2, E, A>) =>
+    ref.runUpdate((get, set) =>
+      Effect.gen(function*(_) {
+        const initial = yield* _(get)
+
+        yield* _(set(AsyncData.startLoading(initial)))
+        const exit = yield* _(Effect.exit(effect))
+        return yield* _(set(AsyncData.done(exit)))
+      }), (current) => Effect.succeed(AsyncData.stopLoading(current)))
+)
+
+/**
+ * Run an Effect that will first start by setting the state to loading/refreshing if the current value is NoData, and
+ * then setting the value to the Exit of the Effect. If interrupted it will stop loading/refreshing
+ * the data.
+ * @since 1.18.0
+ * @category updates
+ */
+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,
+  <R, E, A, R2>(ref: RefAsyncData<R, E, A>, effect: Effect.Effect<R2, E, A>) =>
+    ref.runUpdate((get, set) =>
+      Effect.gen(function*(_) {
+        const initial = yield* _(get)
+
+        if (AsyncData.isNoData(initial) || (AsyncData.isFailure(initial) && Option.isNone(initial.refreshing))) {
+          yield* _(set(AsyncData.startLoading(initial)))
+          const exit = yield* _(Effect.exit(effect))
+          return yield* _(set(AsyncData.done(exit)))
+        }
+
+        return initial
+      }), (current) => Effect.succeed(AsyncData.stopLoading(current)))
+)
+
+/**
+ * Repeat an Effect on a Schedule
+ * @since 1.18.0
+ * @category updates
+ */
+export const runRepeat: {
+  <R2, E, A, R3, X>(
+    effect: Effect.Effect<R2, E, A>,
+    schedule: Schedule<R3, unknown, X>
+  ): <R>(ref: RefAsyncData<R, E, A>) => Effect.Effect<R | R2 | R3, never, AsyncData.AsyncData<E, A>>
+
+  <R, E, A, R2, R3, X>(
+    ref: RefAsyncData<R, E, A>,
+    effect: Effect.Effect<R2, E, A>,
+    schedule: Schedule<R3, unknown, X>
+  ): Effect.Effect<R | R2 | R3, never, AsyncData.AsyncData<E, A>>
+} = dual(
+  3,
+  <R, E, A, R2, R3, X>(
+    ref: RefAsyncData<R, E, A>,
+    effect: Effect.Effect<R2, E, A>,
+    schedule: Schedule<R3, unknown, X>
+  ) => Effect.repeat(run(ref, effect), schedule)
+)
+
+/**
+ * Retry an Effect on a Schedule
+ * @since 1.18.0
+ * @category updates
+ */
+export const runRetry: {
+  <R2, E, A, R3, X>(
+    effect: Effect.Effect<R2, E, A>,
+    schedule: Schedule<R3, unknown, X>
+  ): <R>(ref: RefAsyncData<R, E, A>) => Effect.Effect<R | R2 | R3, never, AsyncData.AsyncData<E, A>>
+
+  <R, E, A, R2, R3, X>(
+    ref: RefAsyncData<R, E, A>,
+    effect: Effect.Effect<R2, E, A>,
+    schedule: Schedule<R3, unknown, X>
+  ): Effect.Effect<R | R2 | R3, never, AsyncData.AsyncData<E, A>>
+} = dual(
+  3,
+  <R, E, A, R2, R3, X>(
+    ref: RefAsyncData<R, E, A>,
+    effect: Effect.Effect<R2, E, A>,
+    schedule: Schedule<R3, unknown, X>
+  ) => Effect.retry(run(ref, effect), schedule)
+)
+
+/**
+ * Retry an Effect `n` times
+ * @since 1.18.0
+ * @category updates
+ */
+export const runRetryN: {
+  <R2, E, A>(
+    effect: Effect.Effect<R2, E, A>,
+    amount: number
+  ): <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>,
+    amount: number
+  ): Effect.Effect<R | R2, never, AsyncData.AsyncData<E, A>>
+} = dual(
+  3,
+  <R, E, A, R2>(
+    ref: RefAsyncData<R, E, A>,
+    effect: Effect.Effect<R2, E, A>,
+    amount: number
+  ) => Effect.retryN(run(ref, effect), amount)
+)
+
+/**
+ * Await for the AsyncData to stop loading.
+ * @since 1.18.0
+ * @category updates
+ */
+export const awaitLoading = <R, E, A>(
+  data: RefAsyncData<R, E, A>
+): Effect.Effect<R, never, AsyncData.AsyncData<E, A>> =>
+  data.pipe(
+    Fx.dropWhile((data) => Effect.succeed(AsyncData.isLoading(data))),
+    Fx.take(1),
+    Fx.toReadonlyArray,
+    Effect.map((x) => x[0])
+  )
+
+/**
+ * Await for the AsyncData to stop loading or refreshing.
+ * @since 1.18.0
+ * @category updates
+ */
+export const awaitLoadingOrRefreshing = <R, E, A>(
+  data: RefAsyncData<R, E, A>
+): Effect.Effect<R, never, AsyncData.AsyncData<E, A>> =>
+  data.pipe(
+    Fx.dropWhile((data) => Effect.succeed(AsyncData.isLoadingOrRefreshing(data))),
+    Fx.take(1),
+    Fx.toReadonlyArray,
+    Effect.map((x) => x[0])
+  )
+
+/**
+ * Convert RefAsyncData into a Sink.
+ * @since 1.18.0
+ * @category conversions
+ */
+export const asSink = <R, E, A>(ref: RefAsyncData<R, E, A>): Sink.WithContext<R, E, A> =>
+  Sink.WithContext((cause) => ref.set(AsyncData.failCause(cause)), (a) => ref.set(AsyncData.success(a)))
+
+/**
+ * Map the input value using an Effect
+ * @since 1.18.0
+ */
+export const mapInputEffect = <R, E, A, R2, B>(
+  ref: RefAsyncData<R, E, A>,
+  f: (b: B) => Effect.Effect<R2, E, A>
+): Sink.WithContext<R | R2, E, B> => Sink.mapEffect(asSink(ref), f)
+
+/**
+ * Map the input value
+ * @since 1.18.0
+ */
+export const mapInput = <R, E, A, B>(
+  ref: RefAsyncData<R, E, A>,
+  f: (b: B) => A
+): Sink.WithContext<R, E, B> => Sink.map(asSink(ref), f)
+
+/**
+ * Fail with a given cause
+ * @since 1.18.0
+ */
+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, E, A>(
+    ref: RefAsyncData<R, E, A>,
+    cause: Cause.Cause<E>,
+    options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
+  ): Effect.Effect<R, never, AsyncData.AsyncData<E, A>>
+} = dual((args) => args.length === 3 || RefSubjectTypeId in args[0], <R, E, A>(
+  ref: RefAsyncData<R, E, A>,
+  cause: Cause.Cause<E>,
+  options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
+) => ref.set(AsyncData.failCause(cause, options)))
+
+/**
+ * Fail with a given error
+ * @since 1.18.0
+ */
+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, E, A>(
+    ref: RefAsyncData<R, E, A>,
+    error: E,
+    options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
+  ): Effect.Effect<R, never, AsyncData.AsyncData<E, A>>
+} = dual((args) => args.length === 3 || RefSubjectTypeId in args[0], <R, E, A>(
+  ref: RefAsyncData<R, E, A>,
+  error: E,
+  options?: AsyncData.OptionalPartial<AsyncData.FailureOptions>
+) => ref.set(AsyncData.fail(error, options)))
+
+/**
+ * Succeed with a value
+ * @since 1.18.0
+ */
+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>>
+
+  <R, E, A>(
+    ref: RefAsyncData<R, E, A>,
+    value: A,
+    options?: AsyncData.OptionalPartial<AsyncData.SuccessOptions>
+  ): Effect.Effect<R, never, AsyncData.AsyncData<E, A>>
+} = dual((args) => args.length === 3 || RefSubjectTypeId in args[0], <R, E, A>(
+  ref: RefAsyncData<R, E, A>,
+  value: A,
+  options?: AsyncData.OptionalPartial<AsyncData.SuccessOptions>
+) => ref.set(AsyncData.success(value, options)))
+
+/**
+ * Set Exit value of RefAsyncData
+ * @since 1.18.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>>
+} = dual((args) => args.length === 3 || RefSubjectTypeId in args[0], <R, E, A>(
+  ref: RefAsyncData<R, E, A>,
+  exit: Exit.Exit<E, A>
+) => ref.set(AsyncData.done(exit)))
+
+/**
+ * Match over the states of AsyncData with an Fx
+ * @since 1.18.0
+ */
+export const match: {
+  <
+    E1,
+    A,
+    R2 = never,
+    E2 = never,
+    B = never,
+    R3 = never,
+    E3 = never,
+    C = never,
+    R4 = never,
+    E4 = never,
+    D = never,
+    R5 = never,
+    E5 = never,
+    F = never
+  >(
+    matchers: {
+      NoData: (data: AsyncData.NoData) => Fx.FxInput<R2, E2, B>
+      Loading: (data: AsyncData.Loading) => Fx.FxInput<R3, E3, C>
+      Failure: (cause: Cause.Cause<E1>, data: AsyncData.Failure<E1>) => Fx.FxInput<R4, E4, D>
+      Success: (value: A, data: AsyncData.Success<A>) => Fx.FxInput<R5, E5, F>
+    }
+  ): <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>
+
+  <
+    R,
+    E,
+    E1,
+    A,
+    R2 = never,
+    E2 = never,
+    B = never,
+    R3 = never,
+    E3 = never,
+    C = never,
+    R4 = never,
+    E4 = never,
+    D = never,
+    R5 = never,
+    E5 = never,
+    F = never
+  >(
+    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, A>>,
+    matchers: {
+      NoData: (data: AsyncData.NoData) => Fx.FxInput<R2, E2, B>
+      Loading: (data: AsyncData.Loading) => Fx.FxInput<R3, E3, C>
+      Failure: (cause: Cause.Cause<E1>, data: AsyncData.Failure<E1>) => Fx.FxInput<R4, E4, D>
+      Success: (value: A, data: AsyncData.Success<A>) => Fx.FxInput<R5, E5, F>
+    }
+  ): Fx.Fx<R | R2 | R3 | R4 | R5, E | E2 | E3 | E4 | E5, B | C | D | F>
+} = dual(2, <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: {
+    NoData: (data: AsyncData.NoData) => Fx.FxInput<R2, E2, B>
+    Loading: (data: AsyncData.Loading) => Fx.FxInput<R3, E3, C>
+    Failure: (cause: Cause.Cause<E1>, data: AsyncData.Failure<E1>) => Fx.FxInput<R4, E4, D>
+    Success: (value: A, data: AsyncData.Success<A>) => Fx.FxInput<R5, E5, F>
+  }
+): Fx.Fx<R | R2 | R3 | R4 | R5, E | E2 | E3 | E4 | E5, B | C | D | F> => Fx.switchMap(fx, AsyncData.match(matchers)))
+
+/**
+ * Match over the states of AsyncData with an Fx using persistent workflows.
+ * @since 1.18.0
+ */
+export const matchKeyed: {
+  <
+    E1,
+    A,
+    NoData extends Fx.FxInput<any, any, any>,
+    Loading extends Fx.FxInput<any, any, any>,
+    Failure extends Fx.FxInput<any, any, any>,
+    Success extends Fx.FxInput<any, any, any>
+  >(
+    matchers: {
+      NoData: () => NoData
+      Loading: (data: LoadingComputed) => Loading
+      Failure: (data: Computed.Computed<never, never, E1>, computed: FailureComputed<E1>) => Failure
+      Success: (value: Computed.Computed<never, never, A>, computed: SuccessComputed) => Success
+    }
+  ): <R, E>(
+    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, A>>
+  ) => Fx.Fx<
+    R | Fx.Fx.Context<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>,
+    E | Fx.Fx.Error<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>,
+    Fx.Fx.Success<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>
+  >
+
+  <
+    R,
+    E,
+    E1,
+    A,
+    NoData extends Fx.FxInput<any, any, any>,
+    Loading extends Fx.FxInput<any, any, any>,
+    Failure extends Fx.FxInput<any, any, any>,
+    Success extends Fx.FxInput<any, any, any>
+  >(
+    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, A>>,
+    matchers: {
+      NoData: () => NoData
+      Loading: (data: LoadingComputed) => Loading
+      Failure: (data: Computed.Computed<never, never, E1>, computed: FailureComputed<E1>) => Failure
+      Success: (value: Computed.Computed<never, never, A>, computed: SuccessComputed) => Success
+    }
+  ): Fx.Fx<
+    R | Fx.Fx.Context<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>,
+    E | Fx.Fx.Error<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>,
+    Fx.Fx.Success<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>
+  >
+} = dual(
+  2,
+  <
+    R,
+    E,
+    E1,
+    A,
+    NoData extends Fx.FxInput<any, any, any>,
+    Loading extends Fx.FxInput<any, any, any>,
+    Failure extends Fx.FxInput<any, any, any>,
+    Success extends Fx.FxInput<any, any, any>
+  >(
+    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, A>>,
+    matchers: {
+      NoData: () => NoData
+      Loading: (data: LoadingComputed) => Loading
+      Failure: (data: Computed.Computed<never, never, E1>, computed: FailureComputed<E1>) => Failure
+      Success: (value: Computed.Computed<never, never, A>, computed: SuccessComputed) => Success
+    }
+  ): Fx.Fx<
+    R | Fx.Fx.Context<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>,
+    E | Fx.Fx.Error<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>,
+    Fx.Fx.Success<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>
+  > =>
+    Fx.matchTags(fx, {
+      NoData: () => matchers.NoData(),
+      Loading: (ref) => matchers.Loading({ progress: ref.map((r) => r.progress) }),
+      Failure: (ref) =>
+        matchers.Failure(
+          ref.mapEffect(({ cause }) =>
+            Cause.failureOrCause(cause).pipe(Either.flip, Effect.catchAll(Effect.failCause))
+          ),
+          {
+            cause: ref.map((r) => r.cause),
+            refreshing: ref.map((r) => r.refreshing)
+          }
+        ),
+      Success: (ref) =>
+        matchers.Success(
+          ref.map((r) => r.value),
+          {
+            refreshing: ref.map((r) => r.refreshing)
+          }
+        )
+    })
+)
+
+/**
+ * @since 1.18.0
+ */
+export type LoadingComputed = {
+  readonly progress: Computed.Computed<never, never, Option.Option<Progress>>
+}
+
+/**
+ * @since 1.18.0
+ */
+export type FailureComputed<E> = {
+  readonly cause: Computed.Computed<never, never, Cause.Cause<E>>
+  readonly refreshing: Computed.Computed<never, never, Option.Option<AsyncData.Loading>>
+}
+
+/**
+ * @since 1.18.0
+ */
+export type SuccessComputed = {
+  readonly refreshing: Computed.Computed<never, never, Option.Option<AsyncData.Loading>>
+}
+
+/**
+ * @since 1.18.0
+ * @category Filtered
+ */
+export const getFailure = <R, E, A>(ref: RefAsyncData<R, E, A>): Filtered.Filtered<R, never, E> =>
+  ref.filterMap(AsyncData.getFailure)
+
+/**
+ * @since 1.18.0
+ * @category Filtered
+ */
+export const getSuccess = <R, E, A>(ref: RefAsyncData<R, E, A>): Filtered.Filtered<R, never, A> =>
+  ref.filterMap(AsyncData.getSuccess)

package/src/RefAsyncDataArray.ts

@@ -0,0 +1,135 @@
+/**
+ * A RefAsyncDataArray is a RefSubject that holds a AsyncData value of an array.
+ * @since 1.18.0
+ */
+
+import type * as AsyncData from "@typed/async-data/AsyncData"
+import type { IdentifierConstructor, IdentifierOf } from "@typed/context/Identifier"
+import type { Scope } from "effect"
+import type * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
+import type * as Computed from "./Computed"
+import * as Fx from "./Fx"
+import * as RefAsyncData from "./RefAsyncData"
+
+/**
+ * A RefAsyncDataArray is a RefSubject that holds a AsyncData value of an array.
+ * @since 1.18.0
+ */
+export interface RefAsyncDataArray<R, E, A> extends RefAsyncData.RefAsyncData<R, E, ReadonlyArray<A>> {}
+
+/**
+ * @since 1.18.0
+ */
+export namespace RefAsyncDataArray {
+  /**
+   * @since 1.18.0
+   */
+  export interface Tagged<I, E, A> extends RefAsyncData.RefAsyncData.Tagged<I, E, ReadonlyArray<A>> {}
+}
+
+/**
+ * @since 1.18.0
+ */
+export const make = <E, A>(): Effect.Effect<Scope.Scope, never, RefAsyncDataArray<never, E, A>> =>
+  RefAsyncData.make<E, ReadonlyArray<A>>()
+
+/**
+ * @since 1.18.0
+ */
+export const tagged = <E, A>(): {
+  <const I extends IdentifierConstructor<any>>(
+    identifier: (id: <const T>(uniqueIdentifier: T) => IdentifierConstructor<T>) => I
+  ): RefAsyncDataArray.Tagged<IdentifierOf<I>, E, A>
+  <const I>(identifier: I | string): RefAsyncDataArray.Tagged<IdentifierOf<I>, E, A>
+} => RefAsyncData.tagged<E, ReadonlyArray<A>>()
+
+/**
+ * @since 1.18.0
+ */
+export const matchKeyed: {
+  <
+    E1,
+    A,
+    B,
+    NoData extends Fx.FxInput<any, any, any>,
+    Loading extends Fx.FxInput<any, any, any>,
+    Failure extends Fx.FxInput<any, any, any>,
+    Success extends Fx.FxInput<any, any, any>
+  >(
+    getKey: (a: A) => B,
+    matchers: {
+      NoData: () => NoData
+      Loading: (data: RefAsyncData.LoadingComputed) => Loading
+      Failure: (data: Computed.Computed<never, never, E1>, computed: RefAsyncData.FailureComputed<E1>) => Failure
+      Success: (value: Computed.Computed<never, never, A>, computed: RefAsyncData.SuccessComputed) => Success
+    }
+  ): <R, E>(
+    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, ReadonlyArray<A>>>
+  ) => Fx.Fx<
+    R | Fx.Fx.Context<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>,
+    E | Fx.Fx.Error<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>,
+    | Fx.Fx.Success<Fx.Fx.FromInput<NoData | Loading | Failure>>
+    | ReadonlyArray<Fx.Fx.Success<Fx.Fx.FromInput<Success>>>
+  >
+
+  <
+    R,
+    E,
+    E1,
+    A,
+    B,
+    NoData extends Fx.FxInput<any, any, any>,
+    Loading extends Fx.FxInput<any, any, any>,
+    Failure extends Fx.FxInput<any, any, any>,
+    Success extends Fx.FxInput<any, any, any>
+  >(
+    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, ReadonlyArray<A>>>,
+    getKey: (a: A) => B,
+    matchers: {
+      NoData: () => NoData
+      Loading: (data: RefAsyncData.LoadingComputed) => Loading
+      Failure: (data: Computed.Computed<never, never, E1>, computed: RefAsyncData.FailureComputed<E1>) => Failure
+      Success: (value: Computed.Computed<never, never, A>, computed: RefAsyncData.SuccessComputed) => Success
+    }
+  ): Fx.Fx<
+    R | Fx.Fx.Context<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>,
+    E | Fx.Fx.Error<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>,
+    | Fx.Fx.Success<Fx.Fx.FromInput<NoData | Loading | Failure>>
+    | ReadonlyArray<Fx.Fx.Success<Fx.Fx.FromInput<Success>>>
+  >
+} = dual(
+  3,
+  <
+    R,
+    E,
+    E1,
+    A,
+    B,
+    NoData extends Fx.FxInput<any, any, any>,
+    Loading extends Fx.FxInput<any, any, any>,
+    Failure extends Fx.FxInput<any, any, any>,
+    Success extends Fx.FxInput<any, any, any>
+  >(
+    fx: Fx.Fx<R, E, AsyncData.AsyncData<E1, ReadonlyArray<A>>>,
+    getKey: (a: A) => B,
+    matchers: {
+      NoData: () => NoData
+      Loading: (data: RefAsyncData.LoadingComputed) => Loading
+      Failure: (data: Computed.Computed<never, never, E1>, computed: RefAsyncData.FailureComputed<E1>) => Failure
+      Success: (value: Computed.Computed<never, never, A>, computed: RefAsyncData.SuccessComputed) => Success
+    }
+  ): Fx.Fx<
+    R | Fx.Fx.Context<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>,
+    E | Fx.Fx.Error<Fx.Fx.FromInput<NoData | Loading | Failure | Success>>,
+    | Fx.Fx.Success<Fx.Fx.FromInput<NoData | Loading | Failure>>
+    | ReadonlyArray<Fx.Fx.Success<Fx.Fx.FromInput<Success>>>
+  > => {
+    return RefAsyncData.matchKeyed(fx, {
+      NoData: matchers.NoData,
+      Loading: matchers.Loading,
+      Failure: matchers.Failure,
+      Success: (ref, computed) => Fx.keyed(ref, getKey, (ref) => matchers.Success(ref, computed))
+    }) as any
+  }
+)