@nlozgachev/pipelined 0.42.0 → 0.44.0

package/dist/{chunk-GBB6LVLI.mjs → chunk-74JKKJ4R.mjs}

@@ -23,11 +23,7 @@ var Duration;
   Duration2.subtract = (other) => (self) => wrap(Brand.unwrap(self) - Brand.unwrap(other));
 })(Duration || (Duration = {}));
 
-// src/Types/NonEmptyList.ts
-var isNonEmptyList = (list) => list.length > 0;
-
 export {
   Brand,
-  isNonEmptyList,
   Duration
 };

package/dist/{chunk-6VYLZTAM.mjs → chunk-LKTOK5IT.mjs}

@@ -2,13 +2,73 @@ import {
   Deferred,
   Maybe,
   Result,
-  Task
-} from "./chunk-OAP765G3.mjs";
-import {
-  isNonEmptyList
-} from "./chunk-GBB6LVLI.mjs";
+  Task,
+  isNonEmptyArr
+} from "./chunk-ND476266.mjs";
 
 // src/Data/Arr.ts
+var ArrMaybe;
+((ArrMaybe2) => {
+  ArrMaybe2.traverse = (f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "None") {
+        return Maybe.none();
+      }
+      result[i] = mapped.value;
+    }
+    return Maybe.some(result);
+  };
+  ArrMaybe2.sequence = (data) => (0, ArrMaybe2.traverse)((a) => a)(data);
+})(ArrMaybe || (ArrMaybe = {}));
+var ArrResult;
+((ArrResult2) => {
+  ArrResult2.traverse = (f) => (data) => {
+    const n = data.length;
+    const result = new Array(n);
+    for (let i = 0; i < n; i++) {
+      const mapped = f(data[i]);
+      if (mapped.kind === "Err") {
+        return mapped;
+      }
+      result[i] = mapped.value;
+    }
+    return Result.ok(result);
+  };
+  ArrResult2.sequence = (data) => (0, ArrResult2.traverse)((a) => a)(data);
+})(ArrResult || (ArrResult = {}));
+var ArrTaskResult;
+((ArrTaskResult2) => {
+  ArrTaskResult2.traverse = (f) => (data) => Task.from(async () => {
+    const result = [];
+    for (const a of data) {
+      const r = await Deferred.toPromise(f(a)());
+      if (Result.isErr(r)) {
+        return r;
+      }
+      result.push(r.value);
+    }
+    return Result.ok(result);
+  });
+  ArrTaskResult2.sequence = (data) => (0, ArrTaskResult2.traverse)((a) => a)(data);
+})(ArrTaskResult || (ArrTaskResult = {}));
+var ArrTask;
+((ArrTask2) => {
+  ArrTask2.traverse = (f) => (data) => Task.from(() => Promise.all(data.map((a) => Deferred.toPromise(f(a)()))));
+  ArrTask2.sequence = (data) => (0, ArrTask2.traverse)((a) => a)(data);
+  ArrTask2.Result = ArrTaskResult;
+})(ArrTask || (ArrTask = {}));
+var ArrNonEmpty;
+((ArrNonEmpty2) => {
+  ArrNonEmpty2.singleton = (value) => [value];
+  ArrNonEmpty2.fromArray = (data) => isNonEmptyArr(data) ? Maybe.some(data) : Maybe.none();
+  ArrNonEmpty2.head = (data) => data[0];
+  ArrNonEmpty2.last = (data) => data[data.length - 1];
+  ArrNonEmpty2.tail = (data) => data.slice(1);
+  ArrNonEmpty2.reduce = (f) => (data) => data.reduce(f);
+})(ArrNonEmpty || (ArrNonEmpty = {}));
 var Arr;
 ((Arr2) => {
   Arr2.head = (data) => data.length > 0 ? Maybe.some(data[0]) : Maybe.none();
@@ -182,6 +242,7 @@ var Arr;
     }
     return result;
   };
+  Arr2.concat = (other) => (data) => [...data, ...other];
   Arr2.chunksOf = (n) => (data) => {
     if (n <= 0) {
       return [];
@@ -222,47 +283,12 @@ var Arr;
     return result;
   };
   Arr2.reduce = (initial, f) => (data) => data.reduce(f, initial);
-  Arr2.traverse = (f) => (data) => {
-    const n = data.length;
-    const result = new Array(n);
-    for (let i = 0; i < n; i++) {
-      const mapped = f(data[i]);
-      if (mapped.kind === "None") {
-        return Maybe.none();
-      }
-      result[i] = mapped.value;
-    }
-    return Maybe.some(result);
-  };
-  Arr2.traverseResult = (f) => (data) => {
-    const n = data.length;
-    const result = new Array(n);
-    for (let i = 0; i < n; i++) {
-      const mapped = f(data[i]);
-      if (mapped.kind === "Err") {
-        return mapped;
-      }
-      result[i] = mapped.value;
-    }
-    return Result.ok(result);
-  };
-  Arr2.traverseTask = (f) => (data) => Task.from(() => Promise.all(data.map((a) => Deferred.toPromise(f(a)()))));
-  Arr2.sequence = (data) => (0, Arr2.traverse)((a) => a)(data);
-  Arr2.sequenceResult = (data) => (0, Arr2.traverseResult)((a) => a)(data);
-  Arr2.sequenceTask = (data) => (0, Arr2.traverseTask)((a) => a)(data);
-  Arr2.traverseTaskResult = (f) => (data) => Task.from(async () => {
-    const result = [];
-    for (const a of data) {
-      const r = await Deferred.toPromise(f(a)());
-      if (Result.isErr(r)) {
-        return r;
-      }
-      result.push(r.value);
-    }
-    return Result.ok(result);
-  });
-  Arr2.sequenceTaskResult = (data) => (0, Arr2.traverseTaskResult)((a) => a)(data);
-  Arr2.isNonEmpty = (data) => isNonEmptyList(data);
+  Arr2.Maybe = ArrMaybe;
+  Arr2.Result = ArrResult;
+  Arr2.Task = ArrTask;
+  Arr2.isNonEmpty = (data) => isNonEmptyArr(data);
+  Arr2.prepend = (value) => (data) => [value, ...data];
+  Arr2.append = (value) => (data) => [...data, value];
   Arr2.size = (data) => data.length;
   Arr2.some = (predicate) => (data) => {
     const n = data.length;
@@ -338,6 +364,7 @@ var Arr;
     const i = Math.max(0, index);
     return [data.slice(0, i), data.slice(i)];
   };
+  Arr2.NonEmpty = ArrNonEmpty;
 })(Arr || (Arr = {}));
 
 // src/Data/Dict.ts
@@ -547,25 +574,78 @@ var Num;
 })(Num || (Num = {}));
 
 // src/Data/Rec.ts
+var _isNonEmpty = (data) => Object.keys(data).length > 0;
+var RecMaybe;
+((RecMaybe2) => {
+  RecMaybe2.traverse = (f) => (data) => {
+    const recordKeys = Object.keys(data);
+    const result = {};
+    for (let i = 0; i < recordKeys.length; i++) {
+      const key = recordKeys[i];
+      const maybeVal = f(data[key]);
+      if (maybeVal.kind === "None") {
+        return maybeVal;
+      }
+      Object.defineProperty(result, key, { value: maybeVal.value, writable: true, enumerable: true, configurable: true });
+    }
+    return { kind: "Some", value: result };
+  };
+  RecMaybe2.sequence = (data) => (0, RecMaybe2.traverse)((a) => a)(data);
+})(RecMaybe || (RecMaybe = {}));
+var RecResult;
+((RecResult2) => {
+  RecResult2.traverse = (f) => (data) => {
+    const recordKeys = Object.keys(data);
+    const result = {};
+    for (let i = 0; i < recordKeys.length; i++) {
+      const key = recordKeys[i];
+      const res = f(data[key]);
+      if (res.kind === "Err") {
+        return res;
+      }
+      Object.defineProperty(result, key, { value: res.value, writable: true, enumerable: true, configurable: true });
+    }
+    return { kind: "Ok", value: result };
+  };
+  RecResult2.sequence = (data) => (0, RecResult2.traverse)((a) => a)(data);
+})(RecResult || (RecResult = {}));
+var RecNonEmpty;
+((RecNonEmpty2) => {
+  RecNonEmpty2.singleton = (key, value) => ({ [key]: value });
+  RecNonEmpty2.fromRecord = (data) => _isNonEmpty(data) ? Maybe.some(data) : Maybe.none();
+  RecNonEmpty2.keys = (data) => Object.keys(data);
+  RecNonEmpty2.values = (data) => Object.values(data);
+  RecNonEmpty2.entries = (data) => Object.entries(data);
+  RecNonEmpty2.reduce = (f) => (data) => {
+    const recordVals = Object.values(data);
+    return recordVals.reduce(f);
+  };
+})(RecNonEmpty || (RecNonEmpty = {}));
 var Rec;
 ((Rec2) => {
-  Rec2.map = (f) => (data) => {
-    const keys2 = Object.keys(data);
-    const vals = Object.values(data);
+  Rec2.isNonEmpty = _isNonEmpty;
+  Rec2.map = (f) => ((data) => {
+    const recordKeys = Object.keys(data);
+    const recordValues = Object.values(data);
     const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < keys2.length; i++) {
-      Object.defineProperty(result, keys2[i], { value: f(vals[i]), writable: true, enumerable: true, configurable: true });
+    for (let i = 0; i < recordKeys.length; i++) {
+      Object.defineProperty(result, recordKeys[i], {
+        value: f(recordValues[i]),
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
     }
     return result;
-  };
+  });
   Rec2.filterMap = (f) => (data) => {
-    const keys2 = Object.keys(data);
-    const vals = Object.values(data);
+    const recordKeys = Object.keys(data);
+    const recordValues = Object.values(data);
     const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < keys2.length; i++) {
-      const maybeVal = f(vals[i]);
+    for (let i = 0; i < recordKeys.length; i++) {
+      const maybeVal = f(recordValues[i]);
       if (maybeVal.kind === "Some") {
-        Object.defineProperty(result, keys2[i], {
+        Object.defineProperty(result, recordKeys[i], {
           value: maybeVal.value,
           writable: true,
           enumerable: true,
@@ -575,27 +655,32 @@ var Rec;
     }
     return result;
   };
-  Rec2.mapWithKey = (f) => (data) => {
-    const keys2 = Object.keys(data);
-    const vals = Object.values(data);
+  Rec2.mapWithKey = (f) => ((data) => {
+    const recordKeys = Object.keys(data);
+    const recordValues = Object.values(data);
     const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < keys2.length; i++) {
-      Object.defineProperty(result, keys2[i], {
-        value: f(keys2[i], vals[i]),
+    for (let i = 0; i < recordKeys.length; i++) {
+      Object.defineProperty(result, recordKeys[i], {
+        value: f(recordKeys[i], recordValues[i]),
         writable: true,
         enumerable: true,
         configurable: true
       });
     }
     return result;
-  };
+  });
   Rec2.filter = (predicate) => (data) => {
-    const keys2 = Object.keys(data);
-    const vals = Object.values(data);
+    const recordKeys = Object.keys(data);
+    const recordValues = Object.values(data);
     const result = Object.create(Object.getPrototypeOf(data));
-    for (let i = 0; i < keys2.length; i++) {
-      if (predicate(vals[i])) {
-        Object.defineProperty(result, keys2[i], { value: vals[i], writable: true, enumerable: true, configurable: true });
+    for (let i = 0; i < recordKeys.length; i++) {
+      if (predicate(recordValues[i])) {
+        Object.defineProperty(result, recordKeys[i], {
+          value: recordValues[i],
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });
       }
     }
     return result;
@@ -672,6 +757,9 @@ var Rec;
     }
     return result;
   };
+  Rec2.Maybe = RecMaybe;
+  Rec2.Result = RecResult;
+  Rec2.NonEmpty = RecNonEmpty;
 })(Rec || (Rec = {}));
 
 // src/Data/Str.ts

package/dist/{chunk-OAP765G3.mjs → chunk-ND476266.mjs}

@@ -1,6 +1,6 @@
 import {
   Duration
-} from "./chunk-GBB6LVLI.mjs";
+} from "./chunk-74JKKJ4R.mjs";
 
 // src/Core/Combinable.ts
 var Combinable;
@@ -1579,6 +1579,162 @@ var State;
   )(data);
 })(State || (State = {}));
 
+// src/Core/TaskMaybe.ts
+var TaskMaybe;
+((TaskMaybe2) => {
+  TaskMaybe2.some = (value) => Task.resolve(Maybe.some(value));
+  TaskMaybe2.none = () => Task.resolve(Maybe.none());
+  TaskMaybe2.fromMaybe = (option) => Task.resolve(option);
+  TaskMaybe2.fromNullable = (value) => Task.resolve(Maybe.fromNullable(value));
+  TaskMaybe2.fromResult = (result) => Task.resolve(Result.toMaybe(result));
+  TaskMaybe2.fromTask = (task) => Task.map(Maybe.some)(task);
+  TaskMaybe2.tryCatch = (f) => Task.from((signal) => Promise.resolve(f(signal)).then(Maybe.some).catch(() => Maybe.none()));
+  TaskMaybe2.map = (f) => (data) => Task.map(Maybe.map(f))(data);
+  TaskMaybe2.chain = (f) => (data) => Task.chain((option) => Maybe.isSome(option) ? f(option.value) : Task.resolve(Maybe.none()))(data);
+  TaskMaybe2.ap = (arg) => (data) => Task.from(
+    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
+      ([of_, oa]) => Maybe.ap(oa)(of_)
+    )
+  );
+  TaskMaybe2.fold = (onNone, onSome) => (data) => Task.map(Maybe.fold(onNone, onSome))(data);
+  TaskMaybe2.match = (cases) => (data) => Task.map(Maybe.match(cases))(data);
+  TaskMaybe2.getOrElse = (defaultValue) => (data) => Task.map(Maybe.getOrElse(defaultValue))(data);
+  TaskMaybe2.tap = (f) => (data) => Task.map(Maybe.tap(f))(data);
+  TaskMaybe2.filter = (predicate) => (data) => Task.map(Maybe.filter(predicate))(data);
+  TaskMaybe2.toResult = (onNone) => (data) => Task.map(Maybe.toResult(onNone))(data);
+  TaskMaybe2.bindTo = (key) => (data) => (0, TaskMaybe2.map)((a) => ({ [key]: a }))(data);
+  TaskMaybe2.bind = (key, f) => (data) => (0, TaskMaybe2.chain)(
+    (a) => (0, TaskMaybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  TaskMaybe2.recover = (fallback) => (data) => Task.chain((maybe) => Maybe.isNone(maybe) ? fallback() : Task.resolve(maybe))(data);
+  TaskMaybe2.struct = (fields) => Task.from((signal) => {
+    const keys = Object.keys(fields);
+    const promises = keys.map((key) => Deferred.toPromise(fields[key](signal)));
+    return Promise.all(promises).then((results) => {
+      const record = {};
+      for (let i = 0; i < keys.length; i++) {
+        const res = results[i];
+        if (Maybe.isNone(res)) {
+          return res;
+        }
+        record[keys[i]] = res.value;
+      }
+      return Maybe.some(record);
+    });
+  });
+})(TaskMaybe || (TaskMaybe = {}));
+
+// src/Core/TaskResult.ts
+var TaskResult;
+((TaskResult2) => {
+  TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
+  TaskResult2.err = (error) => Task.resolve(Result.err(error));
+  TaskResult2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.err(onNull()) : Result.ok(value));
+  TaskResult2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Result.err(onNone()) : Result.ok(maybe.value));
+  TaskResult2.fromResult = (result) => Task.resolve(result);
+  TaskResult2.fromThrowable = (f, onError) => (...args) => Task.from(() => f(...args).then(Result.ok).catch((error) => Result.err(onError(error))));
+  TaskResult2.tryCatch = (f, onError) => Task.from((signal) => Promise.resolve(f(signal)).then(Result.ok).catch((error) => Result.err(onError(error))));
+  TaskResult2.map = (f) => (data) => Task.map(Result.map(f))(data);
+  TaskResult2.mapError = (f) => (data) => Task.map(Result.mapError(f))(data);
+  TaskResult2.chain = (f) => (data) => Task.chain((result) => Result.isOk(result) ? f(result.value) : Task.resolve(Result.err(result.error)))(
+    data
+  );
+  TaskResult2.fold = (onErr, onOk) => (data) => Task.map(Result.fold(onErr, onOk))(data);
+  TaskResult2.match = (cases) => (data) => Task.map(Result.match(cases))(data);
+  TaskResult2.recover = (fallback) => (data) => Task.chain(
+    (result) => Result.isErr(result) ? fallback(result.error) : Task.resolve(result)
+  )(data);
+  TaskResult2.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
+  TaskResult2.tap = (f) => (data) => Task.map(Result.tap(f))(data);
+  TaskResult2.tapError = (f) => (data) => Task.map(Result.tapError(f))(data);
+  TaskResult2.ap = (arg) => (data) => Task.from(
+    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
+      ([of_, oa]) => Result.ap(oa)(of_)
+    )
+  );
+  TaskResult2.run = (signal) => (task) => task(signal);
+  TaskResult2.bindTo = (key) => (data) => (0, TaskResult2.map)((a) => ({ [key]: a }))(data);
+  TaskResult2.bind = (key, f) => (data) => (0, TaskResult2.chain)(
+    (a) => (0, TaskResult2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  TaskResult2.struct = (fields) => Task.from((signal) => {
+    const keys = Object.keys(fields);
+    const promises = keys.map((key) => Deferred.toPromise(fields[key](signal)));
+    return Promise.all(promises).then((results) => {
+      const record = {};
+      for (let i = 0; i < keys.length; i++) {
+        const res = results[i];
+        if (Result.isErr(res)) {
+          return res;
+        }
+        record[keys[i]] = res.value;
+      }
+      return Result.ok(record);
+    });
+  });
+})(TaskResult || (TaskResult = {}));
+
+// src/internal/InternalTypes.ts
+var isNonEmptyArr = (list) => list.length > 0;
+
+// src/Core/TaskValidation.ts
+var TaskValidation;
+((TaskValidation2) => {
+  TaskValidation2.passed = (value) => Task.resolve(Validation.passed(value));
+  TaskValidation2.failed = (error) => Task.resolve(Validation.failed(error));
+  TaskValidation2.failedAll = (errors) => Task.resolve(Validation.failedAll(errors));
+  TaskValidation2.fromValidation = (validation) => Task.resolve(validation);
+  TaskValidation2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Validation.failed(onNull()) : Validation.passed(value));
+  TaskValidation2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Validation.failed(onNone()) : Validation.passed(maybe.value));
+  TaskValidation2.fromResult = (result) => Task.resolve(Validation.fromResult(result));
+  TaskValidation2.tryCatch = (f, onError) => Task.from(
+    (signal) => Promise.resolve(f(signal)).then(Validation.passed).catch((error) => Validation.failed(onError(error)))
+  );
+  TaskValidation2.map = (f) => (data) => Task.map(Validation.map(f))(data);
+  TaskValidation2.ap = (arg) => (data) => Task.from(
+    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
+      ([vf, va]) => Validation.ap(va)(vf)
+    )
+  );
+  TaskValidation2.fold = (onFailed, onPassed) => (data) => Task.map(Validation.fold(onFailed, onPassed))(data);
+  TaskValidation2.match = (cases) => (data) => Task.map(Validation.match(cases))(data);
+  TaskValidation2.getOrElse = (defaultValue) => (data) => Task.map(Validation.getOrElse(defaultValue))(data);
+  TaskValidation2.tap = (f) => (data) => Task.map(Validation.tap(f))(data);
+  TaskValidation2.recover = (fallback) => (data) => Task.chain(
+    (validation) => Validation.isPassed(validation) ? Task.resolve(validation) : fallback(validation.errors)
+  )(data);
+  TaskValidation2.product = (first, second) => Task.from(
+    (signal) => Promise.all([Deferred.toPromise(first(signal)), Deferred.toPromise(second(signal))]).then(
+      ([va, vb]) => Validation.product(va, vb)
+    )
+  );
+  TaskValidation2.productAll = (data) => Task.from(
+    (signal) => Promise.all(data.map((t) => Deferred.toPromise(t(signal)))).then((results) => {
+      const [first, ...rest] = results;
+      return Validation.productAll([first, ...rest]);
+    })
+  );
+  TaskValidation2.mapError = (f) => (data) => Task.map(Validation.mapError(f))(data);
+  TaskValidation2.tapError = (f) => (data) => Task.map(Validation.tapError(f))(data);
+  TaskValidation2.struct = (fields) => Task.from((signal) => {
+    const keys = Object.keys(fields);
+    const promises = keys.map((key) => Deferred.toPromise(fields[key](signal)));
+    return Promise.all(promises).then((results) => {
+      const record = {};
+      const errors = [];
+      for (let i = 0; i < keys.length; i++) {
+        const res = results[i];
+        if (Validation.isPassed(res)) {
+          record[keys[i]] = res.value;
+        } else {
+          errors.push(...res.errors);
+        }
+      }
+      return isNonEmptyArr(errors) ? Validation.failedAll(errors) : Validation.passed(record);
+    });
+  });
+})(TaskValidation || (TaskValidation = {}));
+
 // src/Core/Task.ts
 var toPromise = (task, signal) => Deferred.toPromise(task(signal));
 var getMs2 = (duration) => Duration.toMilliseconds(duration);
@@ -1735,14 +1891,16 @@ var Task;
   Task2.timeout = (duration, onTimeout) => (task) => (0, Task2.from)((outerSignal) => {
     const controller = new AbortController();
     let timerId;
-    function cleanUp() {
-      clearTimeout(timerId);
-      outerSignal?.removeEventListener("abort", onOuterAbort);
-    }
-    function onOuterAbort() {
+    let cleanUp = () => {
+    };
+    const onOuterAbort = () => {
       cleanUp();
       controller.abort();
-    }
+    };
+    cleanUp = () => {
+      clearTimeout(timerId);
+      outerSignal?.removeEventListener("abort", onOuterAbort);
+    };
     if (outerSignal) {
       if (outerSignal.aborted) {
         controller.abort();
@@ -1787,123 +1945,11 @@ var Task;
   Task2.bind = (key, f) => (data) => (0, Task2.chain)(
     (a) => (0, Task2.map)((b) => ({ ...a, [key]: b }))(f(a))
   )(data);
+  Task2.Maybe = TaskMaybe;
+  Task2.Result = TaskResult;
+  Task2.Validation = TaskValidation;
 })(Task || (Task = {}));
 
-// src/Core/TaskMaybe.ts
-var TaskMaybe;
-((TaskMaybe2) => {
-  TaskMaybe2.some = (value) => Task.resolve(Maybe.some(value));
-  TaskMaybe2.none = () => Task.resolve(Maybe.none());
-  TaskMaybe2.fromMaybe = (option) => Task.resolve(option);
-  TaskMaybe2.fromNullable = (value) => Task.resolve(Maybe.fromNullable(value));
-  TaskMaybe2.fromResult = (result) => Task.resolve(Result.toMaybe(result));
-  TaskMaybe2.fromTask = (task) => Task.map(Maybe.some)(task);
-  TaskMaybe2.tryCatch = (f) => Task.from((signal) => f(signal).then(Maybe.some).catch(() => Maybe.none()));
-  TaskMaybe2.map = (f) => (data) => Task.map(Maybe.map(f))(data);
-  TaskMaybe2.chain = (f) => (data) => Task.chain((option) => Maybe.isSome(option) ? f(option.value) : Task.resolve(Maybe.none()))(data);
-  TaskMaybe2.ap = (arg) => (data) => Task.from(
-    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
-      ([of_, oa]) => Maybe.ap(oa)(of_)
-    )
-  );
-  TaskMaybe2.fold = (onNone, onSome) => (data) => Task.map(Maybe.fold(onNone, onSome))(data);
-  TaskMaybe2.match = (cases) => (data) => Task.map(Maybe.match(cases))(data);
-  TaskMaybe2.getOrElse = (defaultValue) => (data) => Task.map(Maybe.getOrElse(defaultValue))(data);
-  TaskMaybe2.tap = (f) => (data) => Task.map(Maybe.tap(f))(data);
-  TaskMaybe2.filter = (predicate) => (data) => Task.map(Maybe.filter(predicate))(data);
-  TaskMaybe2.toTaskResult = (onNone) => (data) => Task.map(Maybe.toResult(onNone))(data);
-  TaskMaybe2.bindTo = (key) => (data) => (0, TaskMaybe2.map)((a) => ({ [key]: a }))(data);
-  TaskMaybe2.bind = (key, f) => (data) => (0, TaskMaybe2.chain)(
-    (a) => (0, TaskMaybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
-  )(data);
-})(TaskMaybe || (TaskMaybe = {}));
-
-// src/Core/TaskResult.ts
-var TaskResult3;
-((TaskResult4) => {
-  TaskResult4.ok = (value) => Task.resolve(Result.ok(value));
-  TaskResult4.err = (error) => Task.resolve(Result.err(error));
-  TaskResult4.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.err(onNull()) : Result.ok(value));
-  TaskResult4.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Result.err(onNone()) : Result.ok(maybe.value));
-  TaskResult4.fromResult = (result) => Task.resolve(result);
-  TaskResult4.fromThrowable = (f, onError) => (...args) => Task.from(() => f(...args).then(Result.ok).catch((error) => Result.err(onError(error))));
-  TaskResult4.tryCatch = (f, onError) => Task.from((signal) => f(signal).then(Result.ok).catch((error) => Result.err(onError(error))));
-  TaskResult4.map = (f) => (data) => Task.map(Result.map(f))(data);
-  TaskResult4.mapError = (f) => (data) => Task.map(Result.mapError(f))(data);
-  TaskResult4.chain = (f) => (data) => Task.chain((result) => Result.isOk(result) ? f(result.value) : Task.resolve(Result.err(result.error)))(
-    data
-  );
-  TaskResult4.fold = (onErr, onOk) => (data) => Task.map(Result.fold(onErr, onOk))(data);
-  TaskResult4.match = (cases) => (data) => Task.map(Result.match(cases))(data);
-  TaskResult4.recover = (fallback) => (data) => Task.chain(
-    (result) => Result.isErr(result) ? fallback(result.error) : Task.resolve(result)
-  )(data);
-  TaskResult4.getOrElse = (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data);
-  TaskResult4.tap = (f) => (data) => Task.map(Result.tap(f))(data);
-  TaskResult4.tapError = (f) => (data) => Task.map(Result.tapError(f))(data);
-  TaskResult4.ap = (arg) => (data) => Task.from(
-    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
-      ([of_, oa]) => Result.ap(oa)(of_)
-    )
-  );
-  TaskResult4.run = (signal) => (task) => task(signal);
-  TaskResult4.bindTo = (key) => (data) => (0, TaskResult4.map)((a) => ({ [key]: a }))(data);
-  TaskResult4.bind = (key, f) => (data) => (0, TaskResult4.chain)(
-    (a) => (0, TaskResult4.map)((b) => ({ ...a, [key]: b }))(f(a))
-  )(data);
-  TaskResult4.struct = (fields) => Task.from((signal) => {
-    const keys = Object.keys(fields);
-    const promises = keys.map((key) => Deferred.toPromise(fields[key](signal)));
-    return Promise.all(promises).then((results) => {
-      const record = {};
-      for (let i = 0; i < keys.length; i++) {
-        const res = results[i];
-        if (Result.isErr(res)) {
-          return res;
-        }
-        record[keys[i]] = res.value;
-      }
-      return Result.ok(record);
-    });
-  });
-})(TaskResult3 || (TaskResult3 = {}));
-
-// src/Core/TaskValidation.ts
-var TaskValidation;
-((TaskValidation2) => {
-  TaskValidation2.passed = (value) => Task.resolve(Validation.passed(value));
-  TaskValidation2.failed = (error) => Task.resolve(Validation.failed(error));
-  TaskValidation2.failedAll = (errors) => Task.resolve(Validation.failedAll(errors));
-  TaskValidation2.fromValidation = (validation) => Task.resolve(validation);
-  TaskValidation2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Validation.failed(onNull()) : Validation.passed(value));
-  TaskValidation2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Validation.failed(onNone()) : Validation.passed(maybe.value));
-  TaskValidation2.fromResult = (result) => Task.resolve(Validation.fromResult(result));
-  TaskValidation2.tryCatch = (f, onError) => Task.from((signal) => f(signal).then(Validation.passed).catch((error) => Validation.failed(onError(error))));
-  TaskValidation2.map = (f) => (data) => Task.map(Validation.map(f))(data);
-  TaskValidation2.ap = (arg) => (data) => Task.from(
-    (signal) => Promise.all([Deferred.toPromise(data(signal)), Deferred.toPromise(arg(signal))]).then(
-      ([vf, va]) => Validation.ap(va)(vf)
-    )
-  );
-  TaskValidation2.fold = (onFailed, onPassed) => (data) => Task.map(Validation.fold(onFailed, onPassed))(data);
-  TaskValidation2.match = (cases) => (data) => Task.map(Validation.match(cases))(data);
-  TaskValidation2.getOrElse = (defaultValue) => (data) => Task.map(Validation.getOrElse(defaultValue))(data);
-  TaskValidation2.tap = (f) => (data) => Task.map(Validation.tap(f))(data);
-  TaskValidation2.recover = (fallback) => (data) => Task.chain(
-    (validation) => Validation.isPassed(validation) ? Task.resolve(validation) : fallback(validation.errors)
-  )(data);
-  TaskValidation2.product = (first, second) => Task.from(
-    (signal) => Promise.all([Deferred.toPromise(first(signal)), Deferred.toPromise(second(signal))]).then(
-      ([va, vb]) => Validation.product(va, vb)
-    )
-  );
-  TaskValidation2.productAll = (data) => Task.from(
-    (signal) => Promise.all(data.map((t) => Deferred.toPromise(t(signal)))).then(
-      (results) => Validation.productAll(results)
-    )
-  );
-})(TaskValidation || (TaskValidation = {}));
-
 // src/Core/These.ts
 var These;
 ((These2) => {
@@ -2026,11 +2072,10 @@ var Validation;
   Validation2.map = (f) => (data) => (0, Validation2.isPassed)(data) ? (0, Validation2.passed)(f(data.value)) : data;
   Validation2.mapError = (f) => (data) => (0, Validation2.isFailed)(data) ? (0, Validation2.failedAll)(data.errors.map(f)) : data;
   Validation2.ap = (arg) => (data) => {
-    if ((0, Validation2.isPassed)(data) && (0, Validation2.isPassed)(arg)) {
-      return (0, Validation2.passed)(data.value(arg.value));
+    if ((0, Validation2.isPassed)(data)) {
+      return (0, Validation2.isPassed)(arg) ? (0, Validation2.passed)(data.value(arg.value)) : (0, Validation2.failedAll)(arg.errors);
     }
-    const errors = [...(0, Validation2.isFailed)(data) ? data.errors : [], ...(0, Validation2.isFailed)(arg) ? arg.errors : []];
-    return (0, Validation2.failedAll)(errors);
+    return (0, Validation2.isPassed)(arg) ? (0, Validation2.failedAll)(data.errors) : (0, Validation2.failedAll)([...data.errors, ...arg.errors]);
   };
   Validation2.fold = (onFailed, onPassed) => (data) => (0, Validation2.isPassed)(data) ? onPassed(data.value) : onFailed(data.errors);
   Validation2.match = (cases) => (data) => (0, Validation2.isPassed)(data) ? cases.passed(data.value) : cases.failed(data.errors);
@@ -2053,11 +2098,10 @@ var Validation;
   Validation2.toMaybe = (data) => (0, Validation2.isPassed)(data) ? Maybe.some(data.value) : Maybe.none();
   Validation2.fromResult = (data) => data.kind === "Ok" ? (0, Validation2.passed)(data.value) : (0, Validation2.failed)(data.error);
   Validation2.product = (first, second) => {
-    if ((0, Validation2.isPassed)(first) && (0, Validation2.isPassed)(second)) {
-      return (0, Validation2.passed)([first.value, second.value]);
+    if ((0, Validation2.isPassed)(first)) {
+      return (0, Validation2.isPassed)(second) ? (0, Validation2.passed)([first.value, second.value]) : (0, Validation2.failedAll)(second.errors);
     }
-    const errors = [...(0, Validation2.isFailed)(first) ? first.errors : [], ...(0, Validation2.isFailed)(second) ? second.errors : []];
-    return (0, Validation2.failedAll)(errors);
+    return (0, Validation2.isPassed)(second) ? (0, Validation2.failedAll)(first.errors) : (0, Validation2.failedAll)([...first.errors, ...second.errors]);
   };
   Validation2.productAll = (data) => {
     const values = [];
@@ -2069,7 +2113,7 @@ var Validation;
         errors.push(...v.errors);
       }
     }
-    return errors.length > 0 ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(values);
+    return isNonEmptyArr(errors) ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(values);
   };
   Validation2.struct = (fields) => {
     const record = {};
@@ -2084,7 +2128,7 @@ var Validation;
         }
       }
     }
-    return errors.length > 0 ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(record);
+    return isNonEmptyArr(errors) ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(record);
   };
 })(Validation || (Validation = {}));
 
@@ -2106,10 +2150,11 @@ export {
   Resource,
   Result,
   State,
-  Task,
   TaskMaybe,
-  TaskResult3 as TaskResult,
+  TaskResult,
+  isNonEmptyArr,
   TaskValidation,
+  Task,
   These,
   Tuple,
   Validation