@typed/async-data 0.7.1 → 0.9.0

package/dist/cjs/Schema.js

@@ -3,23 +3,24 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.asyncDataFromSelf = exports.asyncDataFromJson = exports.asyncData = exports.Progress = void 0;
+exports.asyncDataFromJson = exports.Progress = exports.AsyncDataFromSelf = exports.AsyncData = void 0;
 var Arbitrary = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/schema/Arbitrary"));
 var AST = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/schema/AST"));
 var Eq = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/schema/Equivalence"));
-var Parser = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/schema/Parser"));
 var ParseResult = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/schema/ParseResult"));
 var Pretty = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/schema/Pretty"));
 var Schema = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/schema/Schema"));
-var AsyncData = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@typed/async-data/AsyncData"));
-var _effect = /*#__PURE__*/require("effect");
 var Cause = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Cause"));
+var Data = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Data"));
 var Effect = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Effect"));
+var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Equal"));
+var FiberId = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/FiberId"));
 var Option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Option"));
 var _Predicate = /*#__PURE__*/require("effect/Predicate");
+var _AsyncData = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./AsyncData.js"));
 var P = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Progress.js"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /**
  * @since 1.0.0
  */
@@ -38,13 +39,13 @@ const SUCCESS_PRETTY = print => success => Option.match(success.refreshing, {
   onSome: () => `AsyncData.Success(timestamp=${success.timestamp}, refreshing=true, value=${print(success.value)})`
 });
 const OPTIMISTIC_PRETTY = (printValue, printError) => optimistic => `AsyncData.Optimistic(timestamp=${optimistic.timestamp}, value=${printValue(optimistic.value)}, previous=${asyncDataPretty(printValue, printError)(optimistic.previous)})`;
-const ProgressSchemaJson = /*#__PURE__*/Schema.struct({
-  loaded: Schema.bigint,
-  total: /*#__PURE__*/Schema.optional(Schema.bigint)
+const ProgressSchemaJson = /*#__PURE__*/Schema.Struct({
+  loaded: Schema.BigInt,
+  total: /*#__PURE__*/Schema.optional(Schema.BigInt)
 });
-const ProgressSchema = /*#__PURE__*/Schema.data( /*#__PURE__*/Schema.struct({
-  loaded: Schema.bigintFromSelf,
-  total: /*#__PURE__*/Schema.optionFromSelf(Schema.bigintFromSelf)
+const ProgressSchema = /*#__PURE__*/Schema.Data( /*#__PURE__*/Schema.Struct({
+  loaded: Schema.BigIntFromSelf,
+  total: /*#__PURE__*/Schema.OptionFromSelf(Schema.BigIntFromSelf)
 }));
 const progressArbitrary = fc => fc.bigInt().chain(loaded => fc.option(fc.bigInt({
   min: loaded
@@ -52,20 +53,23 @@ const progressArbitrary = fc => fc.bigInt().chain(loaded => fc.option(fc.bigInt(
 /**
  * @since 1.0.0
  */
-const Progress = exports.Progress = /*#__PURE__*/ProgressSchemaJson.pipe( /*#__PURE__*/Schema.transform(ProgressSchema, json => P.make(json.loaded, json.total), progress => ({
-  loaded: progress.loaded,
-  total: Option.getOrUndefined(progress.total)
-})), /*#__PURE__*/Schema.annotations({
+const Progress = exports.Progress = /*#__PURE__*/ProgressSchemaJson.pipe( /*#__PURE__*/Schema.transform(ProgressSchema, {
+  decode: json => P.make(json.loaded, json.total),
+  encode: progress => ({
+    loaded: progress.loaded,
+    total: Option.getOrUndefined(progress.total)
+  })
+}), /*#__PURE__*/Schema.annotations({
   [AST.IdentifierAnnotationId]: "Progress",
   [Pretty.PrettyHookId]: () => "Progress",
   [Arbitrary.ArbitraryHookId]: () => progressArbitrary,
-  [Eq.EquivalenceHookId]: () => _effect.Equal.equals
+  [Eq.EquivalenceHookId]: () => Equal.equals
 }));
-const loadingArbitrary = fc => fc.option(progressArbitrary(fc)).map(progress => AsyncData.loading({
+const loadingArbitrary = fc => fc.option(progressArbitrary(fc)).map(progress => _AsyncData.loading({
   timestamp: Date.now(),
   progress: progress || undefined
 }));
-const failureArbitrary = cause => fc => fc.option(loadingArbitrary(fc)).chain(refreshing => cause(fc).chain(cause => fc.date().map(date => AsyncData.failCause(cause, {
+const failureArbitrary = cause => fc => fc.option(loadingArbitrary(fc)).chain(refreshing => cause(fc).chain(cause => fc.date().map(date => _AsyncData.failCause(cause, {
   timestamp: date.getTime(),
   refreshing: refreshing || undefined
 }))));
@@ -83,7 +87,7 @@ const FailureFrom = (cause, timestamp, refreshing) => {
   }
   return base;
 };
-const successArbitrary = value => fc => fc.option(loadingArbitrary(fc)).chain(refreshing => value(fc).chain(a => fc.date().map(date => AsyncData.success(a, {
+const successArbitrary = value => fc => fc.option(loadingArbitrary(fc)).chain(refreshing => value(fc).chain(a => fc.date().map(date => _AsyncData.success(a, {
   timestamp: date.getTime(),
   refreshing: refreshing || undefined
 }))));
@@ -107,7 +111,7 @@ const OptimisticFrom = (value, timestamp, previous) => ({
   timestamp,
   previous
 });
-const optimisticArbitrary = (valueArb, causeArb) => fc => asyncDataArbitrary(valueArb, causeArb)(fc).chain(previous => valueArb(fc).chain(value => fc.date().map(date => AsyncData.optimistic(previous, value, {
+const optimisticArbitrary = (valueArb, causeArb) => fc => asyncDataArbitrary(valueArb, causeArb)(fc).chain(previous => valueArb(fc).chain(value => fc.date().map(date => _AsyncData.optimistic(previous, value, {
   timestamp: date.getTime()
 }))));
 const fromEq = (a, b) => {
@@ -121,25 +125,25 @@ const fromEq = (a, b) => {
         if (a.timestamp !== loadingB.timestamp) return false;
         if (a.progress === undefined && loadingB.progress === undefined) return true;
         if (a.progress === undefined || loadingB.progress === undefined) return false;
-        return _effect.Equal.equals(_effect.Data.struct(a.progress), _effect.Data.struct(loadingB.progress));
+        return Equal.equals(Data.struct(a.progress), Data.struct(loadingB.progress));
       }
     case "Failure":
       {
         const failureB = b;
-        if (!(_effect.Equal.equals(_effect.Data.struct(a.cause), _effect.Data.struct(failureB.cause)) && a.timestamp === failureB.timestamp)) return false;
+        if (!(Equal.equals(Data.struct(a.cause), Data.struct(failureB.cause)) && a.timestamp === failureB.timestamp)) return false;
         if (a.refreshing === undefined && failureB.refreshing === undefined) return true;
         if (a.refreshing === undefined || failureB.refreshing === undefined) return false;
-        return _effect.Equal.equals(_effect.Data.struct(a.refreshing), _effect.Data.struct(failureB.refreshing));
+        return Equal.equals(Data.struct(a.refreshing), Data.struct(failureB.refreshing));
       }
     case "Success":
       {
         const successB = b;
-        return _effect.Equal.equals(a.value, successB.value) && a.timestamp === successB.timestamp && _effect.Equal.equals(a.refreshing, successB.refreshing);
+        return Equal.equals(a.value, successB.value) && a.timestamp === successB.timestamp && Equal.equals(a.refreshing, successB.refreshing);
       }
     case "Optimistic":
       {
         const optimisticB = b;
-        return _effect.Equal.equals(a.value, optimisticB.value) && a.timestamp === optimisticB.timestamp && fromEq(a.previous, optimisticB.previous);
+        return Equal.equals(a.value, optimisticB.value) && a.timestamp === optimisticB.timestamp && fromEq(a.previous, optimisticB.previous);
       }
   }
 };
@@ -156,12 +160,12 @@ function isProgressFrom(value) {
 function isLoadingFrom(value) {
   return (0, _Predicate.hasProperty)(value, "_tag") && value._tag === "Loading" && (0, _Predicate.hasProperty)(value, "timestamp") && typeof value.timestamp === "number" && ((0, _Predicate.hasProperty)(value, "progress") ? isProgressFrom(value.progress) : true);
 }
-const isCauseFrom = /*#__PURE__*/Schema.is( /*#__PURE__*/Schema.from( /*#__PURE__*/Schema.cause({
-  defect: Schema.unknown,
-  error: Schema.unknown
+const isCauseEncoded = /*#__PURE__*/Schema.is( /*#__PURE__*/Schema.encodedSchema( /*#__PURE__*/Schema.Cause({
+  defect: Schema.Unknown,
+  error: Schema.Unknown
 })));
 function isFailureFrom(value) {
-  return (0, _Predicate.hasProperty)(value, "_tag") && value._tag === "Failure" && (0, _Predicate.hasProperty)(value, "cause") && isCauseFrom(value.cause) && (0, _Predicate.hasProperty)(value, "timestamp") && typeof value.timestamp === "number" && ((0, _Predicate.hasProperty)(value, "refreshing") ? value.refreshing === undefined || isLoadingFrom(value.refreshing) : true);
+  return (0, _Predicate.hasProperty)(value, "_tag") && value._tag === "Failure" && (0, _Predicate.hasProperty)(value, "cause") && isCauseEncoded(value.cause) && (0, _Predicate.hasProperty)(value, "timestamp") && typeof value.timestamp === "number" && ((0, _Predicate.hasProperty)(value, "refreshing") ? value.refreshing === undefined || isLoadingFrom(value.refreshing) : true);
 }
 function isSuccessFrom(value) {
   return (0, _Predicate.hasProperty)(value, "_tag") && value._tag === "Success" && (0, _Predicate.hasProperty)(value, "value") && (0, _Predicate.hasProperty)(value, "timestamp") && typeof value.timestamp === "number" && ((0, _Predicate.hasProperty)(value, "refreshing") ? value.refreshing === undefined || isLoadingFrom(value.refreshing) : true);
@@ -176,73 +180,76 @@ function isAsyncDataFrom(value) {
  * @since 1.0.0
  */
 const asyncDataFromJson = (value, error) => {
-  const schema = Schema.declare([value, Schema.cause({
+  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, options) => {
-      return Effect.gen(function* (_) {
-        if (!isAsyncDataFrom(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 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;
-  }, (valueSchema, causeSchema) => {
-    const parseCause = Parser.encode(causeSchema);
-    const parseValue = Parser.encode(valueSchema);
-    const parseAsyncData = (input, options) => {
-      return Effect.gen(function* (_) {
-        if (!isAsyncDataFrom(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(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;
+    defect: Schema.Unknown
+  })], {
+    decode: (valueSchema, causeSchema) => {
+      const parseCause = ParseResult.decode(causeSchema);
+      const parseValue = ParseResult.decode(valueSchema);
+      const parseAsyncData = (input, options) => {
+        return Effect.gen(function* () {
+          if (!isAsyncDataFrom(input)) {
+            return yield* Effect.fail(new 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);
+              }
+          }
+        });
+      };
+      return parseAsyncData;
+    },
+    encode: (valueSchema, causeSchema) => {
+      const parseCause = ParseResult.encode(causeSchema);
+      const parseValue = ParseResult.encode(valueSchema);
+      const parseAsyncData = (input, options) => {
+        return Effect.gen(function* () {
+          if (!isAsyncDataFrom(input)) {
+            return yield* Effect.fail(new 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);
+              }
+            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;
+    }
   }, {
     title: "AsyncDataFrom",
     equivalence: () => fromEq,
@@ -255,109 +262,115 @@ const asyncDataFromJson = (value, error) => {
  * @since 1.0.0
  */
 exports.asyncDataFromJson = asyncDataFromJson;
-const asyncData = (valueSchema, errorSchema) => {
+const AsyncData = (valueSchema, errorSchema) => {
   const from = asyncDataFromJson(valueSchema, errorSchema);
-  const to = asyncDataFromSelf(Schema.to(valueSchema), Schema.to(errorSchema));
-  return from.pipe(Schema.transform(to, asyncDataFromToAsyncData, asyncDataToAsyncDataFrom));
+  const to = AsyncDataFromSelf(Schema.typeSchema(valueSchema), Schema.typeSchema(errorSchema));
+  return from.pipe(Schema.transform(to, {
+    decode: asyncDataFromToAsyncData,
+    encode: asyncDataToAsyncDataFrom
+  }));
 };
 /**
  * @since 1.0.0
  */
-exports.asyncData = asyncData;
-const asyncDataFromSelf = (value, error) => {
-  const schema = Schema.declare([value, Schema.causeFromSelf({
+exports.AsyncData = AsyncData;
+const AsyncDataFromSelf = (value, error) => {
+  const schema = Schema.declare([value, Schema.CauseFromSelf({
     error
-  })], (valueSchema, causeSchema) => {
-    const parseCause = Parser.decode(causeSchema);
-    const parseValue = Parser.decode(valueSchema);
-    const parseAsyncData = (input, options) => {
-      return Effect.gen(function* (_) {
-        if (!AsyncData.isAsyncData(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)
-              });
-            }
-          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;
-  }, (valueSchema, causeSchema) => {
-    const parseCause = Parser.encode(causeSchema);
-    const parseValue = Parser.encode(valueSchema);
-    const parseAsyncData = (input, options) => {
-      return Effect.gen(function* (_) {
-        if (!AsyncData.isAsyncData(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)
-              });
-            }
-          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;
+  })], {
+    decode: (valueSchema, causeSchema) => {
+      const parseCause = ParseResult.decode(causeSchema);
+      const parseValue = ParseResult.decode(valueSchema);
+      const parseAsyncData = (input, options) => {
+        return Effect.gen(function* () {
+          if (!_AsyncData.isAsyncData(input)) {
+            return yield* Effect.fail(new 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)
+                });
+              }
+            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;
+    },
+    encode: (valueSchema, causeSchema) => {
+      const parseCause = ParseResult.encode(causeSchema);
+      const parseValue = ParseResult.encode(valueSchema);
+      const parseAsyncData = (input, options) => {
+        return Effect.gen(function* () {
+          if (!_AsyncData.isAsyncData(input)) {
+            return yield* Effect.fail(new 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)
+                });
+              }
+            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;
+    }
   }, {
     title: "AsyncData",
     pretty: asyncDataPretty,
     arbitrary: asyncDataArbitrary,
-    equivalence: () => _effect.Equal.equals
+    equivalence: () => Equal.equals
   });
   return schema;
 };
-exports.asyncDataFromSelf = asyncDataFromSelf;
+exports.AsyncDataFromSelf = AsyncDataFromSelf;
 function asyncDataPretty(A, E) {
-  return AsyncData.match({
+  return _AsyncData.match({
     NoData: () => NO_DATA_PRETTY,
     Loading: LOADING_PRETTY,
     Failure: (_, data) => FAILURE_PRETTY(E)(data),
@@ -369,7 +382,7 @@ function asyncDataArbitrary(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()), failureArb(fc), successArb(fc), optimisticArb(fc));
+  return fc => fc.oneof(fc.constant(_AsyncData.noData()), fc.constant(_AsyncData.loading()), failureArb(fc), successArb(fc), optimisticArb(fc));
 }
 function progressFromJson(json) {
   if (json === undefined) return Option.none();
@@ -384,7 +397,7 @@ function progressToJson(progres) {
 }
 function loadingFromJson(json) {
   if (json === undefined) return;
-  return AsyncData.loading({
+  return _AsyncData.loading({
     timestamp: json.timestamp,
     progress: Option.getOrUndefined(progressFromJson(json.progress))
   });
@@ -421,14 +434,14 @@ function causeFromToCause(from) {
 function fiberIdFromToFiberId(id) {
   switch (id._tag) {
     case "None":
-      return _effect.FiberId.none;
+      return FiberId.none;
     case "Runtime":
-      return _effect.FiberId.runtime(id.id, id.startTimeMillis);
+      return FiberId.runtime(id.id, id.startTimeMillis);
     case "Composite":
-      return _effect.FiberId.composite(fiberIdFromToFiberId(id.left), fiberIdFromToFiberId(id.right));
+      return FiberId.composite(fiberIdFromToFiberId(id.left), fiberIdFromToFiberId(id.right));
   }
 }
-function causeToCauseFrom(cause) {
+function causeToCauseEncoded(cause) {
   switch (cause._tag) {
     case "Die":
       return {
@@ -452,14 +465,14 @@ function causeToCauseFrom(cause) {
     case "Parallel":
       return {
         _tag: "Parallel",
-        left: causeToCauseFrom(cause.left),
-        right: causeToCauseFrom(cause.right)
+        left: causeToCauseEncoded(cause.left),
+        right: causeToCauseEncoded(cause.right)
       };
     case "Sequential":
       return {
         _tag: "Sequential",
-        left: causeToCauseFrom(cause.left),
-        right: causeToCauseFrom(cause.right)
+        left: causeToCauseEncoded(cause.left),
+        right: causeToCauseEncoded(cause.right)
       };
   }
 }
@@ -493,7 +506,7 @@ function asyncDataToAsyncDataFrom(data) {
     case "Loading":
       return loadingToJson(data);
     case "Failure":
-      return FailureFrom(causeToCauseFrom(data.cause), data.timestamp, Option.getOrUndefined(Option.map(data.refreshing, loadingToJson)));
+      return FailureFrom(causeToCauseEncoded(data.cause), data.timestamp, Option.getOrUndefined(Option.map(data.refreshing, loadingToJson)));
     case "Success":
       return SuccessFrom(data.value, data.timestamp, Option.getOrUndefined(Option.map(data.refreshing, loadingToJson)));
     case "Optimistic":
@@ -503,21 +516,21 @@ function asyncDataToAsyncDataFrom(data) {
 function asyncDataFromToAsyncData(data) {
   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
       });
   }