@typed/async-data 0.2.0 → 0.3.1

package/src/Schema.ts

@@ -4,136 +4,433 @@
 
 import * as Arbitrary from "@effect/schema/Arbitrary"
 import * as AST from "@effect/schema/AST"
+import * as Eq from "@effect/schema/Equivalence"
 import * as ParseResult from "@effect/schema/ParseResult"
 import * as Pretty from "@effect/schema/Pretty"
 import * as Schema from "@effect/schema/Schema"
 import * as AsyncData from "@typed/async-data/AsyncData"
-import { Cause, Chunk, Effect, FiberId, HashSet } from "effect"
+import { Equal } from "effect"
+import type * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
+import * as P from "./Progress.js"
 
-const fiberIdArbitrary: Arbitrary.Arbitrary<FiberId.FiberId> = (fc) =>
-  fc.oneof(
-    fc.constant(FiberId.none),
-    fc.integer().chain((i) => fc.date().map((date) => FiberId.make(i, date.getTime() / 1000)))
+const NO_DATA_PRETTY = "AsyncData.NoData"
+const LOADING_PRETTY = (loading: AsyncData.Loading) =>
+  Option.match(loading.progress, {
+    onNone: () => `AsyncData.Loading(timestamp=${loading.timestamp})`,
+    onSome: (progress) => `AsyncData.Loading(timestamp=${loading.timestamp}, progress=${P.pretty(progress)})`
+  })
+const FAILURE_PRETTY = <E>(print: Pretty.Pretty<Cause.Cause<E>>) => (failure: AsyncData.Failure<E>) =>
+  Option.match(failure.refreshing, {
+    onNone: () => `AsyncData.Failure(timestamp=${failure.timestamp}, cause=${print(failure.cause)})`,
+    onSome: (loading) =>
+      `AsyncData.Failure(timestamp=${failure.timestamp}, refreshing=${LOADING_PRETTY(loading)}, cause=${
+        print(failure.cause)
+      })`
+  })
+const SUCCESS_PRETTY = <A>(print: Pretty.Pretty<A>) => (success: AsyncData.Success<A>) =>
+  Option.match(success.refreshing, {
+    onNone: () => `AsyncData.Success(timestamp=${success.timestamp}, value=${print(success.value)})`,
+    onSome: (loading) =>
+      `AsyncData.Success(timestamp=${success.timestamp}, refreshing=${LOADING_PRETTY(loading)}, value=${
+        print(success.value)
+      })`
+  })
+
+const NoDataSchemaJson = Schema.struct({
+  _tag: Schema.literal("NoData")
+})
+const NoDataSchema = Schema.instanceOf(AsyncData.NoData)
+
+/**
+ * @since 1.0.0
+ */
+export const NoData: Schema.Schema<{ readonly _tag: "NoData" }, AsyncData.NoData> = NoDataSchemaJson
+  .pipe(
+    Schema.transform(
+      NoDataSchema,
+      (): AsyncData.NoData => AsyncData.noData(),
+      (): Schema.Schema.To<typeof NoDataSchemaJson> => ({
+        _tag: "NoData"
+      })
+    ),
+    Schema.annotations({
+      [AST.IdentifierAnnotationId]: NO_DATA_PRETTY,
+      [Pretty.PrettyHookId]: () => NO_DATA_PRETTY,
+      [Arbitrary.ArbitraryHookId]: (): Arbitrary.Arbitrary<AsyncData.NoData> => (fc) => fc.constant(AsyncData.noData()),
+      [Eq.EquivalenceHookId]: () => Equal.equals
+    })
   )
 
-const causeFromItems = <A>(
-  items: Array<A>,
-  join: (first: Cause.Cause<A>, second: Cause.Cause<A>) => Cause.Cause<A>
-) => {
-  if (items.length === 0) return Cause.empty
-  if (items.length === 1) return Cause.fail(items[0])
-  return items.map(Cause.fail).reduce(join)
-}
+/**
+ * @since 1.0.0
+ */
+export type NoDataFrom = Schema.Schema.From<typeof NoData>
 
-const causeArbitrary = <A>(item: Arbitrary.Arbitrary<A>): Arbitrary.Arbitrary<Cause.Cause<A>> => (fc) =>
-  fc.oneof(
-    fc.constant(Cause.empty),
-    fc.anything().map(Cause.die),
-    fiberIdArbitrary(fc).map((id) => Cause.interrupt(id)),
-    fc.array(item(fc)).chain((items) =>
-      fc.integer({ min: 0, max: 1 }).map((i) => causeFromItems(items, i > 0.5 ? Cause.sequential : Cause.parallel))
-    )
+const ProgressSchemaJson = Schema.struct({
+  loaded: Schema.bigint,
+  total: Schema.optional(Schema.bigint)
+})
+type ProgressFromTo = Schema.Schema.To<typeof ProgressSchemaJson>
+
+const ProgressSchema: Schema.Schema<
+  {
+    readonly loaded: bigint
+    readonly total: Option.Option<bigint>
+  },
+  P.Progress
+> = Schema.data(Schema.struct({
+  loaded: Schema.bigintFromSelf,
+  total: Schema.optionFromSelf(Schema.bigintFromSelf)
+}))
+
+const progressArbitrary: Arbitrary.Arbitrary<P.Progress> = (fc) =>
+  fc.bigInt().chain((loaded) => fc.option(fc.bigInt({ min: loaded })).map((total) => P.make(loaded, total)))
+
+/**
+ * @since 1.0.0
+ */
+export const Progress: Schema.Schema<{ readonly loaded: string; readonly total?: string | undefined }, P.Progress> =
+  ProgressSchemaJson.pipe(
+    Schema.transform(
+      ProgressSchema,
+      (json): P.Progress => P.make(json.loaded, json.total),
+      (progress) => ({
+        loaded: progress.loaded,
+        total: Option.getOrUndefined(progress.total)
+      })
+    ),
+    Schema.annotations({
+      [AST.IdentifierAnnotationId]: "Progress",
+      [Pretty.PrettyHookId]: () => "Progress",
+      [Arbitrary.ArbitraryHookId]: (): Arbitrary.Arbitrary<P.Progress> => progressArbitrary,
+      [Eq.EquivalenceHookId]: () => Equal.equals
+    })
+  )
+
+/**
+ * @since 1.0.0
+ */
+export type ProgressFrom = Schema.Schema.From<typeof Progress>
+
+const LoadingSchemaJson = Schema.struct({
+  _tag: Schema.literal("Loading"),
+  timestamp: Schema.number,
+  progress: Schema.optional(ProgressSchemaJson)
+})
+const LoadingSchema = Schema.instanceOf(AsyncData.Loading)
+
+const loadingFromJson = (json: Schema.Schema.To<typeof LoadingSchemaJson>): AsyncData.Loading =>
+  AsyncData.loading({ timestamp: json.timestamp, progress: progressFromJson(json.progress) })
+
+const loadingToJson = (loading: AsyncData.Loading): Schema.Schema.To<typeof LoadingSchemaJson> => ({
+  _tag: "Loading",
+  timestamp: loading.timestamp,
+  progress: progressToJson(loading.progress)
+})
+
+const loadingArbitrary: Arbitrary.Arbitrary<AsyncData.Loading> = (fc) =>
+  fc.option(progressArbitrary(fc)).map((progress) =>
+    AsyncData.loading({
+      timestamp: Date.now(),
+      progress: progress || undefined
+    })
   )
 
-const causePretty = <A>(): Pretty.Pretty<Cause.Cause<A>> => Cause.pretty
+/**
+ * @since 1.0.0
+ */
+export const Loading: Schema.Schema<
+  {
+    readonly _tag: "Loading"
+    readonly timestamp: number
+    readonly progress?: ProgressFrom | undefined
+  },
+  AsyncData.Loading
+> = LoadingSchemaJson
+  .pipe(
+    Schema.transform(
+      LoadingSchema,
+      loadingFromJson,
+      loadingToJson
+    ),
+    Schema.annotations({
+      [AST.IdentifierAnnotationId]: "AsyncData.Loading",
+      [Pretty.PrettyHookId]: () => LOADING_PRETTY,
+      [Arbitrary.ArbitraryHookId]: () => loadingArbitrary,
+      [Eq.EquivalenceHookId]: () => Equal.equals
+    })
+  )
 
 /**
  * @since 1.0.0
  */
-export const cause = <EI, E>(error: Schema.Schema<EI, E>): Schema.Schema<Cause.Cause<EI>, Cause.Cause<E>> => {
-  const parseE = Schema.parse(Schema.chunkFromSelf(error))
-
-  const self: Schema.Schema<Cause.Cause<EI>, Cause.Cause<E>> = Schema.suspend(() =>
-    Schema.declare(
-      [error],
-      Schema.struct({}),
-      () => (input, options) =>
-        Effect.gen(function*(_) {
-          if (!Cause.isCause(input)) return yield* _(ParseResult.fail(ParseResult.unexpected(input)))
-
-          let output: Cause.Cause<E> = Cause.empty
-          for (const cause of Cause.linearize<E>(input)) {
-            const parrallelCauses = Cause.linearize(cause)
-
-            if (HashSet.size(parrallelCauses) === 1) {
-              const failures = Cause.failures(cause)
-
-              output = Cause.parallel(
-                output,
-                Chunk.isEmpty(failures) ? cause : Chunk.reduce(
-                  yield* _(parseE(failures, options)),
-                  Cause.empty as Cause.Cause<E>,
-                  (cause, e) => Cause.sequential(cause, Cause.fail(e))
-                )
-              )
-            } else {
-              output = Cause.parallel(
-                output,
-                yield* _(Schema.parse(self)(cause, options))
-              )
+export type LoadingFrom = Schema.Schema.From<typeof Loading>
+
+const FailureSchemaJson = <EI, E>(cause: Schema.Schema<Schema.CauseFrom<EI>, Cause.Cause<E>>) =>
+  Schema.struct({
+    _tag: Schema.literal("Failure"),
+    cause,
+    timestamp: Schema.number,
+    refreshing: Schema.optional(LoadingSchemaJson)
+  })
+
+const FailureSchema = <EI, E>(
+  error: Schema.Schema<EI, E>
+): Schema.Schema<AsyncData.Failure<EI>, AsyncData.Failure<E>> =>
+  Schema.declare(
+    [Schema.cause(error)],
+    Schema.struct({}),
+    (isDecoding, causeSchema) => {
+      const parseCause = isDecoding ? Schema.parse(causeSchema) : Schema.encode(causeSchema)
+
+      return (input, options) => {
+        return Effect.gen(function*(_) {
+          if (!AsyncData.isAsyncData(input)) return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
+
+          switch (input._tag) {
+            case "Failure": {
+              const cause = yield* _(parseCause(input.cause, options))
+
+              return AsyncData.failCause(cause, {
+                timestamp: input.timestamp,
+                refreshing: Option.getOrUndefined(input.refreshing)
+              })
             }
+            default:
+              return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
           }
-
-          return output
-        }),
-      {
-        [AST.IdentifierAnnotationId]: "Cause",
-        [Arbitrary.ArbitraryHookId]: causePretty,
-        [Pretty.PrettyHookId]: causeArbitrary
+        })
       }
+    }
+  )
+
+const failureArbitrary = <E>(
+  cause: Arbitrary.Arbitrary<Cause.Cause<E>>
+): Arbitrary.Arbitrary<AsyncData.Failure<E>> =>
+(fc) =>
+  fc.option(loadingArbitrary(fc)).chain((refreshing) =>
+    cause(fc).chain((cause) =>
+      fc.date().map((date) =>
+        AsyncData.failCause(cause, {
+          timestamp: date.getTime(),
+          refreshing: refreshing || undefined
+        })
+      )
     )
   )
 
-  return self
-}
+/**
+ * @since 1.0.0
+ */
+export const Failure = <EI, E>(
+  error: Schema.Schema<EI, E>
+): Schema.Schema<
+  {
+    readonly _tag: "Failure"
+    readonly cause: Schema.CauseFrom<EI>
+    readonly timestamp: number
+    readonly refreshing?: {
+      readonly _tag: "Loading"
+      readonly timestamp: number
+      readonly progress?: { readonly loaded: string; readonly total?: string | undefined } | undefined
+    } | undefined
+  },
+  AsyncData.Failure<E>
+> =>
+  FailureSchemaJson(Schema.cause(Schema.from(error)))
+    .pipe(
+      Schema.transform(
+        FailureSchema(error),
+        (json): AsyncData.Failure<EI> =>
+          AsyncData.failCause(json.cause, {
+            timestamp: json.timestamp,
+            refreshing: json.refreshing ? loadingFromJson(json.refreshing) : undefined
+          }),
+        (failure) => ({
+          _tag: "Failure",
+          cause: failure.cause,
+          timestamp: failure.timestamp,
+          refreshing: Option.getOrUndefined(Option.map(failure.refreshing, loadingToJson))
+        } as const)
+      ),
+      Schema.annotations({
+        [AST.IdentifierAnnotationId]: "AsyncData.Failure",
+        [Pretty.PrettyHookId]: FAILURE_PRETTY,
+        [Arbitrary.ArbitraryHookId]: failureArbitrary,
+        [Eq.EquivalenceHookId]: () => Equal.equals
+      })
+    )
+
+/**
+ * @since 1.0.0
+ */
+export type FailureFrom<E> = Schema.Schema.From<ReturnType<typeof FailureSchemaJson<E, E>>>
 
-const asyncDataPretty = <E, A>(
-  prettyCause: Pretty.Pretty<Cause.Cause<E>>,
-  prettyValue: Pretty.Pretty<A>
-): Pretty.Pretty<AsyncData.AsyncData<E, A>> =>
-  AsyncData.match({
-    NoData: () => `AsyncData.NoData`,
-    Loading: () => `AsyncData.Loading`,
-    Failure: (cause, data) =>
-      `AsyncData.Failure(refreshing=${Option.isSome(data.refreshing)}, cause=${prettyCause(cause)})`,
-    Success: (value, data) =>
-      `AsyncData.Success(refreshing=${Option.isSome(data.refreshing)}, value=${prettyValue(value)})`
+const SuccessSchemaJson = <AI, A>(
+  value: Schema.Schema<AI, A>
+): Schema.Schema<
+  {
+    readonly timestamp: number
+    readonly _tag: "Success"
+    readonly value: AI
+    readonly refreshing?: {
+      readonly timestamp: number
+      readonly _tag: "Loading"
+      readonly progress?: { readonly loaded: string; readonly total?: string | undefined } | undefined
+    } | undefined
+  },
+  {
+    readonly timestamp: number
+    readonly _tag: "Success"
+    readonly value: A
+    readonly refreshing?: {
+      readonly timestamp: number
+      readonly _tag: "Loading"
+      readonly progress?: { readonly loaded: bigint; readonly total?: bigint | undefined } | undefined
+    } | undefined
+  }
+> =>
+  Schema.struct({
+    _tag: Schema.literal("Success"),
+    value,
+    timestamp: Schema.number,
+    refreshing: Schema.optional(LoadingSchemaJson)
   })
 
-const asyncDataArbitrary = <E, A>(
-  causeArbitrary: Arbitrary.Arbitrary<Cause.Cause<E>>,
-  valueArbitrary: Arbitrary.Arbitrary<A>
-): Arbitrary.Arbitrary<AsyncData.AsyncData<E, A>> =>
+const SuccessSchema = <AI, A>(
+  value: Schema.Schema<AI, A>
+): Schema.Schema<AsyncData.Success<AI>, AsyncData.Success<A>> =>
+  Schema.declare(
+    [value],
+    Schema.struct({
+      _tag: Schema.literal("Success"),
+      timestamp: Schema.number
+    }),
+    (isDecoding, valueSchema) => {
+      const parseValue = isDecoding ? Schema.parse(valueSchema) : Schema.encode(valueSchema)
+
+      return (input, options) => {
+        return Effect.gen(function*(_) {
+          if (!AsyncData.isAsyncData(input)) return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
+
+          switch (input._tag) {
+            case "Success": {
+              const value = yield* _(parseValue(input.value, options))
+
+              return AsyncData.success(value, {
+                timestamp: input.timestamp,
+                refreshing: Option.getOrUndefined(input.refreshing)
+              })
+            }
+            default:
+              return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
+          }
+        })
+      }
+    }
+  )
+
+const successArbitrary = <A>(
+  value: Arbitrary.Arbitrary<A>
+): Arbitrary.Arbitrary<AsyncData.Success<A>> =>
 (fc) =>
-  fc.oneof(
-    fc.constant(AsyncData.noData()),
-    fc.constant(AsyncData.loading()),
-    causeArbitrary(fc).map((cause) => AsyncData.failCause(cause)),
-    valueArbitrary(fc).map((a) => AsyncData.success(a))
+  fc.option(loadingArbitrary(fc)).chain((refreshing) =>
+    value(fc).chain((a) =>
+      fc.date().map((date) =>
+        AsyncData.success(a, {
+          timestamp: date.getTime(),
+          refreshing: refreshing || undefined
+        })
+      )
+    )
   )
 
+/**
+ * @since 1.0.0
+ */
+export const Success = <AI, A>(
+  value: Schema.Schema<AI, A>
+): Schema.Schema<
+  {
+    readonly timestamp: number
+    readonly _tag: "Success"
+    readonly value: AI
+    readonly refreshing?: LoadingFrom | undefined
+  },
+  AsyncData.Success<A>
+> =>
+  SuccessSchemaJson(Schema.from(value))
+    .pipe(
+      Schema.transform(
+        SuccessSchema(value),
+        (json): AsyncData.Success<AI> =>
+          AsyncData.success(json.value, {
+            timestamp: json.timestamp,
+            refreshing: json.refreshing ? loadingFromJson(json.refreshing) : undefined
+          }),
+        (success) => ({
+          _tag: "Success",
+          value: success.value,
+          timestamp: success.timestamp,
+          refreshing: Option.getOrUndefined(Option.map(success.refreshing, loadingToJson))
+        } as const)
+      ),
+      Schema.annotations({
+        [AST.IdentifierAnnotationId]: "AsyncData.Success",
+        [Pretty.PrettyHookId]: SUCCESS_PRETTY,
+        [Arbitrary.ArbitraryHookId]: successArbitrary,
+        [Eq.EquivalenceHookId]: () => Equal.equals
+      })
+    )
+
+/**
+ * @since 1.0.0
+ */
+export type SuccessFrom<A> = Schema.Schema.From<ReturnType<typeof SuccessSchemaJson<A, A>>>
+
+/**
+ * @since 1.0.0
+ */
+export type AsyncDataFrom<E, A> = NoDataFrom | LoadingFrom | FailureFrom<E> | SuccessFrom<A>
+
 /**
  * @since 1.0.0
  */
 export const asyncData = <EI, E, AI, A>(
   error: Schema.Schema<EI, E>,
   value: Schema.Schema<AI, A>
+): Schema.Schema<AsyncDataFrom<EI, AI>, AsyncData.AsyncData<E, A>> => {
+  return Schema.union(
+    NoData,
+    Loading,
+    Failure(error),
+    Success(value)
+  )
+}
+
+/**
+ * @since 1.0.0
+ */
+export const asyncDataFromSelf = <EI, E, AI, A>(
+  error: Schema.Schema<EI, E>,
+  value: Schema.Schema<AI, A>
 ): Schema.Schema<AsyncData.AsyncData<EI, AI>, AsyncData.AsyncData<E, A>> => {
   return Schema.declare(
-    [cause(error), value],
+    [Schema.cause(error), value],
     Schema.struct({}),
-    (_, ...params) => {
+    (isDecoding, ...params) => {
       const [causeSchema, valueSchema] = params as readonly [
-        Schema.Schema<Cause.Cause<EI>, Cause.Cause<E>>,
-        Schema.Schema<AI, A>
+        Schema.Schema<Cause.Cause<any>, Cause.Cause<any>>,
+        Schema.Schema<any, any>
       ]
-      const parseCause = Schema.parse(causeSchema)
-      const parseValue = Schema.parse(valueSchema)
+      const parseCause = isDecoding ? Schema.parse(causeSchema) : Schema.encode(causeSchema)
+      const parseValue = isDecoding ? Schema.parse(valueSchema) : Schema.encode(valueSchema)
 
       return (input, options) => {
         return Effect.gen(function*(_) {
-          if (!AsyncData.isAsyncData<EI, AI>(input)) return yield* _(ParseResult.fail(ParseResult.unexpected(input)))
+          if (!AsyncData.isAsyncData(input)) return yield* _(ParseResult.fail(ParseResult.forbidden(input)))
 
           switch (input._tag) {
             case "NoData":
@@ -143,6 +440,7 @@ export const asyncData = <EI, E, AI, A>(
               const cause = yield* _(parseCause(input.cause, options))
 
               return AsyncData.failCause(cause, {
+                timestamp: input.timestamp,
                 refreshing: Option.getOrUndefined(input.refreshing)
               })
             }
@@ -150,6 +448,7 @@ export const asyncData = <EI, E, AI, A>(
               const a = yield* _(parseValue(input.value, options))
 
               return AsyncData.success(a, {
+                timestamp: input.timestamp,
                 refreshing: Option.getOrUndefined(input.refreshing)
               })
             }
@@ -159,8 +458,52 @@ export const asyncData = <EI, E, AI, A>(
     },
     {
       [AST.IdentifierAnnotationId]: "AsyncData",
-      [Arbitrary.ArbitraryHookId]: asyncDataPretty,
-      [Pretty.PrettyHookId]: asyncDataArbitrary
+      [Pretty.PrettyHookId]: asyncDataPretty,
+      [Arbitrary.ArbitraryHookId]: asyncDataArbitrary,
+      [Eq.EquivalenceHookId]: () => Equal.equals
     }
   )
 }
+
+function asyncDataPretty<E, A>(
+  E: Pretty.Pretty<Cause.Cause<E>>,
+  A: Pretty.Pretty<A>
+): Pretty.Pretty<AsyncData.AsyncData<E, A>> {
+  return AsyncData.match({
+    NoData: () => NO_DATA_PRETTY,
+    Loading: LOADING_PRETTY,
+    Failure: (_, data) => FAILURE_PRETTY(E)(data),
+    Success: (_, data) => SUCCESS_PRETTY(A)(data)
+  })
+}
+
+function asyncDataArbitrary<E, A>(
+  E: Arbitrary.Arbitrary<Cause.Cause<E>>,
+  A: Arbitrary.Arbitrary<A>
+): Arbitrary.Arbitrary<AsyncData.AsyncData<E, A>> {
+  const noDataArb = Arbitrary.make(NoData)
+  const loadingArb = Arbitrary.make(Loading)
+  const failureArb = failureArbitrary(E)
+  const successArb = successArbitrary(A)
+
+  return (fc) =>
+    fc.oneof(
+      noDataArb(fc),
+      loadingArb(fc),
+      failureArb(fc),
+      successArb(fc)
+    )
+}
+
+function progressFromJson(json: ProgressFromTo | undefined): P.Progress | undefined {
+  if (json === undefined) return
+  return P.make(json.loaded, json.total)
+}
+
+function progressToJson(progres: Option.Option<P.Progress>): ProgressFromTo | undefined {
+  if (Option.isNone(progres)) return
+  return {
+    loaded: progres.value.loaded,
+    total: Option.getOrUndefined(progres.value.total)
+  }
+}

package/src/internal/async-data.ts

@@ -1,7 +1,13 @@
 // Internal
 
-import { Cause, Effect, Effectable, Equal, Hash, Option, pipe, Unify } from "effect"
-import { constant } from "effect/Function"
+import * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import * as Effectable from "effect/Effectable"
+import * as Equal from "effect/Equal"
+import { constant, pipe } from "effect/Function"
+import * as Hash from "effect/Hash"
+import * as Option from "effect/Option"
+import * as Unify from "effect/Unify"
 import { type AsyncData, type Failure, type Loading, type Success } from "../AsyncData.js"
 import { FAILURE_TAG, LOADING_TAG, NO_DATA_TAG, SUCCESS_TAG } from "./tag.js"
 
@@ -14,7 +20,7 @@ export class FailureImpl<E> extends Effectable.Class<never, E, never> implements
   [Unify.unifySymbol]!: AsyncData.Unify<this>;
   [Unify.ignoreSymbol]!: AsyncData.IgnoreList
 
-  constructor(readonly cause: Cause.Cause<E>, readonly refreshing: Option.Option<Loading>) {
+  constructor(readonly cause: Cause.Cause<E>, readonly timestamp: number, readonly refreshing: Option.Option<Loading>) {
     super()
 
     this.commit = constant(Effect.failCause(cause))
@@ -23,6 +29,7 @@ export class FailureImpl<E> extends Effectable.Class<never, E, never> implements
   [Equal.symbol] = (that: unknown) => {
     return isAsyncData(that) && that._tag === "Failure"
       && Equal.equals(this.cause, that.cause)
+      && Equal.equals(this.timestamp, that.timestamp)
       && Equal.equals(this.refreshing, that.refreshing)
   };
 
@@ -44,7 +51,7 @@ export class SuccessImpl<A> extends Effectable.Class<never, never, A> implements
   [Unify.unifySymbol]!: AsyncData.Unify<this>;
   [Unify.ignoreSymbol]!: AsyncData.IgnoreList
 
-  constructor(readonly value: A, readonly refreshing: Option.Option<Loading>) {
+  constructor(readonly value: A, readonly timestamp: number, readonly refreshing: Option.Option<Loading>) {
     super()
 
     this.commit = constant(Effect.succeed(value))
@@ -53,6 +60,7 @@ export class SuccessImpl<A> extends Effectable.Class<never, never, A> implements
   [Equal.symbol] = (that: unknown) => {
     return isAsyncData(that) && that._tag === "Success"
       && Equal.equals(this.value, that.value)
+      && Equal.equals(this.timestamp, that.timestamp)
       && Equal.equals(this.refreshing, that.refreshing)
   };