@typed/async-data 0.11.0 → 0.13.0

package/src/AsyncData.ts

@@ -1,49 +1,57 @@
-/**
- * AsyncData represents a piece of data which is acquired asynchronously with loading, failure, and progress states
- * in addition to Option-like states of NoData and Success.
- *
- * @since 1.0.0
- */
-
-import * as Cause from "effect/Cause"
-import * as Data from "effect/Data"
-import * as Duration from "effect/Duration"
-import type * as Effect from "effect/Effect"
-import * as Either from "effect/Either"
-import * as Equal from "effect/Equal"
-import * as Equivalence from "effect/Equivalence"
-import * as Exit from "effect/Exit"
-import { dual } from "effect/Function"
-import * as Option from "effect/Option"
-import * as Unify from "effect/Unify"
-import * as internal from "./internal/async-data.js"
-import { FAILURE_TAG, LOADING_TAG, NO_DATA_TAG, OPTIMISTIC_TAG, SUCCESS_TAG } from "./internal/tag.js"
-import * as Progress from "./Progress.js"
-import { AsyncDataTypeId } from "./TypeId.js"
-
-const getCurrentTimestamp = () => Date.now()
-
-/**
- * AsyncData represents a piece of data which is acquired asynchronously with loading, failure, and progress states
- * in addition to Option-like states of NoData and Success.
- *
- * @since 1.0.0
- */
-export type AsyncData<A, E = never> = NoData | Loading | Failure<E> | Success<A> | Optimistic<A, E>
-
-/**
- * @since 1.0.0
- */
+import {
+  Cause,
+  Effect,
+  Either,
+  Equal,
+  Equivalence,
+  Exit,
+  identity,
+  Option,
+  Schema,
+  SchemaAST,
+  Unify,
+} from 'effect'
+import { dual } from 'effect/Function'
+import { Progress, type ProgressEncoded } from './Progress.js'
+import { DataEffect, LiteralWithDefault } from './_internal.js'
+
+export type AsyncData<A, E = never> =
+  | NoData
+  | Loading
+  | Success<A>
+  | Failure<E>
+  | Refreshing<A, E>
+  | Optimistic<A, E>
+
 export namespace AsyncData {
-  /**
-   * @since 1.0.0
-   */
-  export type Error<T> = [T] extends [AsyncData<infer _, infer E>] ? E : never
+  export type Encoded<A, E = never> =
+    | typeof NoData.Encoded
+    | typeof Loading.Encoded
+    | SuccessEncoded<A>
+    | FailureEncoded<E>
+    | RefreshingEncoded<A, E>
+    | OptimisticEncoded<A, E>
+  export interface SuccessEncoded<A> {
+    readonly _tag: 'Success'
+    readonly value: A
+  }
 
-  /**
-   * @since 1.0.0
-   */
-  export type Success<T> = [T] extends [AsyncData<infer A, infer _>] ? A : never
+  export interface FailureEncoded<E> {
+    readonly _tag: 'Failure'
+    readonly cause: Schema.CauseEncoded<E, unknown>
+  }
+
+  export type RefreshingEncoded<A, E = never> = {
+    readonly _tag: 'Refreshing'
+    readonly previous: SuccessEncoded<A> | FailureEncoded<E>
+    readonly progress?: ProgressEncoded
+  }
+
+  export interface OptimisticEncoded<A, E = never> {
+    readonly _tag: 'Optimistic'
+    readonly previous: Encoded<A, E>
+    readonly value: A
+  }
 
   /**
    * @category models
@@ -51,15 +59,24 @@ export namespace AsyncData {
    */
   export interface Unify<A extends { [Unify.typeSymbol]?: any }> extends Effect.EffectUnify<A> {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    AsyncData: () => Unify_<A[Unify.typeSymbol]> extends AsyncData<infer E0, infer A0> | infer _ ? AsyncData<E0, A0>
+    AsyncData: () => Unify_<A[Unify.typeSymbol]> extends AsyncData<infer E0, infer A0> | infer _
+      ? AsyncData<E0, A0>
       : never
   }
 
-  type Unify_<T extends AsyncData<any, any>> = T extends NoData ? AsyncData<never, never> :
-    T extends Loading ? AsyncData<never, never> :
-    T extends Failure<infer E> ? AsyncData<E, never>
-    : T extends Success<infer A> ? AsyncData<never, A>
-    : never
+  type Unify_<T extends AsyncData<any, any>> = T extends NoData
+    ? AsyncData<never, never>
+    : T extends Loading
+      ? AsyncData<never, never>
+      : T extends Failure<infer E>
+        ? AsyncData<E, never>
+        : T extends Success<infer A>
+          ? AsyncData<never, A>
+          : T extends Optimistic<infer A, infer E>
+            ? AsyncData<A, E>
+            : T extends Refreshing<infer A, infer E>
+              ? AsyncData<A, E>
+              : never
 
   /**
    * @category models
@@ -70,625 +87,568 @@ export namespace AsyncData {
   }
 }
 
-/**
- * @since 1.0.0
- */
-export class NoData extends Data.TaggedError(NO_DATA_TAG)<{}> {
-  /**
-   * @since 1.0.0
-   */
-  readonly [AsyncDataTypeId]: AsyncDataTypeId = AsyncDataTypeId
-
-  /**
-   * @since 1.0.0
-   */
-  readonly [Unify.typeSymbol]!: unknown
-  /**
-   * @since 1.0.0
-   */
-  readonly [Unify.unifySymbol]!: AsyncData.Unify<this>
-  /**
-   * @since 1.0.0
-   */
-  readonly [Unify.ignoreSymbol]!: AsyncData.IgnoreList
-}
+export class NoData
+  extends Schema.TaggedError<NoData>()('NoData', {})
+  implements Effect.Effect<never, NoData, never> {}
 
-/**
- * @since 1.0.0
- */
 export const noData: {
   (): NoData
-  <A, E>(): AsyncData<A, E>
-} = (): NoData => new NoData()
-
-/**
- * @since 1.0.0
- */
-export class Loading extends Data.TaggedError(LOADING_TAG)<LoadingOptions> {
-  /**
-   * @since 1.0.0
-   */
-  readonly [AsyncDataTypeId]: AsyncDataTypeId = AsyncDataTypeId
+  <A, E = never>(): AsyncData<A, E>
+} = () => NoData.make()
 
-  /**
-   * @since 1.0.0
-   */
-  readonly [Unify.typeSymbol]!: unknown
-  /**
-   * @since 1.0.0
-   */
-  readonly [Unify.unifySymbol]!: AsyncData.Unify<this>
-  /**
-   * @since 1.0.0
-   */
-  readonly [Unify.ignoreSymbol]!: AsyncData.IgnoreList
-}
+export class Loading
+  extends Schema.TaggedError<Loading>()('Loading', {
+    progress: Schema.optionalWith(Progress, { as: 'Option', default: undefined }),
+  })
+  implements Effect.Effect<never, Loading, never> {}
 
-/**
- * @since 1.0.0
- */
-export type LoadingOptions = {
-  readonly timestamp: number // Date.now()
-  readonly progress: Option.Option<Progress.Progress>
+export function loading(progress?: Progress): Loading
+export function loading<A, E = never>(progress?: Progress): AsyncData<A, E>
+export function loading<A, E = never>(progress?: Progress): AsyncData<A, E> {
+  return Loading.make({ progress: Option.fromNullable(progress) })
 }
 
-/**
- * @since 1.0.0
- */
-export type OptionalPartial<A> = [
-  {
-    [K in keyof A]+?: [A[K]] extends [Option.Option<infer R>] ? R | undefined : A[K]
+export class Success<A>
+  extends DataEffect('Success')<{ readonly value: A }, A>
+  implements Effect.Effect<A>
+{
+  constructor(value: A) {
+    super({ value }, Effect.succeed(value))
   }
-] extends [infer R] ? { readonly [K in keyof R]: R[K] } : never
-
-/**
- * @since 1.0.0
- */
-export const loading: {
-  (options?: OptionalPartial<LoadingOptions>): Loading
-  <A, E>(options?: OptionalPartial<LoadingOptions>): AsyncData<A, E>
-} = (options?: OptionalPartial<LoadingOptions>): Loading =>
-  new Loading({
-    [AsyncDataTypeId]: AsyncDataTypeId,
-    timestamp: options?.timestamp ?? getCurrentTimestamp(),
-    progress: Option.fromNullable(options?.progress)
-  } as any)
-
-/**
- * @since 1.0.0
- */
-export interface Failure<out E> extends Effect.Effect<never, E, never> {
-  readonly [AsyncDataTypeId]: AsyncDataTypeId
-
-  /**
-   * @since 1.18.0
-   */
-  readonly _tag: typeof FAILURE_TAG
-
-  /**
-   * @since 1.18.0
-   */
-  readonly cause: Cause.Cause<E>
-
-  /**
-   * @since 1.20.0
-   */
-  readonly timestamp: number // Date.now()
 
-  /**
-   * @since 1.18.0
-   */
-  readonly refreshing: Option.Option<Loading>
+  static schema<A, I, R>(
+    value: Schema.Schema<A, I, R>,
+  ): Schema.SchemaClass<Success<A>, AsyncData.SuccessEncoded<I>, R> {
+    return Schema.Struct({
+      _tag: LiteralWithDefault<'_tag'>()('Success'),
+      value,
+    }).pipe(
+      Schema.transform(Schema.instanceOf(Success<A>), {
+        strict: true,
+        decode: (from) => new Success(from.value),
+        encode: identity,
+      }),
+    )
+  }
+}
 
-  /**
-   * @since 1.18.0
-   */
-  readonly [Unify.typeSymbol]: unknown
+export function success<A>(value: A): Success<A>
+export function success<A, E = never>(value: A): AsyncData<A, E>
+export function success<A>(value: A): Success<A> {
+  return new Success(value)
+}
 
-  /**
-   * @since 1.18.0
-   */
-  readonly [Unify.unifySymbol]: AsyncData.Unify<this>
+export class Failure<E>
+  extends DataEffect('Failure')<{ readonly cause: Cause.Cause<E> }, never, E, never>
+  implements Effect.Effect<never, E, never>
+{
+  constructor(cause: Cause.Cause<E>) {
+    super({ cause }, Effect.failCause(cause))
+  }
 
-  /**
-   * @since 1.18.0
-   */
-  readonly [Unify.ignoreSymbol]: AsyncData.IgnoreList
+  static schema<E, I, R>(
+    error: Schema.Schema<E, I, R>,
+  ): Schema.SchemaClass<Failure<E>, AsyncData.FailureEncoded<I>, R> {
+    return Schema.Struct({
+      _tag: LiteralWithDefault<'_tag'>()('Failure'),
+      cause: Schema.Cause({
+        error,
+        defect: Schema.Unknown,
+      }),
+    }).pipe(
+      Schema.transform(Schema.instanceOf(Failure<E>), {
+        strict: true,
+        decode: (from) => new Failure(from.cause),
+        encode: identity,
+      }),
+    )
+  }
 }
 
-/**
- * @since 1.0.0
- */
-export type FailureOptions = {
-  readonly timestamp: number // Date.now()
-  readonly refreshing: Option.Option<Loading>
+export function failure<E>(cause: Cause.Cause<E>): Failure<E>
+export function failure<E, A = never>(cause: Cause.Cause<E>): AsyncData<A, E>
+export function failure<E>(cause: Cause.Cause<E>): Failure<E> {
+  return new Failure(cause)
 }
 
-/**
- * @since 1.0.0
- */
-export const failCause: {
-  <E>(cause: Cause.Cause<E>, options?: OptionalPartial<FailureOptions>): Failure<E>
-  <A, E>(cause: Cause.Cause<E>, options?: OptionalPartial<FailureOptions>): AsyncData<A, E>
-} = <E>(cause: Cause.Cause<E>, options?: OptionalPartial<FailureOptions>): Failure<E> =>
-  new internal.FailureImpl(
-    cause,
-    options?.timestamp ?? getCurrentTimestamp(),
-    Option.fromNullable(options?.refreshing)
-  ) as any
-
-/**
- * @since 1.0.0
- */
-export const fail: {
-  <E>(error: E, options?: OptionalPartial<FailureOptions>): Failure<E>
-  <A, E>(error: E, options?: OptionalPartial<FailureOptions>): AsyncData<A, E>
-} = <E>(error: E, options?: OptionalPartial<FailureOptions>): Failure<E> => failCause<E>(Cause.fail(error), options)
-
-/**
- * @since 1.0.0
- */
-export interface Success<out A> extends Effect.Effect<never, never, A> {
-  readonly [AsyncDataTypeId]: AsyncDataTypeId
-
-  readonly _tag: typeof SUCCESS_TAG
-  readonly value: A
-  /**
-   * @since 1.20.0
-   */
-  readonly timestamp: number // Date.now()
-  readonly refreshing: Option.Option<Loading>
-
-  readonly [Unify.typeSymbol]: unknown
-  readonly [Unify.unifySymbol]: AsyncData.Unify<this>
-  readonly [Unify.ignoreSymbol]: AsyncData.IgnoreList
+export function die(cause: unknown): Failure<never>
+export function die<A, E = never>(cause: unknown): AsyncData<A, E>
+export function die<E>(cause: unknown): Failure<E> {
+  return new Failure(Cause.die(cause))
 }
 
-/**
- * @since 1.0.0
- */
-export type SuccessOptions = {
-  readonly timestamp: number // Date.now()
-  readonly refreshing: Option.Option<Loading>
+export function fail<E>(error: E): Failure<E> {
+  return new Failure(Cause.fail(error))
 }
 
-/**
- * @since 1.0.0
- */
-export const success: {
-  <A>(value: A, options?: OptionalPartial<SuccessOptions>): Success<A>
-  <A, E>(value: A, options?: OptionalPartial<SuccessOptions>): AsyncData<A, E>
-} = <A>(value: A, options?: OptionalPartial<SuccessOptions>): Success<A> =>
-  new internal.SuccessImpl(
-    value,
-    options?.timestamp ?? getCurrentTimestamp(),
-    Option.fromNullable(options?.refreshing)
-  ) as any
-
-/**
- * @since 1.0.0
- */
-export interface Optimistic<A, E = never> extends Effect.Effect<never, never, A> {
-  readonly [AsyncDataTypeId]: AsyncDataTypeId
-  readonly _tag: "Optimistic"
-  readonly value: A
-  readonly timestamp: number // Date.now()
-  readonly previous: AsyncData<A, E>
-
-  readonly [Unify.typeSymbol]: unknown
-  readonly [Unify.unifySymbol]: AsyncData.Unify<this>
-  readonly [Unify.ignoreSymbol]: AsyncData.IgnoreList
+export class Refreshing<A, E>
+  extends DataEffect('Refreshing')<
+    { readonly previous: Success<A> | Failure<E>; readonly progress: Option.Option<Progress> },
+    A,
+    E,
+    never
+  >
+  implements Effect.Effect<A, E>
+{
+  constructor(previous: Success<A> | Failure<E>, progress: Option.Option<Progress>) {
+    super({ previous, progress }, previous)
+  }
+
+  static schema<A, EI, E, AI, R>(
+    previous: Schema.Schema<
+      Success<A> | Failure<E>,
+      AsyncData.SuccessEncoded<AI> | AsyncData.FailureEncoded<EI>,
+      R
+    >,
+  ): Schema.SchemaClass<Refreshing<A, E>, AsyncData.RefreshingEncoded<AI, EI>, R> {
+    return Schema.Struct({
+      _tag: LiteralWithDefault<'_tag'>()('Refreshing'),
+      previous,
+      progress: Schema.optionalWith(Progress, { as: 'Option', default: undefined }),
+    }).pipe(
+      Schema.transform(Schema.instanceOf(Refreshing<A, E>), {
+        strict: true,
+        decode: (from) => new Refreshing(from.previous, from.progress),
+        encode: identity,
+      }),
+    )
+  }
 }
 
-/**
- * @since 1.0.0
- */
-export interface OptimisticOptions {
-  readonly timestamp: number // Date.now()
+export function refreshing<A = never, E = never>(
+  previous: Success<A> | Failure<E>,
+  progress?: Progress,
+): Refreshing<A, E> {
+  return new Refreshing(previous, Option.fromNullable(progress))
 }
 
-const isAsyncDataFirst = (args: IArguments) => isAsyncData(args[0])
+export class Optimistic<A, E>
+  extends DataEffect('Optimistic')<{ readonly previous: AsyncData<A, E>; readonly value: A }, A>
+  implements Effect.Effect<A>
+{
+  constructor(previous: AsyncData<A, E>, value: A) {
+    super({ previous, value }, Effect.succeed(value))
+  }
 
-/**
- * @since 1.0.0
- */
-export const optimistic: {
-  <A>(value: A, options?: OptionalPartial<OptimisticOptions>): <E>(previous: AsyncData<A, E>) => Optimistic<A, E>
-  <A, E = never>(previous: AsyncData<A, E>, value: A, options?: OptionalPartial<OptimisticOptions>): Optimistic<A, E>
-} = dual(
-  (args) => args.length === 3 || isAsyncDataFirst(args),
-  <A, E>(previous: AsyncData<A, E>, value: A, options?: OptionalPartial<OptimisticOptions>): Optimistic<A, E> =>
-    new internal.OptimisticImpl<A, E>(
+  static schema<A, EI, E, AI, R, R2>(
+    previous: Schema.Schema<AsyncData<A, E>, AsyncData.Encoded<AI, EI>, R>,
+    value: Schema.Schema<A, AI, R2>,
+  ): Schema.SchemaClass<Optimistic<A, E>, AsyncData.OptimisticEncoded<AI, EI>, R | R2> {
+    return Schema.Struct({
+      _tag: LiteralWithDefault<'_tag'>()('Optimistic'),
+      previous,
       value,
-      options?.timestamp ?? getCurrentTimestamp(),
-      // We don't want to nest Optimistic values, so we unwrap the previous value if it's already optimistic
-      previous._tag === "Optimistic" ? previous.previous : previous
-    ) as any
-)
-
-/**
- * @since 1.0.0
- */
-export const isSuccess = <A, E>(data: AsyncData<A, E>): data is Success<A> => data._tag === SUCCESS_TAG
-
-/**
- * @since 1.0.0
- */
-export const isOptimistic = <A, E>(data: AsyncData<A, E>): data is Optimistic<A, E> => data._tag === OPTIMISTIC_TAG
-
-/**
- * @since 1.0.0
- */
-export const isFailure = <A, E>(data: AsyncData<A, E>): data is Failure<E> => data._tag === FAILURE_TAG
-
-/**
- * @since 1.0.0
- */
-export const isLoading = <A, E>(data: AsyncData<A, E>): data is Loading => data._tag === LOADING_TAG
-
-/**
- * @since 1.0.0
- */
-export const isNoData = <A, E>(data: AsyncData<A, E>): data is NoData => data._tag === NO_DATA_TAG
-
-/**
- * @since 1.0.0
- */
-export type Refreshing<A, E> = RefreshingFailure<E> | RefreshingSuccess<A>
-
-/**
- * @since 1.0.0
- */
-export interface RefreshingFailure<E> extends Failure<E> {
-  readonly refreshing: Option.Some<Loading>
+    }).pipe(
+      Schema.transform(Schema.instanceOf(Optimistic<A, E>), {
+        strict: true,
+        decode: (from) => new Optimistic(from.previous, from.value),
+        encode: identity,
+      }),
+    )
+  }
 }
 
-/**
- * @since 1.0.0
- */
-export interface RefreshingSuccess<A> extends Success<A> {
-  readonly refreshing: Option.Some<Loading>
-}
+export const optimistic: {
+  <A>(value: A): <E>(previous: AsyncData<A, E>) => Optimistic<A, E>
+  <A, E>(previous: AsyncData<A, E>, value: A): Optimistic<A, E>
+} = dual(2, function optimistic<A, E>(previous: AsyncData<A, E>, value: A): Optimistic<A, E> {
+  return new Optimistic(previous, value)
+})
 
-/**
- * @since 1.0.0
- */
-export const isRefreshing = <A, E>(data: AsyncData<A, E>): data is Refreshing<A, E> =>
-  isSuccess(data) || isFailure(data)
-    ? Option.isSome(data.refreshing)
-    : isOptimistic(data)
-    ? isRefreshing(data.previous)
-    : false
-
-/**
- * @since 1.0.0
- */
-export const isLoadingOrRefreshing = <A, E>(data: AsyncData<A, E>): data is Loading | Refreshing<A, E> =>
-  isLoading(data) || isRefreshing(data) || (isOptimistic(data) && isLoadingOrRefreshing(data.previous))
-
-/**
- * @since 1.0.0
- */
-export const match: {
-  <A, E, R1, R2, R3, R4, R5>(
+export const matchAll: {
+  <A, E, R1, R2, R3, R4, R5, R6>(
+    data: AsyncData<A, E>,
     matchers: {
-      NoData: (data: NoData) => R1
-      Loading: (data: Loading) => R2
-      Failure: (cause: Cause.Cause<E>, data: Failure<E>) => R3
-      Success: (value: A, data: Success<A>) => R4
-      Optimistic: (value: A, data: Optimistic<A, E>) => R5
-    }
-  ): (data: AsyncData<A, E>) => Unify.Unify<R1 | R2 | R3 | R4 | R5>
-
-  <A, E, R1, R2, R3, R4, R5>(
+      readonly NoData: () => R1
+      readonly Loading: (progress: Option.Option<Progress>) => R2
+      readonly Success: (value: A) => R3
+      readonly Failure: (cause: Cause.Cause<E>) => R4
+      readonly Refreshing: (
+        previous: Success<A> | Failure<E>,
+        progress: Option.Option<Progress>,
+      ) => R5
+      readonly Optimistic: (value: A, previous: AsyncData<A, E>) => R6
+    },
+  ): R1 | R2 | R3 | R4 | R5 | R6
+
+  <A, E, R1, R2, R3, R4, R5, R6>(
     data: AsyncData<A, E>,
     matchers: {
-      NoData: (data: NoData) => R1
-      Loading: (data: Loading) => R2
-      Failure: (cause: Cause.Cause<E>, data: Failure<E>) => R3
-      Success: (value: A, data: Success<A>) => R4
-      Optimistic: (value: A, data: Optimistic<A, E>) => R5
+      readonly NoData: () => R1
+      readonly Loading: (progress: Option.Option<Progress>) => R2
+      readonly Success: (value: A) => R3
+      readonly Failure: (cause: Cause.Cause<E>) => R4
+      readonly Refreshing: (
+        previous: Success<A> | Failure<E>,
+        progress: Option.Option<Progress>,
+      ) => R5
+      readonly Optimistic: (value: A, previous: AsyncData<A, E>) => R6
+    },
+  ): R1 | R2 | R3 | R4 | R5 | R6
+} = dual(
+  2,
+  function matchAll<A, E, R1, R2, R3, R4, R5, R6>(
+    data: AsyncData<A, E>,
+    matchers: {
+      readonly NoData: () => R1
+      readonly Loading: (progress: Option.Option<Progress>) => R2
+      readonly Success: (value: A) => R3
+      readonly Failure: (cause: Cause.Cause<E>) => R4
+      readonly Refreshing: (
+        previous: Success<A> | Failure<E>,
+        progress: Option.Option<Progress>,
+      ) => R5
+      readonly Optimistic: (value: A, previous: AsyncData<A, E>) => R6
+    },
+  ): R1 | R2 | R3 | R4 | R5 | R6 {
+    switch (data._tag) {
+      case 'NoData':
+        return matchers.NoData()
+      case 'Loading':
+        return matchers.Loading(data.progress)
+      case 'Success':
+        return matchers.Success(data.value)
+      case 'Failure':
+        return matchers.Failure(data.cause)
+      case 'Refreshing':
+        return matchers.Refreshing(data.previous, data.progress)
+      case 'Optimistic':
+        return matchers.Optimistic(data.value, data.previous)
     }
-  ): Unify.Unify<R1 | R2 | R3 | R4 | R5>
-} = dual(2, <A, E, R1, R2, R3, R4, R5>(data: AsyncData<A, E>, matchers: {
-  NoData: (data: NoData) => R1
-  Loading: (data: Loading) => R2
-  Failure: (cause: Cause.Cause<E>, data: Failure<E>) => R3
-  Success: (value: A, data: Success<A>) => R4
-  Optimistic: (value: A, data: Optimistic<A, E>) => R5
-}): Unify.Unify<R1 | R2 | R3 | R4> => {
-  if (isSuccess(data)) {
-    return matchers.Success(data.value, data) as Unify.Unify<R1 | R2 | R3 | R4>
-  } else if (isFailure(data)) {
-    return matchers.Failure(data.cause, data) as Unify.Unify<R1 | R2 | R3 | R4>
-  } else if (isLoading(data)) {
-    return matchers.Loading(data) as Unify.Unify<R1 | R2 | R3 | R4>
-  } else if (isNoData(data)) {
-    return matchers.NoData(data) as Unify.Unify<R1 | R2 | R3 | R4>
-  } else {
-    return matchers.Optimistic(data.value, data) as Unify.Unify<R1 | R2 | R3 | R4>
-  }
-})
-
-/**
- * @since 1.0.0
- */
-export const map: {
-  <A, B>(f: (a: A) => B): <E>(data: AsyncData<A, E>) => AsyncData<B, E>
-  <A, E, B>(data: AsyncData<A, E>, f: (a: A) => B): AsyncData<B, E>
-} = dual(2, function map<A, E, B>(data: AsyncData<A, E>, f: (a: A) => B): AsyncData<B, E> {
-  if (isSuccess(data)) {
-    return success(f(data.value), {
-      timestamp: data.timestamp,
-      refreshing: Option.getOrUndefined(data.refreshing)
-    })
-  } else if (isOptimistic(data)) {
-    return optimistic(map(data.previous, f), f(data.value), { timestamp: data.timestamp })
-  } else {
-    return data
-  }
-})
+  },
+)
 
-/**
- * @since 1.0.0
- */
-export const flatMap: {
-  <A, E, B, E2>(
-    f: (a: A, data: Success<A> | Optimistic<A, E>) => AsyncData<B, E2>
-  ): (data: AsyncData<A, E>) => AsyncData<B, E | E2>
-  <A, E, B, E2>(
+export const match: {
+  <A, E, R1, R2, R3, R4>(matchers: {
+    readonly NoData: () => R1
+    readonly Loading: (progress: Option.Option<Progress>) => R2
+    readonly Success: (
+      value: A,
+      params: {
+        readonly isRefreshing: boolean
+        readonly isOptimistic: boolean
+        readonly progress: Option.Option<Progress>
+      },
+    ) => R3
+    readonly Failure: (
+      cause: Cause.Cause<E>,
+      params: { readonly isRefreshing: boolean; readonly progress: Option.Option<Progress> },
+    ) => R4
+  }): (data: AsyncData<A, E>) => Unify.Unify<R1 | R2 | R3 | R4>
+
+  <A, E, R1, R2, R3, R4>(
     data: AsyncData<A, E>,
-    f: (a: A, data: Success<A> | Optimistic<A, E>) => AsyncData<B, E>
-  ): AsyncData<B, E | E2>
+    matchers: {
+      readonly NoData: () => R1
+      readonly Loading: (progress: Option.Option<Progress>) => R2
+      readonly Success: (
+        value: A,
+        params: {
+          readonly isRefreshing: boolean
+          readonly isOptimistic: boolean
+          readonly progress: Option.Option<Progress>
+        },
+      ) => R3
+      readonly Failure: (
+        cause: Cause.Cause<E>,
+        params: { readonly isRefreshing: boolean; readonly progress: Option.Option<Progress> },
+      ) => R4
+    },
+  ): Unify.Unify<R1 | R2 | R3 | R4>
 } = dual(
   2,
-  function<A, E, B, E2>(
+  function match<A, E, R1, R2, R3, R4>(
     data: AsyncData<A, E>,
-    f: (a: A, data: Success<A> | Optimistic<A, E>) => AsyncData<B, E2>
-  ): AsyncData<B, E | E2> {
-    if (isSuccess(data) || isOptimistic(data)) {
-      return f(data.value, data)
-    } else {
+    matchers: {
+      readonly NoData: () => R1
+      readonly Loading: (progress: Option.Option<Progress>) => R2
+      readonly Success: (
+        value: A,
+        params: {
+          readonly isRefreshing: boolean
+          readonly isOptimistic: boolean
+          readonly progress: Option.Option<Progress>
+        },
+      ) => R3
+      readonly Failure: (
+        cause: Cause.Cause<E>,
+        params: { readonly isRefreshing: boolean; readonly progress: Option.Option<Progress> },
+      ) => R4
+    },
+  ): Unify.Unify<R1 | R2 | R3 | R4> {
+    const match_ = (
+      data: AsyncData<A, E>,
+      params: {
+        readonly isRefreshing: boolean
+        readonly isOptimistic: boolean
+        readonly progress: Option.Option<Progress>
+      },
+    ): R1 | R2 | R3 | R4 =>
+      matchAll(data, {
+        NoData: matchers.NoData,
+        Loading: matchers.Loading,
+        Success: (value) => matchers.Success(value, params),
+        Failure: (cause) => matchers.Failure(cause, params),
+        Refreshing: (previous, progress) =>
+          match_(previous, { ...params, isRefreshing: true, progress }),
+        Optimistic: (value) => matchers.Success(value, { ...params, isOptimistic: true }),
+      })
+
+    return Unify.unify(
+      match_(data, {
+        isRefreshing: false,
+        isOptimistic: false,
+        progress: Option.none(),
+      }),
+    )
+  },
+)
+
+export function startLoading<A, E>(data: AsyncData<A, E>, progress?: Progress): AsyncData<A, E> {
+  switch (data._tag) {
+    case 'Success':
+    case 'Failure':
+      return refreshing(data, progress)
+    case 'NoData':
+      return loading(progress)
+    case 'Optimistic':
+      return optimistic(startLoading(data.previous, progress), data.value)
+    default:
       return data
-    }
   }
-)
+}
 
-/**
- * @since 1.0.0
- */
-export const startLoading = <A, E>(
-  data: AsyncData<A, E>,
-  options?: OptionalPartial<LoadingOptions>
-): AsyncData<A, E> => {
-  if (isSuccess(data)) {
-    return Option.isSome(data.refreshing) ? data : success(data.value, { ...data, refreshing: loading(options) })
-  } else if (isFailure(data)) {
-    return Option.isSome(data.refreshing)
-      ? data
-      : failCause(data.cause, { ...data, refreshing: loading(options) })
-  } else if (isOptimistic(data)) {
-    return optimistic(startLoading(data.previous, options), data.value, data)
-  } else {
-    return loading(options)
+export function stopLoading<A, E>(data: AsyncData<A, E>): AsyncData<A, E> {
+  switch (data._tag) {
+    case 'Refreshing':
+      return data.previous
+    case 'Loading':
+      return noData()
+    case 'Optimistic':
+      return optimistic(stopLoading(data.previous), data.value)
+    default:
+      return data
   }
 }
 
-/**
- * @since 1.0.0
- */
-export const stopLoading = <A, E>(data: AsyncData<A, E>): AsyncData<A, E> => {
-  if (isSuccess(data)) {
-    return Option.isSome(data.refreshing) ? success(data.value, { timestamp: data.timestamp }) : data
-  } else if (isFailure(data)) {
-    return Option.isSome(data.refreshing) ? failCause(data.cause, { timestamp: data.timestamp }) : data
-  } else if (isOptimistic(data)) {
-    return optimistic(stopLoading(data.previous), data.value, data)
-  } else {
-    return noData()
+export function updateProgress<A, E>(data: AsyncData<A, E>, progress: Progress): AsyncData<A, E> {
+  switch (data._tag) {
+    case 'Refreshing':
+      return refreshing(data.previous, progress)
+    case 'Loading':
+      return loading(progress)
+    case 'Optimistic':
+      return optimistic(updateProgress(data.previous, progress), data.value)
+    default:
+      return data
   }
 }
 
-/**
- * @since 1.0.0
- */
-export const isAsyncData: <A, E>(u: unknown) => u is AsyncData<A, E> = internal.isAsyncData
-
-/**
- * @since 1.0.0
- */
-export const done = <A, E = never>(exit: Exit.Exit<A, E>): AsyncData<A, E> =>
-  Exit.match(exit, {
-    onFailure: (cause) => failCause(cause),
-    onSuccess: (value) => success(value)
-  })
+export interface AsyncDataSchemaClass<E, EI, ER, A, AI, AR>
+  extends Schema.SchemaClass<AsyncData<A, E>, AsyncData.Encoded<AI, EI>, AR | ER> {
+  readonly eq: Equivalence.Equivalence<AsyncData<A, E>>
+
+  readonly success: (value: A) => AsyncData<A, E>
+  readonly failCause: (cause: Cause.Cause<E>) => AsyncData<A, E>
+  readonly fail: (error: E) => AsyncData<A, E>
+  readonly die: (cause: unknown) => AsyncData<A, E>
+  readonly optimistic: (previous: AsyncData<A, E>, value: A) => AsyncData<A, E>
+  readonly refreshing: (previous: Success<A> | Failure<E>, progress?: Progress) => AsyncData<A, E>
+  readonly loading: (progress?: Progress) => AsyncData<A, E>
+  readonly noData: () => AsyncData<A, E>
+}
 
-/**
- * @since 1.0.0
- */
-export const getFailure = <A, E>(data: AsyncData<A, E>): Option.Option<E> =>
-  isFailure(data) ? Cause.failureOption(data.cause) : Option.none()
+export function AsyncData<A, AI, AR, E, EI, ER>(
+  schemas: {
+    readonly success: Schema.Schema<A, AI, AR>
+    readonly failure: Schema.Schema<E, EI, ER>
+  },
+  annotations?: Schema.Annotations.Schema<AsyncData<A, E>>,
+): AsyncDataSchemaClass<E, EI, ER, A, AI, AR> {
+  const identifier = Option.all({
+    E: getIdentifier(schemas.failure.ast),
+    A: getIdentifier(schemas.success.ast),
+  }).pipe(
+    Option.match({
+      onNone: () => 'AsyncData',
+      onSome: ({ E, A }) => `AsyncData<${E}, ${A}>`,
+    }),
+  )
+
+  const equivalence = makeEquivalence(
+    Schema.equivalence(schemas.success),
+    Schema.equivalence(schemas.failure),
+  )
+
+  const recursive: Schema.Schema<
+    AsyncData<A, E>,
+    AsyncData.Encoded<AI, EI>,
+    AR | ER
+  > = Schema.suspend(() => AsyncData).annotations({
+    identifier,
+    equivalence: () => equivalence,
+    ...annotations,
+  })
 
-/**
- * @since 1.0.0
- */
-export const getSuccess = <A, E>(data: AsyncData<A, E>): Option.Option<A> =>
-  isSuccess(data) || isOptimistic(data) ? Option.some(data.value) : Option.none()
+  const successAndFailure = Schema.Union(
+    Success.schema(schemas.success),
+    Failure.schema(schemas.failure),
+  )
+
+  const AsyncData = Schema.Union(
+    NoData,
+    Loading,
+    successAndFailure,
+    Refreshing.schema(successAndFailure),
+    Optimistic.schema(recursive, schemas.success),
+  ).annotations({
+    equivalence: () => equivalence,
+  })
 
-const optionProgressEq = Option.getEquivalence(Progress.equals)
+  return class extends AsyncData {
+    static readonly eq = equivalence
+    static readonly success = success
+    static readonly failCause = failure
+    static readonly fail = fail
+    static readonly die = die
+    static readonly optimistic = optimistic
+    static readonly refreshing = refreshing
+    static readonly loading = loading
+    static readonly noData = noData
+  }
+}
 
-const loadingEquivalence: Equivalence.Equivalence<Loading> = Equivalence.struct({
-  _tag: Equivalence.string,
-  timestamp: Equivalence.number,
-  progress: optionProgressEq
-})
+function getIdentifier(ast: SchemaAST.AST) {
+  return SchemaAST.getJSONIdentifier(ast).pipe(
+    Option.orElse(() => SchemaAST.getTitleAnnotation(ast)),
+  )
+}
 
-const optionLoadingEq = Option.getEquivalence(loadingEquivalence)
+export function fromExit<A, E>(exit: Exit.Exit<A, E>): AsyncData<A, E> {
+  return Exit.match(exit, { onSuccess: success<A>, onFailure: failure<E> })
+}
 
-const failureEquivalence: Equivalence.Equivalence<Failure<any>> = Equivalence.struct({
-  _tag: Equivalence.string,
-  cause: Equal.equals,
-  timestamp: Equivalence.number,
-  refreshing: optionLoadingEq
-})
+export function fromEither<A, E>(either: Either.Either<A, E>): AsyncData<A, E> {
+  return Either.match(either, { onLeft: fail<E>, onRight: success<A> })
+}
 
-const successEquivalence = <A>(valueEq: Equivalence.Equivalence<A>): Equivalence.Equivalence<Success<A>> =>
-  Equivalence.struct({
-    _tag: Equivalence.string,
-    value: valueEq,
-    timestamp: Equivalence.number,
-    refreshing: optionLoadingEq
-  })
+export function fromOption<A>(option: Option.Option<A>): AsyncData<A> {
+  return Option.match(option, { onSome: success<A>, onNone: noData<A> })
+}
 
-const optimisticEquivalence = <A, E>(
-  valueEq: Equivalence.Equivalence<A>
-): Equivalence.Equivalence<Optimistic<A, E>> => {
-  let previousEq: Equivalence.Equivalence<AsyncData<A, E>> | undefined
-  const get = () => {
-    if (previousEq === undefined) {
-      previousEq = getEquivalence(valueEq)
+export const map: {
+  <A, B>(f: (a: A) => B): <E>(data: AsyncData<A, E>) => AsyncData<B, E>
+  <A, E, B>(data: AsyncData<A, E>, f: (a: A) => B): AsyncData<B, E>
+} = dual(2, function map<A, E, B>(data: AsyncData<A, E>, f: (a: A) => B): AsyncData<B, E> {
+  if (data._tag === 'Success') {
+    return new Success(f(data.value))
+  } else if (data._tag === 'Refreshing' && data.previous._tag === 'Success') {
+    return new Refreshing(new Success(f(data.previous.value)), data.progress)
+  } else if (data._tag === 'Optimistic') {
+    if (data.previous._tag === 'Success') {
+      return new Optimistic(new Success(f(data.previous.value)), f(data.value))
+    } else if (data.previous._tag === 'Failure') {
+      return new Optimistic(data.previous, f(data.value))
     }
-    return previousEq
   }
 
-  return Equivalence.struct({
-    _tag: Equivalence.string,
-    value: valueEq,
-    timestamp: Equivalence.number,
-    previous: (a: AsyncData<A, E>, b: AsyncData<A, E>) => get()(a, b)
-  })
-}
-
-/**
- * @since 1.0.0
- */
-export const getEquivalence = <A, E>(
-  valueEq: Equivalence.Equivalence<A> = Equal.equals
-): Equivalence.Equivalence<AsyncData<A, E>> => {
-  const successEq_ = successEquivalence(valueEq)
-  const optimisticEq_ = optimisticEquivalence(valueEq)
-  return (a, b) => {
-    if (a === b) return true
+  return data as AsyncData<B, E>
+})
 
-    return match(a, {
-      NoData: () => isNoData(b),
-      Loading: (l1) => isLoading(b) ? loadingEquivalence(l1, b) : false,
-      Failure: (_, f1) => isFailure(b) ? failureEquivalence(f1, b) : false,
-      Success: (_, s1) => isSuccess(b) ? successEq_(s1, b) : false,
-      Optimistic: (_, o1) => isOptimistic(b) ? optimisticEq_(o1, b) : false
-    })
+export const flatMap: {
+  <A, B, E2>(f: (a: A) => AsyncData<B, E2>): <E>(data: AsyncData<A, E>) => AsyncData<B, E | E2>
+  <A, E, B, E2>(data: AsyncData<A, E>, f: (a: A) => AsyncData<B, E2>): AsyncData<B, E | E2>
+} = dual(2, function flatMap<
+  A,
+  E,
+  B,
+  E2,
+>(data: AsyncData<A, E>, f: (a: A) => AsyncData<B, E2>): AsyncData<B, E | E2> {
+  if (data._tag === 'Success' || data._tag === 'Optimistic') {
+    return f(data.value)
+  } else if (data._tag === 'Refreshing' && data.previous._tag === 'Success') {
+    return f(data.previous.value)
   }
-}
 
-/**
- * @since 1.0.0
- */
-export function fromExit<A, E>(exit: Exit.Exit<A, E>): Success<A> | Failure<E> {
-  return Exit.match(exit, {
-    onFailure: (cause) => failCause(cause),
-    onSuccess: (value) => success(value)
-  })
+  return data as AsyncData<B, E>
+})
+
+export function isNoData<A, E>(data: AsyncData<A, E>): data is NoData {
+  return data._tag === 'NoData'
 }
 
-/**
- * @since 1.0.0
- */
-export function fromEither<A, E = never>(either: Either.Either<A, E>): Success<A> | Failure<E> {
-  return Either.match(either, {
-    onLeft: (e) => fail(e),
-    onRight: (a) => success(a)
-  })
+export function isLoading<A, E>(data: AsyncData<A, E>): data is Loading {
+  return data._tag === 'Loading'
 }
 
-/**
- * @since 1.0.0
- */
-export const isExpired: {
-  (ttl: Duration.DurationInput, now?: number): <A, E>(data: AsyncData<A, E>) => boolean
-  <A, E>(data: AsyncData<A, E>, ttl: Duration.DurationInput, now?: number): boolean
-} = dual(isAsyncDataFirst, function isExpired<A, E>(
-  data: AsyncData<A, E>,
-  ttl: Duration.DurationInput,
-  now: number = getCurrentTimestamp()
-): boolean {
-  return match(data, {
-    NoData: () => true,
-    Loading: ({ timestamp }) => isPastTTL(timestamp, ttl, now),
-    Failure: (_, f) =>
-      Option.isNone(f.refreshing)
-        ? isPastTTL(f.timestamp, ttl, now)
-        : isPastTTL(f.refreshing.value.timestamp, ttl, now),
-    Success: (_, s) =>
-      Option.isNone(s.refreshing)
-        ? isPastTTL(s.timestamp, ttl, now) :
-        isPastTTL(s.refreshing.value.timestamp, ttl, now),
-    Optimistic: (_, o) =>
-      isPastTTL(o.timestamp, ttl, now) || (o.previous._tag === NO_DATA_TAG ? false : isExpired(o.previous, ttl, now))
-  })
-})
+export function isSuccess<A, E>(data: AsyncData<A, E>): data is Success<A> {
+  return data._tag === 'Success'
+}
 
-function isPastTTL(timestamp: number, ttl: Duration.DurationInput, now: number): boolean {
-  const millis = Duration.toMillis(ttl)
+export function isFailure<A, E>(data: AsyncData<A, E>): data is Failure<E> {
+  return data._tag === 'Failure'
+}
 
-  return now - timestamp >= millis
+export function isRefreshing<A, E>(data: AsyncData<A, E>): data is Refreshing<A, E> {
+  return data._tag === 'Refreshing'
 }
 
-const optionDataEqual = Option.getEquivalence(dataEqual)
-
-/**
- * Checks if two AsyncData are equal, disregarding the timestamps associated with them. Useful for testing
- * without needing to manage timestamps.
- *
- * @since 1.0.0
- */
-export function dataEqual<A, E>(first: AsyncData<A, E>, second: AsyncData<A, E>): boolean {
-  return match(first, {
-    NoData: () => isNoData(second),
-    Loading: (l) => isLoading(second) && Equal.equals(l.progress, second.progress),
-    Failure: (_, f1) =>
-      isFailure(second) && Equal.equals(f1.cause, second.cause) && optionDataEqual(f1.refreshing, second.refreshing),
-    Success: (_, s1) =>
-      isSuccess(second) && Equal.equals(s1.value, second.value) && optionDataEqual(s1.refreshing, second.refreshing),
-    Optimistic: (_, o1) =>
-      isOptimistic(second) && Equal.equals(o1.value, second.value) && dataEqual(o1.previous, second.previous)
-  })
+export function isLoadingOrRefreshing<A, E>(
+  data: AsyncData<A, E>,
+): data is Loading | Refreshing<A, E> {
+  return isLoading(data) || isRefreshing(data)
 }
 
-/**
- * @since 1.0.0
- */
-export function toOption<A, E>(data: AsyncData<A, E>): Option.Option<A> {
-  return match(data, {
-    NoData: Option.none,
-    Loading: Option.none,
-    Failure: Option.none,
-    Success: Option.some,
-    Optimistic: Option.some
-  })
+export function isOptimistic<A, E>(data: AsyncData<A, E>): data is Optimistic<A, E> {
+  return data._tag === 'Optimistic'
 }
 
-/**
- * @since 1.0.0
- */
-export function toOptionCause<A, E>(data: AsyncData<A, E>): Option.Option<Cause.Cause<E>> {
-  return match(data, {
-    NoData: Option.none,
-    Loading: Option.none,
-    Failure: Option.some,
-    Success: Option.none,
-    Optimistic: Option.none
+export function makeEquivalence<A, E>(
+  eqA: Equivalence.Equivalence<A>,
+  eqB: Equivalence.Equivalence<E>,
+): Equivalence.Equivalence<AsyncData<A, E>> {
+  const eqCause = Equivalence.make((a: Cause.Cause<E>, b: Cause.Cause<E>) => {
+    const failuresA = Array.from(Cause.failures(a))
+    const failuresB = Array.from(Cause.failures(b))
+    if (failuresA.length > 0) {
+      return (
+        failuresA.length === failuresB.length && failuresA.every((e, i) => eqB(e, failuresB[i]))
+      )
+    }
+
+    return Equal.equals(a, b)
   })
+
+  const eq: Equivalence.Equivalence<AsyncData<A, E>> = Equivalence.make((a, b) =>
+    matchAll(a, {
+      NoData: () => isNoData(b),
+      Loading: (progress) => isLoading(b) && Equal.equals(progress, b.progress),
+      Success: (value) => isSuccess(b) && eqA(value, b.value),
+      Failure: (cause) => isFailure(b) && eqCause(cause, b.cause),
+      Refreshing: (previous, progress) =>
+        isRefreshing(b) && eq(previous, b.previous) && Equal.equals(progress, b.progress),
+      Optimistic: (value, previous) =>
+        isOptimistic(b) && eqA(value, b.value) && eq(previous, b.previous),
+    }),
+  )
+
+  return eq
 }
 
-/**
- * @since 1.0.0
- */
-export function toOptionError<A, E>(data: AsyncData<A, E>): Option.Option<E> {
-  return match(data, {
-    NoData: Option.none,
-    Loading: Option.none,
-    Failure: Cause.failureOption,
-    Success: Option.none,
-    Optimistic: Option.none
-  })
+type EqValue<T> = T extends Equivalence.Equivalence<infer A> ? A : never
+
+function unionEquivalence<EQS extends ReadonlyArray<Equivalence.Equivalence<any>>>(
+  eqs: EQS,
+): Equivalence.Equivalence<EqValue<EQS[number]>> {
+  return (a, b) => {
+    for (const eq of eqs) {
+      if (eq(a, b)) {
+        return true
+      }
+    }
+
+    return false
+  }
 }
+
+export const equals = makeEquivalence(Equal.equals, Equal.equals)