@typed/async-data 0.7.1 → 0.8.0

package/src/Schema.ts

@@ -5,30 +5,31 @@
 import * as Arbitrary from "@effect/schema/Arbitrary"
 import * as AST from "@effect/schema/AST"
 import * as Eq from "@effect/schema/Equivalence"
-import * as Parser from "@effect/schema/Parser"
 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 { Data, Equal, FiberId } from "effect"
 import * as Cause from "effect/Cause"
+import * as Data from "effect/Data"
 import * as Effect from "effect/Effect"
+import * as Equal from "effect/Equal"
+import * as FiberId from "effect/FiberId"
 import * as Option from "effect/Option"
 import { hasProperty } from "effect/Predicate"
+import * as _AsyncData from "./AsyncData.js"
 import * as P from "./Progress.js"
 
 const NO_DATA_PRETTY = "AsyncData.NoData"
-const LOADING_PRETTY = (loading: AsyncData.Loading) =>
+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>) =>
+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: () => `AsyncData.Failure(timestamp=${failure.timestamp}, refreshing=true, cause=${print(failure.cause)})`
   })
-const SUCCESS_PRETTY = <A>(print: Pretty.Pretty<A>) => (success: AsyncData.Success<A>) =>
+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: () => `AsyncData.Success(timestamp=${success.timestamp}, refreshing=true, value=${print(success.value)})`
@@ -36,7 +37,7 @@ const SUCCESS_PRETTY = <A>(print: Pretty.Pretty<A>) => (success: AsyncData.Succe
 
 const OPTIMISTIC_PRETTY =
   <E, A>(printValue: Pretty.Pretty<A>, printError: Pretty.Pretty<Cause.Cause<E>>) =>
-  (optimistic: AsyncData.Optimistic<A, E>) =>
+  (optimistic: _AsyncData.Optimistic<A, E>) =>
     `AsyncData.Optimistic(timestamp=${optimistic.timestamp}, value=${printValue(optimistic.value)}, previous=${
       asyncDataPretty(printValue, printError)(optimistic.previous)
     })`
@@ -46,9 +47,9 @@ const OPTIMISTIC_PRETTY =
  */
 export type NoDataFrom = { readonly _tag: "NoData" }
 
-const ProgressSchemaJson = Schema.struct({
-  loaded: Schema.bigint,
-  total: Schema.optional(Schema.bigint)
+const ProgressSchemaJson = Schema.Struct({
+  loaded: Schema.BigInt,
+  total: Schema.optional(Schema.BigInt)
 })
 
 const ProgressSchema: Schema.Schema<
@@ -57,12 +58,12 @@ const ProgressSchema: Schema.Schema<
     readonly loaded: bigint
     readonly total: Option.Option<bigint>
   }
-> = Schema.data(Schema.struct({
-  loaded: Schema.bigintFromSelf,
-  total: Schema.optionFromSelf(Schema.bigintFromSelf)
+> = Schema.Data(Schema.Struct({
+  loaded: Schema.BigIntFromSelf,
+  total: Schema.OptionFromSelf(Schema.BigIntFromSelf)
 }))
 
-const progressArbitrary: Arbitrary.Arbitrary<P.Progress> = (fc) =>
+const progressArbitrary: Arbitrary.LazyArbitrary<P.Progress> = (fc) =>
   fc.bigInt().chain((loaded) => fc.option(fc.bigInt({ min: loaded })).map((total) => P.make(loaded, total)))
 
 /**
@@ -74,16 +75,18 @@ export const Progress: Schema.Schema<
 > = ProgressSchemaJson.pipe(
   Schema.transform(
     ProgressSchema,
-    (json): P.Progress => P.make(json.loaded, json.total),
-    (progress) => ({
-      loaded: progress.loaded,
-      total: Option.getOrUndefined(progress.total)
-    })
+    {
+      decode: (json): P.Progress => P.make(json.loaded, json.total),
+      encode: (progress) => ({
+        loaded: progress.loaded,
+        total: Option.getOrUndefined(progress.total)
+      })
+    }
   ),
   Schema.annotations({
     [AST.IdentifierAnnotationId]: "Progress",
     [Pretty.PrettyHookId]: () => "Progress",
-    [Arbitrary.ArbitraryHookId]: (): Arbitrary.Arbitrary<P.Progress> => progressArbitrary,
+    [Arbitrary.ArbitraryHookId]: (): Arbitrary.LazyArbitrary<P.Progress> => progressArbitrary,
     [Eq.EquivalenceHookId]: () => Equal.equals
   })
 )
@@ -96,9 +99,9 @@ export type ProgressFrom = {
   readonly total?: string | undefined
 }
 
-const loadingArbitrary: Arbitrary.Arbitrary<AsyncData.Loading> = (fc) =>
+const loadingArbitrary: Arbitrary.LazyArbitrary<_AsyncData.Loading> = (fc) =>
   fc.option(progressArbitrary(fc)).map((progress) =>
-    AsyncData.loading({
+    _AsyncData.loading({
       timestamp: Date.now(),
       progress: progress || undefined
     })
@@ -114,13 +117,13 @@ export type LoadingFrom = {
 }
 
 const failureArbitrary = <E>(
-  cause: Arbitrary.Arbitrary<Cause.Cause<E>>
-): Arbitrary.Arbitrary<AsyncData.Failure<E>> =>
+  cause: Arbitrary.LazyArbitrary<Cause.Cause<E>>
+): Arbitrary.LazyArbitrary<_AsyncData.Failure<E>> =>
 (fc) =>
   fc.option(loadingArbitrary(fc)).chain((refreshing) =>
     cause(fc).chain((cause) =>
       fc.date().map((date) =>
-        AsyncData.failCause(cause, {
+        _AsyncData.failCause(cause, {
           timestamp: date.getTime(),
           refreshing: refreshing || undefined
         })
@@ -133,12 +136,12 @@ const failureArbitrary = <E>(
  */
 export type FailureFrom<E> = {
   readonly _tag: "Failure"
-  readonly cause: Schema.CauseFrom<E>
+  readonly cause: Schema.CauseEncoded<E>
   readonly timestamp: number
   readonly refreshing?: LoadingFrom | undefined
 }
 
-const FailureFrom = <E>(cause: Schema.CauseFrom<E>, timestamp: number, refreshing?: LoadingFrom): FailureFrom<E> => {
+const FailureFrom = <E>(cause: Schema.CauseEncoded<E>, timestamp: number, refreshing?: LoadingFrom): FailureFrom<E> => {
   const base = {
     _tag: "Failure",
     cause,
@@ -153,13 +156,13 @@ const FailureFrom = <E>(cause: Schema.CauseFrom<E>, timestamp: number, refreshin
 }
 
 const successArbitrary = <A>(
-  value: Arbitrary.Arbitrary<A>
-): Arbitrary.Arbitrary<AsyncData.Success<A>> =>
+  value: Arbitrary.LazyArbitrary<A>
+): Arbitrary.LazyArbitrary<_AsyncData.Success<A>> =>
 (fc) =>
   fc.option(loadingArbitrary(fc)).chain((refreshing) =>
     value(fc).chain((a) =>
       fc.date().map((date) =>
-        AsyncData.success(a, {
+        _AsyncData.success(a, {
           timestamp: date.getTime(),
           refreshing: refreshing || undefined
         })
@@ -209,13 +212,13 @@ const OptimisticFrom = <A, E>(value: A, timestamp: number, previous: AsyncDataFr
 })
 
 const optimisticArbitrary = <A, E>(
-  valueArb: Arbitrary.Arbitrary<A>,
-  causeArb: Arbitrary.Arbitrary<Cause.Cause<E>>
-): Arbitrary.Arbitrary<AsyncData.Optimistic<A, E>> =>
+  valueArb: Arbitrary.LazyArbitrary<A>,
+  causeArb: Arbitrary.LazyArbitrary<Cause.Cause<E>>
+): Arbitrary.LazyArbitrary<_AsyncData.Optimistic<A, E>> =>
 (fc) =>
   asyncDataArbitrary(valueArb, causeArb)(fc).chain((previous) =>
     valueArb(fc).chain((value) =>
-      fc.date().map((date) => AsyncData.optimistic(previous, value, { timestamp: date.getTime() }))
+      fc.date().map((date) => _AsyncData.optimistic(previous, value, { timestamp: date.getTime() }))
     )
   )
 
@@ -291,13 +294,13 @@ function isLoadingFrom(value: unknown): value is LoadingFrom {
     && (hasProperty(value, "progress") ? isProgressFrom(value.progress) : true)
 }
 
-const isCauseFrom = Schema.is(Schema.from(Schema.cause({ defect: Schema.unknown, error: Schema.unknown })))
+const isCauseEncoded = Schema.is(Schema.encodedSchema(Schema.Cause({ defect: Schema.Unknown, error: Schema.Unknown })))
 
 function isFailureFrom(value: unknown): value is FailureFrom<any> {
   return hasProperty(value, "_tag")
     && value._tag === "Failure"
     && hasProperty(value, "cause")
-    && isCauseFrom(value.cause)
+    && isCauseEncoded(value.cause)
     && hasProperty(value, "timestamp")
     && typeof value.timestamp === "number"
     && (hasProperty(value, "refreshing") ? value.refreshing === undefined || isLoadingFrom(value.refreshing) : true)
@@ -338,86 +341,88 @@ export const asyncDataFromJson = <A, AI, R1, E, EI, R2>(
   error: Schema.Schema<E, EI, R2>
 ): Schema.Schema<AsyncDataFrom<A, E>, AsyncDataFrom<AI, EI>, R1 | R2> => {
   const schema = Schema.declare(
-    [value, Schema.cause({ error, defect: Schema.unknown })],
-    (valueSchema, causeSchema) => {
-      const parseCause = Parser.decode(causeSchema)
-      const parseValue = Parser.decode(valueSchema)
-
-      const parseAsyncData = (
-        input: unknown,
-        options?: AST.ParseOptions | undefined
-      ): Effect.Effect<
-        AsyncDataFrom<A, E>,
-        ParseResult.ParseIssue,
-        never
-      > => {
-        return Effect.gen(function*(_) {
-          if (!isAsyncDataFrom<AI, EI>(input)) {
-            return yield* _(Effect.fail<ParseResult.ParseIssue>(ParseResult.forbidden(schema.ast, input)))
-          }
-
-          switch (input._tag) {
-            case "NoData":
-            case "Loading":
-              return input
-            case "Failure": {
-              const cause = yield* _(parseCause(input.cause, options))
-              return FailureFrom(cause, input.timestamp, input.refreshing)
-            }
-            case "Success": {
-              const a = yield* _(parseValue(input.value, options))
-              return SuccessFrom(a, input.timestamp, input.refreshing)
-            }
-            case "Optimistic": {
-              const previous = yield* _(parseAsyncData(input.previous, options))
-              const value = yield* _(parseValue(input.value, options))
-              return OptimisticFrom(value, input.timestamp, previous)
+    [value, Schema.Cause({ error, defect: Schema.Unknown })],
+    {
+      decode: (valueSchema, causeSchema) => {
+        const parseCause = ParseResult.decode(causeSchema)
+        const parseValue = ParseResult.decode(valueSchema)
+
+        const parseAsyncData = (
+          input: unknown,
+          options?: AST.ParseOptions | undefined
+        ): Effect.Effect<
+          AsyncDataFrom<A, E>,
+          ParseResult.ParseIssue,
+          never
+        > => {
+          return Effect.gen(function*() {
+            if (!isAsyncDataFrom<AI, EI>(input)) {
+              return yield* Effect.fail<ParseResult.ParseIssue>(new ParseResult.Forbidden(schema.ast, input))
             }
-          }
-        })
-      }
 
-      return parseAsyncData
-    },
-    (valueSchema, causeSchema) => {
-      const parseCause = Parser.encode(causeSchema)
-      const parseValue = Parser.encode(valueSchema)
-
-      const parseAsyncData = (
-        input: unknown,
-        options?: AST.ParseOptions
-      ): Effect.Effect<
-        AsyncDataFrom<AI, EI>,
-        ParseResult.ParseIssue,
-        never
-      > => {
-        return Effect.gen(function*(_) {
-          if (!isAsyncDataFrom<A, E>(input)) {
-            return yield* _(Effect.fail<ParseResult.ParseIssue>(ParseResult.forbidden(schema.ast, input)))
-          }
-
-          switch (input._tag) {
-            case "NoData":
-            case "Loading":
-              return input
-            case "Failure": {
-              const cause = yield* _(parseCause(causeFromToCause(input.cause), options))
-              return FailureFrom(cause, input.timestamp, input.refreshing)
+            switch (input._tag) {
+              case "NoData":
+              case "Loading":
+                return input
+              case "Failure": {
+                const cause = yield* parseCause(input.cause, options)
+                return FailureFrom(cause, input.timestamp, input.refreshing)
+              }
+              case "Success": {
+                const a = yield* parseValue(input.value, options)
+                return SuccessFrom(a, input.timestamp, input.refreshing)
+              }
+              case "Optimistic": {
+                const previous = yield* parseAsyncData(input.previous, options)
+                const value = yield* parseValue(input.value, options)
+                return OptimisticFrom(value, input.timestamp, previous)
+              }
             }
-            case "Success": {
-              const a = yield* _(parseValue(input.value, options))
-              return SuccessFrom(a, input.timestamp, input.refreshing)
+          })
+        }
+
+        return parseAsyncData
+      },
+      encode: (valueSchema, causeSchema) => {
+        const parseCause = ParseResult.encode(causeSchema)
+        const parseValue = ParseResult.encode(valueSchema)
+
+        const parseAsyncData = (
+          input: unknown,
+          options?: AST.ParseOptions
+        ): Effect.Effect<
+          AsyncDataFrom<AI, EI>,
+          ParseResult.ParseIssue,
+          never
+        > => {
+          return Effect.gen(function*() {
+            if (!isAsyncDataFrom<A, E>(input)) {
+              return yield* Effect.fail<ParseResult.ParseIssue>(new ParseResult.Forbidden(schema.ast, input))
             }
-            case "Optimistic": {
-              const previous = yield* _(parseAsyncData(input.previous, options))
-              const value = yield* _(parseValue(input.value, options))
-              return OptimisticFrom(value, input.timestamp, previous)
+
+            switch (input._tag) {
+              case "NoData":
+              case "Loading":
+                return input
+              case "Failure": {
+                const cause = yield* parseCause(causeFromToCause(input.cause), options)
+                return FailureFrom(cause, input.timestamp, input.refreshing)
+              }
+              case "Success": {
+                const a = yield* parseValue(input.value, options)
+                return SuccessFrom(a, input.timestamp, input.refreshing)
+              }
+              case "Optimistic": {
+                const previous = yield* parseAsyncData(input.previous, options)
+                const value = yield* parseValue(input.value, options)
+                return OptimisticFrom(value, input.timestamp, previous)
+              }
             }
-          }
-        })
-      }
+          })
+        }
 
-      return parseAsyncData
+        return parseAsyncData
+      }
     },
     {
       title: "AsyncDataFrom",
@@ -435,131 +440,135 @@ export const asyncDataFromJson = <A, AI, R1, E, EI, R2>(
 /**
  * @since 1.0.0
  */
-export const asyncData = <A, AI, R1, E, EI, R2>(
+export const AsyncData = <A, AI, R1, E, EI, R2>(
   valueSchema: Schema.Schema<A, AI, R2>,
   errorSchema: Schema.Schema<E, EI, R1>
-): Schema.Schema<AsyncData.AsyncData<A, E>, AsyncDataFrom<AI, EI>, R1 | R2> => {
+): Schema.Schema<_AsyncData.AsyncData<A, E>, AsyncDataFrom<AI, EI>, R1 | R2> => {
   const from = asyncDataFromJson(valueSchema, errorSchema)
-  const to = asyncDataFromSelf(Schema.to(valueSchema), Schema.to(errorSchema))
+  const to = AsyncDataFromSelf(Schema.typeSchema(valueSchema), Schema.typeSchema(errorSchema))
 
   return from
     .pipe(Schema.transform(
       to,
-      asyncDataFromToAsyncData,
-      asyncDataToAsyncDataFrom
+      {
+        decode: asyncDataFromToAsyncData,
+        encode: asyncDataToAsyncDataFrom
+      }
     ))
 }
 
 /**
  * @since 1.0.0
  */
-export const asyncDataFromSelf = <A, AI, R1, E, EI, R2>(
+export const AsyncDataFromSelf = <A, AI, R1, E, EI, R2>(
   value: Schema.Schema<A, AI, R2>,
   error: Schema.Schema<E, EI, R1>
-): Schema.Schema<AsyncData.AsyncData<A, E>, AsyncData.AsyncData<AI, EI>, R1 | R2> => {
+): Schema.Schema<_AsyncData.AsyncData<A, E>, _AsyncData.AsyncData<AI, EI>, R1 | R2> => {
   const schema = Schema.declare(
-    [value, Schema.causeFromSelf({ error })],
-    (valueSchema, causeSchema) => {
-      const parseCause = Parser.decode(causeSchema)
-      const parseValue = Parser.decode(valueSchema)
-
-      const parseAsyncData = (
-        input: unknown,
-        options?: AST.ParseOptions
-      ): Effect.Effect<
-        AsyncData.AsyncData<A, E>,
-        ParseResult.ParseIssue,
-        never
-      > => {
-        return Effect.gen(function*(_) {
-          if (!AsyncData.isAsyncData<AI, EI>(input)) {
-            return yield* _(Effect.fail<ParseResult.ParseIssue>(ParseResult.forbidden(schema.ast, input)))
-          }
-
-          switch (input._tag) {
-            case "NoData":
-            case "Loading":
-              return input
-            case "Failure": {
-              const cause = yield* _(parseCause(input.cause, options))
-
-              return AsyncData.failCause(cause, {
-                timestamp: input.timestamp,
-                refreshing: Option.getOrUndefined(input.refreshing)
-              })
+    [value, Schema.CauseFromSelf({ error })],
+    {
+      decode: (valueSchema, causeSchema) => {
+        const parseCause = ParseResult.decode(causeSchema)
+        const parseValue = ParseResult.decode(valueSchema)
+
+        const parseAsyncData = (
+          input: unknown,
+          options?: AST.ParseOptions
+        ): Effect.Effect<
+          _AsyncData.AsyncData<A, E>,
+          ParseResult.ParseIssue,
+          never
+        > => {
+          return Effect.gen(function*() {
+            if (!_AsyncData.isAsyncData<AI, EI>(input)) {
+              return yield* Effect.fail<ParseResult.ParseIssue>(new ParseResult.Forbidden(schema.ast, input))
             }
-            case "Success": {
-              const a = yield* _(parseValue(input.value, options))
 
-              return AsyncData.success(a, {
-                timestamp: input.timestamp,
-                refreshing: Option.getOrUndefined(input.refreshing)
-              })
+            switch (input._tag) {
+              case "NoData":
+              case "Loading":
+                return input
+              case "Failure": {
+                const cause = yield* parseCause(input.cause, options)
+
+                return _AsyncData.failCause(cause, {
+                  timestamp: input.timestamp,
+                  refreshing: Option.getOrUndefined(input.refreshing)
+                })
+              }
+              case "Success": {
+                const a = yield* parseValue(input.value, options)
+
+                return _AsyncData.success(a, {
+                  timestamp: input.timestamp,
+                  refreshing: Option.getOrUndefined(input.refreshing)
+                })
+              }
+              case "Optimistic": {
+                const previous = yield* parseAsyncData(input.previous, options)
+                const value = yield* parseValue(input.value, options)
+
+                return _AsyncData.optimistic(previous, value, {
+                  timestamp: input.timestamp
+                })
+              }
             }
-            case "Optimistic": {
-              const previous = yield* _(parseAsyncData(input.previous, options))
-              const value = yield* _(parseValue(input.value, options))
-
-              return AsyncData.optimistic(previous, value, {
-                timestamp: input.timestamp
-              })
+          })
+        }
+
+        return parseAsyncData
+      },
+      encode: (valueSchema, causeSchema) => {
+        const parseCause = ParseResult.encode(causeSchema)
+        const parseValue = ParseResult.encode(valueSchema)
+
+        const parseAsyncData = (
+          input: unknown,
+          options?: AST.ParseOptions
+        ): Effect.Effect<
+          _AsyncData.AsyncData<AI, EI>,
+          ParseResult.ParseIssue,
+          never
+        > => {
+          return Effect.gen(function*() {
+            if (!_AsyncData.isAsyncData<A, E>(input)) {
+              return yield* Effect.fail(new ParseResult.Forbidden(schema.ast, input))
             }
-          }
-        })
-      }
 
-      return parseAsyncData
-    },
-    (valueSchema, causeSchema) => {
-      const parseCause = Parser.encode(causeSchema)
-      const parseValue = Parser.encode(valueSchema)
-
-      const parseAsyncData = (
-        input: unknown,
-        options?: AST.ParseOptions
-      ): Effect.Effect<
-        AsyncData.AsyncData<AI, EI>,
-        ParseResult.ParseIssue,
-        never
-      > => {
-        return Effect.gen(function*(_) {
-          if (!AsyncData.isAsyncData<A, E>(input)) {
-            return yield* _(Effect.fail(ParseResult.forbidden(schema.ast, input)))
-          }
-
-          switch (input._tag) {
-            case "NoData":
-            case "Loading":
-              return input
-            case "Failure": {
-              const cause = yield* _(parseCause(input.cause, options))
-
-              return AsyncData.failCause(cause, {
-                timestamp: input.timestamp,
-                refreshing: Option.getOrUndefined(input.refreshing)
-              })
+            switch (input._tag) {
+              case "NoData":
+              case "Loading":
+                return input
+              case "Failure": {
+                const cause = yield* parseCause(input.cause, options)
+
+                return _AsyncData.failCause(cause, {
+                  timestamp: input.timestamp,
+                  refreshing: Option.getOrUndefined(input.refreshing)
+                })
+              }
+              case "Success": {
+                const a = yield* parseValue(input.value, options)
+
+                return _AsyncData.success(a, {
+                  timestamp: input.timestamp,
+                  refreshing: Option.getOrUndefined(input.refreshing)
+                })
+              }
+              case "Optimistic": {
+                const previous = yield* parseAsyncData(input.previous, options)
+                const value = yield* parseValue(input.value, options)
+
+                return _AsyncData.optimistic(previous, value, {
+                  timestamp: input.timestamp
+                })
+              }
             }
-            case "Success": {
-              const a = yield* _(parseValue(input.value, options))
+          })
+        }
 
-              return AsyncData.success(a, {
-                timestamp: input.timestamp,
-                refreshing: Option.getOrUndefined(input.refreshing)
-              })
-            }
-            case "Optimistic": {
-              const previous = yield* _(parseAsyncData(input.previous, options))
-              const value = yield* _(parseValue(input.value, options))
-
-              return AsyncData.optimistic(previous, value, {
-                timestamp: input.timestamp
-              })
-            }
-          }
-        })
+        return parseAsyncData
       }
-
-      return parseAsyncData
     },
     {
       title: "AsyncData",
@@ -568,14 +577,14 @@ export const asyncDataFromSelf = <A, AI, R1, E, EI, R2>(
       equivalence: () => Equal.equals
     }
   )
-  return schema
+  return schema as any
 }
 
 function asyncDataPretty<A, E>(
   A: Pretty.Pretty<A>,
   E: Pretty.Pretty<Cause.Cause<E>>
-): Pretty.Pretty<AsyncData.AsyncData<A, E>> {
-  return AsyncData.match({
+): Pretty.Pretty<_AsyncData.AsyncData<A, E>> {
+  return _AsyncData.match({
     NoData: () => NO_DATA_PRETTY,
     Loading: LOADING_PRETTY,
     Failure: (_, data) => FAILURE_PRETTY(E)(data),
@@ -585,17 +594,17 @@ function asyncDataPretty<A, E>(
 }
 
 function asyncDataArbitrary<A, E>(
-  A: Arbitrary.Arbitrary<A>,
-  E: Arbitrary.Arbitrary<Cause.Cause<E>>
-): Arbitrary.Arbitrary<AsyncData.AsyncData<A, E>> {
+  A: Arbitrary.LazyArbitrary<A>,
+  E: Arbitrary.LazyArbitrary<Cause.Cause<E>>
+): Arbitrary.LazyArbitrary<_AsyncData.AsyncData<A, E>> {
   const failureArb = failureArbitrary(E)
   const successArb = successArbitrary(A)
   const optimisticArb = optimisticArbitrary(A, E)
 
   return (fc) =>
     fc.oneof(
-      fc.constant(AsyncData.noData()),
-      fc.constant(AsyncData.loading()),
+      fc.constant(_AsyncData.noData()),
+      fc.constant(_AsyncData.loading()),
       failureArb(fc),
       successArb(fc),
       optimisticArb(fc)
@@ -615,15 +624,15 @@ function progressToJson(progres: Option.Option<P.Progress>): ProgressFrom | unde
   }
 }
 
-function loadingFromJson(json: LoadingFrom | undefined): AsyncData.Loading | undefined {
+function loadingFromJson(json: LoadingFrom | undefined): _AsyncData.Loading | undefined {
   if (json === undefined) return
-  return AsyncData.loading({
+  return _AsyncData.loading({
     timestamp: json.timestamp,
     progress: Option.getOrUndefined(progressFromJson(json.progress))
   })
 }
 
-function loadingToJson(loading: AsyncData.Loading): LoadingFrom {
+function loadingToJson(loading: _AsyncData.Loading): LoadingFrom {
   const from: LoadingFrom = {
     _tag: "Loading",
     timestamp: loading.timestamp
@@ -636,7 +645,7 @@ function loadingToJson(loading: AsyncData.Loading): LoadingFrom {
   return from
 }
 
-function causeFromToCause<E>(from: Schema.CauseFrom<E>): Cause.Cause<E> {
+function causeFromToCause<E>(from: Schema.CauseEncoded<E>): Cause.Cause<E> {
   switch (from._tag) {
     case "Die":
       return Cause.die(from.defect)
@@ -653,7 +662,7 @@ function causeFromToCause<E>(from: Schema.CauseFrom<E>): Cause.Cause<E> {
   }
 }
 
-function fiberIdFromToFiberId(id: Schema.FiberIdFrom): FiberId.FiberId {
+function fiberIdFromToFiberId(id: Schema.FiberIdEncoded): FiberId.FiberId {
   switch (id._tag) {
     case "None":
       return FiberId.none
@@ -664,7 +673,7 @@ function fiberIdFromToFiberId(id: Schema.FiberIdFrom): FiberId.FiberId {
   }
 }
 
-function causeToCauseFrom<E>(cause: Cause.Cause<E>): Schema.CauseFrom<E> {
+function causeToCauseEncoded<E>(cause: Cause.Cause<E>): Schema.CauseEncoded<E> {
   switch (cause._tag) {
     case "Die":
       return { _tag: "Die", defect: cause.defect }
@@ -675,13 +684,13 @@ function causeToCauseFrom<E>(cause: Cause.Cause<E>): Schema.CauseFrom<E> {
     case "Interrupt":
       return { _tag: "Interrupt", fiberId: fiberIdToFiberIdFrom(cause.fiberId) }
     case "Parallel":
-      return { _tag: "Parallel", left: causeToCauseFrom(cause.left), right: causeToCauseFrom(cause.right) }
+      return { _tag: "Parallel", left: causeToCauseEncoded(cause.left), right: causeToCauseEncoded(cause.right) }
     case "Sequential":
-      return { _tag: "Sequential", left: causeToCauseFrom(cause.left), right: causeToCauseFrom(cause.right) }
+      return { _tag: "Sequential", left: causeToCauseEncoded(cause.left), right: causeToCauseEncoded(cause.right) }
   }
 }
 
-function fiberIdToFiberIdFrom(id: FiberId.FiberId): Schema.FiberIdFrom {
+function fiberIdToFiberIdFrom(id: FiberId.FiberId): Schema.FiberIdEncoded {
   switch (id._tag) {
     case "None":
       return { _tag: "None" }
@@ -694,7 +703,7 @@ function fiberIdToFiberIdFrom(id: FiberId.FiberId): Schema.FiberIdFrom {
 
 const NO_DATA_FROM: NoDataFrom = { _tag: "NoData" } as const
 
-function asyncDataToAsyncDataFrom<A, E>(data: AsyncData.AsyncData<A, E>): AsyncDataFrom<A, E> {
+function asyncDataToAsyncDataFrom<A, E>(data: _AsyncData.AsyncData<A, E>): AsyncDataFrom<A, E> {
   switch (data._tag) {
     case "NoData":
       return NO_DATA_FROM
@@ -702,7 +711,7 @@ function asyncDataToAsyncDataFrom<A, E>(data: AsyncData.AsyncData<A, E>): AsyncD
       return loadingToJson(data)
     case "Failure":
       return FailureFrom(
-        causeToCauseFrom(data.cause),
+        causeToCauseEncoded(data.cause),
         data.timestamp,
         Option.getOrUndefined(Option.map(data.refreshing, loadingToJson))
       )
@@ -717,24 +726,24 @@ function asyncDataToAsyncDataFrom<A, E>(data: AsyncData.AsyncData<A, E>): AsyncD
   }
 }
 
-function asyncDataFromToAsyncData<A, E>(data: AsyncDataFrom<A, E>): AsyncData.AsyncData<A, E> {
+function asyncDataFromToAsyncData<A, E>(data: AsyncDataFrom<A, E>): _AsyncData.AsyncData<A, E> {
   switch (data._tag) {
     case "NoData":
-      return AsyncData.noData()
+      return _AsyncData.noData()
     case "Loading":
       return loadingFromJson(data)!
     case "Failure":
-      return AsyncData.failCause(causeFromToCause(data.cause), {
+      return _AsyncData.failCause(causeFromToCause(data.cause), {
         timestamp: data.timestamp,
         refreshing: loadingFromJson(data.refreshing)
       })
     case "Success":
-      return AsyncData.success(data.value, {
+      return _AsyncData.success(data.value, {
         timestamp: data.timestamp,
         refreshing: loadingFromJson(data.refreshing)
       })
     case "Optimistic":
-      return AsyncData.optimistic(asyncDataFromToAsyncData(data.previous), data.value, {
+      return _AsyncData.optimistic(asyncDataFromToAsyncData(data.previous), data.value, {
         timestamp: data.timestamp
       })
   }