@nlozgachev/pipelined 0.41.0 → 0.43.0

package/dist/utils.js

@@ -111,74 +111,227 @@ 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;
-
 // src/Core/Result.ts
 var Result;
-((Result2) => {
-  Result2.ok = (value) => ({ kind: "Ok", value });
-  Result2.err = (e) => ({ kind: "Err", error: e });
-  Result2.isOk = (data) => data.kind === "Ok";
-  Result2.isErr = (data) => data.kind === "Err";
-  Result2.tryCatch = (f, onError) => {
+((Result3) => {
+  Result3.ok = (value) => ({ kind: "Ok", value });
+  Result3.err = (e) => ({ kind: "Err", error: e });
+  Result3.isOk = (data) => data.kind === "Ok";
+  Result3.isErr = (data) => data.kind === "Err";
+  Result3.tryCatch = (f, onError) => {
     try {
-      return (0, Result2.ok)(f());
+      return (0, Result3.ok)(f());
     } catch (error) {
-      return (0, Result2.err)(onError(error));
+      return (0, Result3.err)(onError(error));
     }
   };
-  Result2.map = (f) => (data) => (0, Result2.isOk)(data) ? (0, Result2.ok)(f(data.value)) : data;
-  Result2.mapError = (f) => (data) => (0, Result2.isErr)(data) ? (0, Result2.err)(f(data.error)) : data;
-  Result2.chain = (f) => (data) => (0, Result2.isOk)(data) ? f(data.value) : data;
-  Result2.fold = (onErr, onOk) => (data) => (0, Result2.isOk)(data) ? onOk(data.value) : onErr(data.error);
-  Result2.match = (cases) => (data) => (0, Result2.isOk)(data) ? cases.ok(data.value) : cases.err(data.error);
-  Result2.getOrElse = (defaultValue) => (data) => (0, Result2.isOk)(data) ? data.value : defaultValue();
-  Result2.tap = (f) => (data) => {
-    if ((0, Result2.isOk)(data)) {
+  Result3.map = (f) => (data) => (0, Result3.isOk)(data) ? (0, Result3.ok)(f(data.value)) : data;
+  Result3.mapError = (f) => (data) => (0, Result3.isErr)(data) ? (0, Result3.err)(f(data.error)) : data;
+  Result3.chain = (f) => (data) => (0, Result3.isOk)(data) ? f(data.value) : data;
+  Result3.fold = (onErr, onOk) => (data) => (0, Result3.isOk)(data) ? onOk(data.value) : onErr(data.error);
+  Result3.match = (cases) => (data) => (0, Result3.isOk)(data) ? cases.ok(data.value) : cases.err(data.error);
+  Result3.getOrElse = (defaultValue) => (data) => (0, Result3.isOk)(data) ? data.value : defaultValue();
+  Result3.tap = (f) => (data) => {
+    if ((0, Result3.isOk)(data)) {
       f(data.value);
     }
     return data;
   };
-  Result2.tapError = (f) => (data) => {
-    if ((0, Result2.isErr)(data)) {
+  Result3.tapError = (f) => (data) => {
+    if ((0, Result3.isErr)(data)) {
       f(data.error);
     }
     return data;
   };
-  Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.err)(onFalse(a));
-  Result2.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Result2.err)(onNull()) : (0, Result2.ok)(value);
-  Result2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Result2.err)(onNone()) : (0, Result2.ok)(maybe.value);
-  Result2.fromThrowable = (f, onError) => (...args) => {
+  Result3.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result3.ok)(a) : (0, Result3.err)(onFalse(a));
+  Result3.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Result3.err)(onNull()) : (0, Result3.ok)(value);
+  Result3.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Result3.err)(onNone()) : (0, Result3.ok)(maybe.value);
+  Result3.fromThrowable = (f, onError) => (...args) => {
     try {
-      return (0, Result2.ok)(f(...args));
+      return (0, Result3.ok)(f(...args));
     } catch (error) {
-      return (0, Result2.err)(onError(error));
+      return (0, Result3.err)(onError(error));
     }
   };
-  Result2.recover = (fallback) => (data) => (0, Result2.isOk)(data) ? data : fallback(data.error);
-  Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
-  Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
-  Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isErr)(data) ? data : arg;
-  Result2.bindTo = (key) => (data) => (0, Result2.map)((a) => ({ [key]: a }))(data);
-  Result2.bind = (key, f) => (data) => (0, Result2.chain)(
-    (a) => (0, Result2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  Result3.recover = (fallback) => (data) => (0, Result3.isOk)(data) ? data : fallback(data.error);
+  Result3.recoverUnless = (isBlocked, fallback) => (data) => (0, Result3.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
+  Result3.toMaybe = (data) => (0, Result3.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
+  Result3.ap = (arg) => (data) => (0, Result3.isOk)(data) && (0, Result3.isOk)(arg) ? (0, Result3.ok)(data.value(arg.value)) : (0, Result3.isErr)(data) ? data : arg;
+  Result3.bindTo = (key) => (data) => (0, Result3.map)((a) => ({ [key]: a }))(data);
+  Result3.bind = (key, f) => (data) => (0, Result3.chain)(
+    (a) => (0, Result3.map)((b) => ({ ...a, [key]: b }))(f(a))
   )(data);
-  Result2.struct = (fields) => {
+  Result3.struct = (fields) => {
     const result = {};
     for (const key in fields) {
       if (Object.hasOwn(fields, key)) {
         const res = fields[key];
-        if ((0, Result2.isErr)(res)) {
+        if ((0, Result3.isErr)(res)) {
           return res;
         }
         result[key] = res.value;
       }
     }
-    return (0, Result2.ok)(result);
+    return (0, Result3.ok)(result);
   };
 })(Result || (Result = {}));
 
+// 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 getMs = (duration) => Duration.toMilliseconds(duration);
@@ -203,9 +356,7 @@ var Task;
     (signal) => new Promise((res) => {
       let timerId;
       const onAbort = () => {
-        if (timerId !== void 0) {
-          clearTimeout(timerId);
-        }
+        clearTimeout(timerId);
         res(toPromise(data, signal));
       };
       if (signal) {
@@ -226,27 +377,20 @@ var Task;
       return Promise.resolve([]);
     }
     const results = [];
-    const wait = () => {
-      if (signal?.aborted) {
-        return Promise.resolve();
+    const wait = () => new Promise((r) => {
+      let timerId;
+      const onAbort = () => {
+        clearTimeout(timerId);
+        r();
+      };
+      if (signal) {
+        signal.addEventListener("abort", onAbort, { once: true });
       }
-      return new Promise((r) => {
-        let timerId;
-        const onAbort = () => {
-          if (timerId !== void 0) {
-            clearTimeout(timerId);
-          }
-          r();
-        };
-        if (signal) {
-          signal.addEventListener("abort", onAbort, { once: true });
-        }
-        timerId = setTimeout(() => {
-          signal?.removeEventListener("abort", onAbort);
-          r();
-        }, delayDuration ? getMs(delayDuration) : 0);
-      });
-    };
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        r();
+      }, delayDuration ? getMs(delayDuration) : 0);
+    });
     const run2 = (left) => {
       if (signal?.aborted) {
         return Promise.resolve(results);
@@ -263,27 +407,20 @@ var Task;
   });
   Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
     const { when: predicate, delay: delayDuration, maxAttempts } = options;
-    const wait = () => {
-      if (signal?.aborted) {
-        return Promise.resolve();
+    const wait = () => new Promise((r) => {
+      let timerId;
+      const onAbort = () => {
+        clearTimeout(timerId);
+        r();
+      };
+      if (signal) {
+        signal.addEventListener("abort", onAbort, { once: true });
       }
-      return new Promise((r) => {
-        let timerId;
-        const onAbort = () => {
-          if (timerId !== void 0) {
-            clearTimeout(timerId);
-          }
-          r();
-        };
-        if (signal) {
-          signal.addEventListener("abort", onAbort, { once: true });
-        }
-        timerId = setTimeout(() => {
-          signal?.removeEventListener("abort", onAbort);
-          r();
-        }, delayDuration ? getMs(delayDuration) : 0);
-      });
-    };
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        r();
+      }, delayDuration ? getMs(delayDuration) : 0);
+    });
     const run2 = (attempt, lastValue) => {
       if (signal?.aborted && lastValue !== void 0) {
         return Promise.resolve(lastValue);
@@ -351,16 +488,16 @@ var Task;
   Task2.timeout = (duration, onTimeout) => (task) => (0, Task2.from)((outerSignal) => {
     const controller = new AbortController();
     let timerId;
-    function cleanUp() {
-      if (timerId !== void 0) {
-        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();
@@ -405,9 +542,148 @@ 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/Validation.ts
+var Validation;
+((Validation2) => {
+  Validation2.passed = (value) => ({ kind: "Passed", value });
+  Validation2.failed = (error) => ({ kind: "Failed", errors: [error] });
+  Validation2.failedAll = (errors) => ({ kind: "Failed", errors });
+  Validation2.isPassed = (data) => data.kind === "Passed";
+  Validation2.isFailed = (data) => data.kind === "Failed";
+  Validation2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Validation2.passed)(a) : (0, Validation2.failed)(onFalse(a));
+  Validation2.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Validation2.failed)(onNull()) : (0, Validation2.passed)(value);
+  Validation2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Validation2.failed)(onNone()) : (0, Validation2.passed)(maybe.value);
+  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)) {
+      return (0, Validation2.isPassed)(arg) ? (0, Validation2.passed)(data.value(arg.value)) : (0, Validation2.failedAll)(arg.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);
+  Validation2.getOrElse = (defaultValue) => (data) => (0, Validation2.isPassed)(data) ? data.value : defaultValue();
+  Validation2.tap = (f) => (data) => {
+    if ((0, Validation2.isPassed)(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Validation2.tapError = (f) => (data) => {
+    if ((0, Validation2.isFailed)(data)) {
+      f(data.errors);
+    }
+    return data;
+  };
+  Validation2.recover = (fallback) => (data) => (0, Validation2.isPassed)(data) ? data : fallback(data.errors);
+  Validation2.recoverUnless = (isBlocked, fallback) => (data) => (0, Validation2.isFailed)(data) && !data.errors.some(isBlocked) ? fallback() : data;
+  Validation2.toResult = (data) => (0, Validation2.isPassed)(data) ? Result.ok(data.value) : Result.err(data.errors);
+  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)) {
+      return (0, Validation2.isPassed)(second) ? (0, Validation2.passed)([first.value, second.value]) : (0, Validation2.failedAll)(second.errors);
+    }
+    return (0, Validation2.isPassed)(second) ? (0, Validation2.failedAll)(first.errors) : (0, Validation2.failedAll)([...first.errors, ...second.errors]);
+  };
+  Validation2.productAll = (data) => {
+    const values = [];
+    const errors = [];
+    for (const v of data) {
+      if ((0, Validation2.isPassed)(v)) {
+        values.push(v.value);
+      } else {
+        errors.push(...v.errors);
+      }
+    }
+    return isNonEmptyArr(errors) ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(values);
+  };
+  Validation2.struct = (fields) => {
+    const record = {};
+    const errors = [];
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const val = fields[key];
+        if ((0, Validation2.isPassed)(val)) {
+          record[key] = val.value;
+        } else {
+          errors.push(...val.errors);
+        }
+      }
+    }
+    return isNonEmptyArr(errors) ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(record);
+  };
+})(Validation || (Validation = {}));
+
 // 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();
@@ -581,6 +857,7 @@ var Arr;
     }
     return result;
   };
+  Arr2.concat = (other) => (data) => [...data, ...other];
   Arr2.chunksOf = (n) => (data) => {
     if (n <= 0) {
       return [];
@@ -621,47 +898,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;
@@ -737,6 +979,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
@@ -946,25 +1189,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,
@@ -974,27 +1270,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;
@@ -1071,6 +1372,9 @@ var Rec;
     }
     return result;
   };
+  Rec2.Maybe = RecMaybe;
+  Rec2.Result = RecResult;
+  Rec2.NonEmpty = RecNonEmpty;
 })(Rec || (Rec = {}));
 
 // src/Data/Str.ts