@nlozgachev/pipelined 0.31.0 → 0.33.0

package/dist/core.js

@@ -20,12 +20,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/Core/index.ts
 var Core_exports = {};
 __export(Core_exports, {
+  Combinable: () => Combinable,
   Deferred: () => Deferred,
+  Equality: () => Equality,
+  Lazy: () => Lazy,
   Lens: () => Lens,
   Logged: () => Logged,
   Maybe: () => Maybe,
   Op: () => Op,
   Optional: () => Optional,
+  Ordering: () => Ordering,
   Predicate: () => Predicate,
   Reader: () => Reader,
   Refinement: () => Refinement,
@@ -43,65 +47,6 @@ __export(Core_exports, {
 });
 module.exports = __toCommonJS(Core_exports);
 
-// src/Core/Deferred.ts
-var Deferred;
-((Deferred2) => {
-  Deferred2.fromPromise = (p) => (
-    // eslint-disable-next-line unicorn/no-thenable -- Deferred is intentionally thenable; it is the mechanism that makes Task awaitable
-    { then: ((f) => p.then(f)) }
-  );
-  Deferred2.toPromise = (d) => new Promise((resolve) => d.then(resolve));
-})(Deferred || (Deferred = {}));
-
-// src/Core/Lens.ts
-var Lens;
-((Lens2) => {
-  Lens2.make = (get2, set2) => ({ get: get2, set: set2 });
-  Lens2.prop = () => (key) => (0, Lens2.make)(
-    (s) => s[key],
-    (a) => (s) => ({ ...s, [key]: a })
-  );
-  Lens2.get = (lens) => (s) => lens.get(s);
-  Lens2.set = (lens) => (a) => (s) => lens.set(a)(s);
-  Lens2.modify = (lens) => (f) => (s) => lens.set(f(lens.get(s)))(s);
-  Lens2.andThen = (inner) => (outer) => (0, Lens2.make)(
-    (s) => inner.get(outer.get(s)),
-    (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
-  );
-  Lens2.andThenOptional = (inner) => (outer) => ({
-    get: (s) => inner.get(outer.get(s)),
-    set: (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
-  });
-  Lens2.toOptional = (lens) => ({
-    get: (s) => ({ kind: "Some", value: lens.get(s) }),
-    set: lens.set
-  });
-})(Lens || (Lens = {}));
-
-// src/Core/Logged.ts
-var Logged;
-((Logged2) => {
-  Logged2.make = (value) => ({ value, log: [] });
-  Logged2.tell = (entry) => ({ value: void 0, log: [entry] });
-  Logged2.map = (f) => (data) => ({
-    value: f(data.value),
-    log: data.log
-  });
-  Logged2.chain = (f) => (data) => {
-    const next = f(data.value);
-    return { value: next.value, log: [...data.log, ...next.log] };
-  };
-  Logged2.ap = (arg) => (data) => ({
-    value: data.value(arg.value),
-    log: [...data.log, ...arg.log]
-  });
-  Logged2.tap = (f) => (data) => {
-    f(data.value);
-    return data;
-  };
-  Logged2.run = (data) => [data.value, data.log];
-})(Logged || (Logged = {}));
-
 // src/Core/Result.ts
 var Result;
 ((Result2) => {
@@ -131,6 +76,15 @@ var Result;
     return data;
   };
   Result2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result2.ok)(a) : (0, Result2.error)(onFalse(a));
+  Result2.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Result2.error)(onNull()) : (0, Result2.ok)(value);
+  Result2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Result2.error)(onNone()) : (0, Result2.ok)(maybe.value);
+  Result2.fromThrowable = (f, onError) => (...args) => {
+    try {
+      return (0, Result2.ok)(f(...args));
+    } catch (e) {
+      return (0, Result2.error)(onError(e));
+    }
+  };
   Result2.recover = (fallback) => (data) => (0, Result2.isOk)(data) ? data : fallback(data.error);
   Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isError)(data) && !isBlocked(data.error) ? fallback() : data;
   Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
@@ -165,6 +119,137 @@ var Maybe;
   Maybe2.ap = (arg) => (data) => (0, Maybe2.isSome)(data) && (0, Maybe2.isSome)(arg) ? (0, Maybe2.some)(data.value(arg.value)) : (0, Maybe2.none)();
 })(Maybe || (Maybe = {}));
 
+// src/Core/Combinable.ts
+var Combinable;
+((Combinable2) => {
+  Combinable2.string = {
+    empty: "",
+    combine: (b) => (a) => a + b
+  };
+  Combinable2.sum = {
+    empty: 0,
+    combine: (b) => (a) => a + b
+  };
+  Combinable2.product = {
+    empty: 1,
+    combine: (b) => (a) => a * b
+  };
+  Combinable2.all = {
+    empty: true,
+    combine: (b) => (a) => a && b
+  };
+  Combinable2.any = {
+    empty: false,
+    combine: (b) => (a) => a || b
+  };
+  Combinable2.array = () => ({
+    empty: [],
+    combine: (b) => (a) => [...a, ...b]
+  });
+  Combinable2.maybe = (inner) => ({
+    empty: Maybe.none(),
+    combine: (b) => (a) => Maybe.isNone(a) ? b : Maybe.isNone(b) ? a : Maybe.some(inner.combine(b.value)(a.value))
+  });
+  Combinable2.fold = (c) => (data) => data.reduce((acc, x) => c.combine(x)(acc), c.empty);
+})(Combinable || (Combinable = {}));
+
+// src/Core/Deferred.ts
+var Deferred;
+((Deferred2) => {
+  Deferred2.fromPromise = (p) => (
+    // eslint-disable-next-line unicorn/no-thenable -- Deferred is intentionally thenable; it is the mechanism that makes Task awaitable
+    { then: ((f) => p.then(f)) }
+  );
+  Deferred2.toPromise = (d) => new Promise((resolve) => d.then(resolve));
+})(Deferred || (Deferred = {}));
+
+// src/Core/Equality.ts
+var Equality;
+((Equality2) => {
+  Equality2.string = (a, b) => a === b;
+  Equality2.number = (a, b) => a === b;
+  Equality2.boolean = (a, b) => a === b;
+  Equality2.date = (a, b) => a.getTime() === b.getTime();
+  Equality2.array = (eq) => (a, b) => a.length === b.length && a.every((x, i) => eq(x, b[i]));
+  Equality2.by = (f) => (eq) => (a, b) => eq(f(a), f(b));
+  Equality2.and = (eq2) => (eq1) => (a, b) => eq1(a, b) && eq2(a, b);
+})(Equality || (Equality = {}));
+
+// src/Core/Lazy.ts
+var Lazy;
+((Lazy2) => {
+  Lazy2.from = (f) => {
+    let done = false;
+    let cache;
+    return {
+      get: () => {
+        if (!done) {
+          cache = f();
+          done = true;
+        }
+        return cache;
+      }
+    };
+  };
+  Lazy2.evaluate = (lazy) => lazy.get();
+  Lazy2.map = (f) => (lazy) => Lazy2.from(() => f(lazy.get()));
+  Lazy2.chain = (f) => (lazy) => Lazy2.from(() => f(lazy.get()).get());
+  Lazy2.tap = (f) => (lazy) => Lazy2.from(() => {
+    const v = lazy.get();
+    f(v);
+    return v;
+  });
+})(Lazy || (Lazy = {}));
+
+// src/Core/Lens.ts
+var Lens;
+((Lens2) => {
+  Lens2.make = (get2, set2) => ({ get: get2, set: set2 });
+  Lens2.prop = () => (key) => (0, Lens2.make)(
+    (s) => s[key],
+    (a) => (s) => ({ ...s, [key]: a })
+  );
+  Lens2.get = (lens) => (s) => lens.get(s);
+  Lens2.set = (lens) => (a) => (s) => lens.set(a)(s);
+  Lens2.modify = (lens) => (f) => (s) => lens.set(f(lens.get(s)))(s);
+  Lens2.andThen = (inner) => (outer) => (0, Lens2.make)(
+    (s) => inner.get(outer.get(s)),
+    (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
+  );
+  Lens2.andThenOptional = (inner) => (outer) => ({
+    get: (s) => inner.get(outer.get(s)),
+    set: (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s)
+  });
+  Lens2.toOptional = (lens) => ({
+    get: (s) => ({ kind: "Some", value: lens.get(s) }),
+    set: lens.set
+  });
+})(Lens || (Lens = {}));
+
+// src/Core/Logged.ts
+var Logged;
+((Logged2) => {
+  Logged2.make = (value) => ({ value, log: [] });
+  Logged2.tell = (entry) => ({ value: void 0, log: [entry] });
+  Logged2.map = (f) => (data) => ({
+    value: f(data.value),
+    log: data.log
+  });
+  Logged2.chain = (f) => (data) => {
+    const next = f(data.value);
+    return { value: next.value, log: [...data.log, ...next.log] };
+  };
+  Logged2.ap = (arg) => (data) => ({
+    value: data.value(arg.value),
+    log: [...data.log, ...arg.log]
+  });
+  Logged2.tap = (f) => (data) => {
+    f(data.value);
+    return data;
+  };
+  Logged2.run = (data) => [data.value, data.log];
+})(Logged || (Logged = {}));
+
 // src/internal/Op.util.ts
 var _abortedNil = { kind: "OpNil", reason: "aborted" };
 var _droppedNil = { kind: "OpNil", reason: "dropped" };
@@ -1167,6 +1252,20 @@ var Optional;
   );
 })(Optional || (Optional = {}));
 
+// src/Core/Ordering.ts
+var Ordering;
+((Ordering2) => {
+  Ordering2.string = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+  Ordering2.number = (a, b) => a - b;
+  Ordering2.date = (a, b) => a.getTime() - b.getTime();
+  Ordering2.reverse = (ord) => (a, b) => ord(b, a);
+  Ordering2.thenBy = (ord2) => (ord1) => (a, b) => {
+    const r = ord1(a, b);
+    return r !== 0 ? r : ord2(a, b);
+  };
+  Ordering2.by = (f) => (ord) => (a, b) => ord(f(a), f(b));
+})(Ordering || (Ordering = {}));
+
 // src/Core/Predicate.ts
 var Predicate;
 ((Predicate2) => {
@@ -1280,8 +1379,34 @@ var RemoteData;
   RemoteData2.filter = (pred, onFalse) => (data) => (0, RemoteData2.isSuccess)(data) ? pred(data.value) ? data : (0, RemoteData2.failure)(onFalse(data.value)) : data;
 })(RemoteData || (RemoteData = {}));
 
+// src/Types/Brand.ts
+var Brand;
+((Brand2) => {
+  Brand2.wrap = () => (value) => value;
+  Brand2.unwrap = (branded) => branded;
+})(Brand || (Brand = {}));
+
+// src/Types/Duration.ts
+var Duration;
+((Duration2) => {
+  const wrap = Brand.wrap();
+  Duration2.milliseconds = (ms) => wrap(ms);
+  Duration2.seconds = (s) => wrap(s * 1e3);
+  Duration2.minutes = (m) => wrap(m * 60 * 1e3);
+  Duration2.hours = (h) => wrap(h * 60 * 60 * 1e3);
+  Duration2.days = (d) => wrap(d * 24 * 60 * 60 * 1e3);
+  Duration2.toMilliseconds = (d) => Brand.unwrap(d);
+  Duration2.toSeconds = (d) => Brand.unwrap(d) / 1e3;
+  Duration2.toMinutes = (d) => Brand.unwrap(d) / (60 * 1e3);
+  Duration2.toHours = (d) => Brand.unwrap(d) / (60 * 60 * 1e3);
+  Duration2.toDays = (d) => Brand.unwrap(d) / (24 * 60 * 60 * 1e3);
+  Duration2.add = (other) => (self) => wrap(Brand.unwrap(self) + Brand.unwrap(other));
+  Duration2.subtract = (other) => (self) => wrap(Brand.unwrap(self) - Brand.unwrap(other));
+})(Duration || (Duration = {}));
+
 // src/Core/Task.ts
 var toPromise = (task, signal) => Deferred.toPromise(task(signal));
+var getMs = (ms) => typeof ms === "number" ? ms : Duration.toMilliseconds(ms);
 var Task;
 ((Task2) => {
   Task2.resolve = (value) => () => Deferred.fromPromise(Promise.resolve(value));
@@ -1305,60 +1430,169 @@ var Task;
     (signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))
   );
   Task2.delay = (ms) => (data) => (0, Task2.from)(
-    (signal) => new Promise(
-      (resolve2) => setTimeout(
-        () => toPromise(data, signal).then(resolve2),
-        ms
-      )
-    )
+    (signal) => new Promise((resolve2) => {
+      let timerId = void 0;
+      const onAbort = () => {
+        if (timerId !== void 0) {
+          clearTimeout(timerId);
+        }
+        resolve2(toPromise(data, signal));
+      };
+      if (signal) {
+        if (signal.aborted) {
+          return resolve2(toPromise(data, signal));
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      timerId = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve2(toPromise(data, signal));
+      }, getMs(ms));
+    })
   );
   Task2.repeat = (options) => (task) => (0, Task2.from)((signal) => {
     const { times, delay: ms } = options;
     if (times <= 0) return Promise.resolve([]);
     const results = [];
-    const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run2 = (left) => toPromise(task, signal).then((a) => {
-      results.push(a);
-      if (left <= 1) return results;
-      return wait().then(() => run2(left - 1));
-    });
+    const wait = () => {
+      if (signal?.aborted) return Promise.resolve();
+      return new Promise((r) => {
+        let timerId = void 0;
+        const onAbort = () => {
+          if (timerId !== void 0) {
+            clearTimeout(timerId);
+          }
+          r();
+        };
+        if (signal) {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        timerId = setTimeout(() => {
+          signal?.removeEventListener("abort", onAbort);
+          r();
+        }, getMs(ms || 0));
+      });
+    };
+    const run2 = (left) => {
+      if (signal?.aborted) {
+        return Promise.resolve(results);
+      }
+      return toPromise(task, signal).then((a) => {
+        results.push(a);
+        if (left <= 1 || signal?.aborted) return results;
+        return wait().then(() => run2(left - 1));
+      });
+    };
     return run2(times);
   });
   Task2.repeatUntil = (options) => (task) => (0, Task2.from)((signal) => {
     const { when: predicate, delay: ms, maxAttempts } = options;
-    const wait = () => ms !== void 0 && ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve();
-    const run2 = (attempt) => toPromise(task, signal).then((a) => {
-      if (predicate(a)) return a;
-      if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
-      return wait().then(() => run2(attempt + 1));
-    });
+    const wait = () => {
+      if (signal?.aborted) return Promise.resolve();
+      return new Promise((r) => {
+        let timerId = void 0;
+        const onAbort = () => {
+          if (timerId !== void 0) {
+            clearTimeout(timerId);
+          }
+          r();
+        };
+        if (signal) {
+          signal.addEventListener("abort", onAbort, { once: true });
+        }
+        timerId = setTimeout(() => {
+          signal?.removeEventListener("abort", onAbort);
+          r();
+        }, getMs(ms || 0));
+      });
+    };
+    const run2 = (attempt, lastValue) => {
+      if (signal?.aborted && lastValue !== void 0) {
+        return Promise.resolve(lastValue);
+      }
+      return toPromise(task, signal).then((a) => {
+        if (predicate(a)) return a;
+        if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
+        if (signal?.aborted) return a;
+        return wait().then(() => run2(attempt + 1, a));
+      });
+    };
     return run2(1);
   });
-  Task2.race = (tasks) => (0, Task2.from)((signal) => Promise.race(tasks.map((t) => toPromise(t, signal))));
+  Task2.race = (tasks) => {
+    if (tasks.length === 0) {
+      return () => Deferred.fromPromise(new Promise(() => {
+      }));
+    }
+    return (0, Task2.from)((outerSignal) => {
+      const controllers = tasks.map(() => new AbortController());
+      const onOuterAbort = () => {
+        for (const ctrl of controllers) ctrl.abort();
+      };
+      if (outerSignal) {
+        if (outerSignal.aborted) {
+          onOuterAbort();
+        } else {
+          outerSignal.addEventListener("abort", onOuterAbort, { once: true });
+        }
+      }
+      const promises = tasks.map((task, idx) => {
+        const ctrl = controllers[idx];
+        return toPromise(task, ctrl.signal).then((result) => {
+          for (let i = 0; i < controllers.length; i++) {
+            if (i !== idx) {
+              controllers[i].abort();
+            }
+          }
+          outerSignal?.removeEventListener("abort", onOuterAbort);
+          return result;
+        });
+      });
+      return Promise.race(promises);
+    });
+  };
+  Task2.sequence = (tasks) => (0, Task2.from)((signal) => Promise.all(tasks.map((t) => toPromise(t, signal))));
   Task2.sequential = (tasks) => (0, Task2.from)(async (signal) => {
     const results = [];
     for (const task of tasks) {
+      if (signal?.aborted) {
+        break;
+      }
       results.push(await toPromise(task, signal));
     }
     return results;
   });
   Task2.timeout = (ms, onTimeout) => (task) => (0, Task2.from)((outerSignal) => {
     const controller = new AbortController();
-    const onOuterAbort = () => controller.abort();
-    outerSignal?.addEventListener("abort", onOuterAbort, { once: true });
     let timerId;
+    const cleanUp = () => {
+      if (timerId !== void 0) {
+        clearTimeout(timerId);
+      }
+      outerSignal?.removeEventListener("abort", onOuterAbort);
+    };
+    const onOuterAbort = () => {
+      cleanUp();
+      controller.abort();
+    };
+    if (outerSignal) {
+      if (outerSignal.aborted) {
+        controller.abort();
+      } else {
+        outerSignal.addEventListener("abort", onOuterAbort, { once: true });
+      }
+    }
     return Promise.race([
       toPromise(task, controller.signal).then((a) => {
-        clearTimeout(timerId);
-        outerSignal?.removeEventListener("abort", onOuterAbort);
+        cleanUp();
         return Result.ok(a);
       }),
       new Promise((resolve2) => {
         timerId = setTimeout(() => {
           controller.abort();
-          outerSignal?.removeEventListener("abort", onOuterAbort);
+          cleanUp();
           resolve2(Result.error(onTimeout()));
-        }, ms);
+        }, getMs(ms));
       })
     ]);
   });
@@ -1392,28 +1626,33 @@ var Resource;
     release
   });
   Resource2.use = (f) => (resource) => Task.from(
-    () => Deferred.toPromise(resource.acquire()).then(async (acquired) => {
+    (signal) => Deferred.toPromise(resource.acquire(signal)).then(async (acquired) => {
       if (Result.isError(acquired)) return acquired;
       const a = acquired.value;
-      const usageResult = await Deferred.toPromise(f(a)());
-      await Deferred.toPromise(resource.release(a)());
-      return usageResult;
+      try {
+        const usageResult = await Deferred.toPromise(f(a)(signal));
+        return usageResult;
+      } finally {
+        await Deferred.toPromise(resource.release(a)(signal));
+      }
     })
   );
   Resource2.combine = (resourceA, resourceB) => ({
     acquire: Task.from(
-      () => Deferred.toPromise(resourceA.acquire()).then(async (acquiredA) => {
+      (signal) => Deferred.toPromise(resourceA.acquire(signal)).then(async (acquiredA) => {
         if (Result.isError(acquiredA)) return acquiredA;
         const a = acquiredA.value;
-        const acquiredB = await Deferred.toPromise(resourceB.acquire());
+        const acquiredB = await Deferred.toPromise(resourceB.acquire(signal));
         if (Result.isError(acquiredB)) {
-          await Deferred.toPromise(resourceA.release(a)());
+          await Deferred.toPromise(resourceA.release(a)(signal));
           return acquiredB;
         }
         return Result.ok([a, acquiredB.value]);
       })
     ),
-    release: ([a, b]) => Task.from(() => Deferred.toPromise(resourceB.release(b)()).then(() => Deferred.toPromise(resourceA.release(a)())))
+    release: ([a, b]) => Task.from(
+      (signal) => Deferred.toPromise(resourceB.release(b)(signal)).then(() => Deferred.toPromise(resourceA.release(a)(signal)))
+    )
   });
 })(Resource || (Resource = {}));
 
@@ -1454,16 +1693,18 @@ var TaskMaybe;
   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(
-    () => f().then(Maybe.some).catch(() => Maybe.none())
+    (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(
-    () => Promise.all([
-      Deferred.toPromise(data()),
-      Deferred.toPromise(arg())
+    (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);
@@ -1479,6 +1720,12 @@ var TaskResult;
 ((TaskResult2) => {
   TaskResult2.ok = (value) => Task.resolve(Result.ok(value));
   TaskResult2.err = (error) => Task.resolve(Result.error(error));
+  TaskResult2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.error(onNull()) : Result.ok(value));
+  TaskResult2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Result.error(onNone()) : Result.ok(maybe.value));
+  TaskResult2.fromResult = (result) => Task.resolve(result);
+  TaskResult2.fromThrowable = (f, onError) => (...args) => Task.from(
+    () => f(...args).then(Result.ok).catch((e) => Result.error(onError(e)))
+  );
   TaskResult2.tryCatch = (f, onError) => Task.from(
     (signal) => f(signal).then(Result.ok).catch((e) => Result.error(onError(e)))
   );
@@ -1497,6 +1744,12 @@ var TaskResult;
   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) => Deferred.toPromise(task(signal));
 })(TaskResult || (TaskResult = {}));
 
@@ -1518,6 +1771,8 @@ var Validation;
   Validation2.isValid = (data) => data.kind === "Valid";
   Validation2.isInvalid = (data) => data.kind === "Invalid";
   Validation2.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Validation2.valid)(a) : (0, Validation2.invalid)(onFalse(a));
+  Validation2.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Validation2.invalid)(onNull()) : (0, Validation2.valid)(value);
+  Validation2.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Validation2.invalid)(onNone()) : (0, Validation2.valid)(maybe.value);
   Validation2.map = (f) => (data) => (0, Validation2.isValid)(data) ? (0, Validation2.valid)(f(data.value)) : data;
   Validation2.ap = (arg) => (data) => {
     if ((0, Validation2.isValid)(data) && (0, Validation2.isValid)(arg)) return (0, Validation2.valid)(data.value(arg.value));
@@ -1569,14 +1824,17 @@ var TaskValidation;
   TaskValidation2.invalid = (error) => Task.resolve(Validation.invalid(error));
   TaskValidation2.invalidAll = (errors) => Task.resolve(Validation.invalidAll(errors));
   TaskValidation2.fromValidation = (validation) => Task.resolve(validation);
+  TaskValidation2.fromNullable = (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Validation.invalid(onNull()) : Validation.valid(value));
+  TaskValidation2.fromMaybe = (onNone) => (maybe) => Task.resolve(Maybe.isNone(maybe) ? Validation.invalid(onNone()) : Validation.valid(maybe.value));
+  TaskValidation2.fromResult = (result) => Task.resolve(Validation.fromResult(result));
   TaskValidation2.tryCatch = (f, onError) => Task.from(
-    () => f().then(Validation.valid).catch((e) => Validation.invalid(onError(e)))
+    (signal) => f(signal).then(Validation.valid).catch((e) => Validation.invalid(onError(e)))
   );
   TaskValidation2.map = (f) => (data) => Task.map(Validation.map(f))(data);
   TaskValidation2.ap = (arg) => (data) => Task.from(
-    () => Promise.all([
-      Deferred.toPromise(data()),
-      Deferred.toPromise(arg())
+    (signal) => Promise.all([
+      Deferred.toPromise(data(signal)),
+      Deferred.toPromise(arg(signal))
     ]).then(([vf, va]) => Validation.ap(va)(vf))
   );
   TaskValidation2.fold = (onInvalid, onValid) => (data) => Task.map(Validation.fold(onInvalid, onValid))(data);
@@ -1587,13 +1845,13 @@ var TaskValidation;
     (validation) => Validation.isValid(validation) ? Task.resolve(validation) : fallback(validation.errors)
   )(data);
   TaskValidation2.product = (first, second) => Task.from(
-    () => Promise.all([
-      Deferred.toPromise(first()),
-      Deferred.toPromise(second())
+    (signal) => Promise.all([
+      Deferred.toPromise(first(signal)),
+      Deferred.toPromise(second(signal))
     ]).then(([va, vb]) => Validation.product(va, vb))
   );
   TaskValidation2.productAll = (data) => Task.from(
-    () => Promise.all(data.map((t) => Deferred.toPromise(t()))).then((results) => Validation.productAll(results))
+    (signal) => Promise.all(data.map((t) => Deferred.toPromise(t(signal)))).then((results) => Validation.productAll(results))
   );
 })(TaskValidation || (TaskValidation = {}));
 
@@ -1680,12 +1938,16 @@ var Tuple;
 })(Tuple || (Tuple = {}));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Combinable,
   Deferred,
+  Equality,
+  Lazy,
   Lens,
   Logged,
   Maybe,
   Op,
   Optional,
+  Ordering,
   Predicate,
   Reader,
   Refinement,

package/dist/core.mjs

@@ -1,8 +1,12 @@
 import {
+  Combinable,
+  Equality,
+  Lazy,
   Lens,
   Logged,
   Op,
   Optional,
+  Ordering,
   Predicate,
   Reader,
   Refinement,
@@ -15,20 +19,25 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-VIC54JR4.mjs";
+} from "./chunk-FZX4MTRI.mjs";
 import {
   Deferred,
   Maybe,
   Result,
   Task
-} from "./chunk-SDGDJ7CU.mjs";
+} from "./chunk-GSTKY7MF.mjs";
+import "./chunk-VWVPHDZO.mjs";
 export {
+  Combinable,
   Deferred,
+  Equality,
+  Lazy,
   Lens,
   Logged,
   Maybe,
   Op,
   Optional,
+  Ordering,
   Predicate,
   Reader,
   Refinement,