@nlozgachev/pipelined 0.36.0 → 0.37.1

package/dist/index.js

@@ -46,7 +46,7 @@ __export(src_exports, {
   Str: () => Str,
   Task: () => Task,
   TaskMaybe: () => TaskMaybe,
-  TaskResult: () => TaskResult,
+  TaskResult: () => TaskResult3,
   TaskValidation: () => TaskValidation,
   These: () => These,
   Tuple: () => Tuple,
@@ -417,84 +417,6 @@ function uncurry(f) {
 var uncurry3 = (f) => (a, b, c) => f(a)(b)(c);
 var uncurry4 = (f) => (a, b, c, d) => f(a)(b)(c)(d);
 
-// 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) => {
-    try {
-      return (0, Result2.ok)(f());
-    } catch (error) {
-      return (0, Result2.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)) {
-      f(data.value);
-    }
-    return data;
-  };
-  Result2.tapError = (f) => (data) => {
-    if ((0, Result2.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) => {
-    try {
-      return (0, Result2.ok)(f(...args));
-    } catch (error) {
-      return (0, Result2.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;
-})(Result || (Result = {}));
-
-// src/Core/Maybe.ts
-var _none = { kind: "None" };
-var Maybe;
-((Maybe2) => {
-  Maybe2.some = (value) => ({ kind: "Some", value });
-  Maybe2.isSome = (data) => data.kind === "Some";
-  Maybe2.none = () => _none;
-  Maybe2.isNone = (data) => data.kind === "None";
-  Maybe2.fromNullable = (value) => value === null || value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
-  Maybe2.toNullable = (data) => (0, Maybe2.isSome)(data) ? data.value : null;
-  Maybe2.toUndefined = (data) => (0, Maybe2.isSome)(data) ? data.value : void 0;
-  Maybe2.fromPredicate = (pred) => (a) => pred(a) ? (0, Maybe2.some)(a) : (0, Maybe2.none)();
-  Maybe2.toResult = (onNone) => (data) => (0, Maybe2.isSome)(data) ? Result.ok(data.value) : Result.err(onNone());
-  Maybe2.fromResult = (data) => Result.isOk(data) ? (0, Maybe2.some)(data.value) : (0, Maybe2.none)();
-  Maybe2.map = (f) => (data) => (0, Maybe2.isSome)(data) ? (0, Maybe2.some)(f(data.value)) : data;
-  Maybe2.chain = (f) => (data) => (0, Maybe2.isSome)(data) ? f(data.value) : data;
-  Maybe2.fold = (onNone, onSome) => (data) => (0, Maybe2.isSome)(data) ? onSome(data.value) : onNone();
-  Maybe2.match = (cases) => (data) => (0, Maybe2.isSome)(data) ? cases.some(data.value) : cases.none();
-  Maybe2.getOrElse = (defaultValue) => (data) => (0, Maybe2.isSome)(data) ? data.value : defaultValue();
-  Maybe2.tap = (f) => (data) => {
-    if ((0, Maybe2.isSome)(data)) {
-      f(data.value);
-    }
-    return data;
-  };
-  Maybe2.filter = (predicate) => (data) => (0, Maybe2.isSome)(data) ? predicate(data.value) ? data : (0, Maybe2.none)() : data;
-  Maybe2.recover = (fallback) => (data) => (0, Maybe2.isSome)(data) ? data : fallback();
-  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) => {
@@ -523,14 +445,14 @@ var 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);
+((Equality3) => {
+  Equality3.string = (a, b) => a === b;
+  Equality3.number = (a, b) => a === b;
+  Equality3.boolean = (a, b) => a === b;
+  Equality3.date = (a, b) => a.getTime() === b.getTime();
+  Equality3.array = (eq) => (a, b) => a.length === b.length && a.every((x, i) => eq(x, b[i]));
+  Equality3.by = (f) => (eq) => (a, b) => eq(f(a), f(b));
+  Equality3.and = (eq2) => (eq1) => (a, b) => eq1(a, b) && eq2(a, b);
 })(Equality || (Equality = {}));
 
 // src/Core/Lazy.ts
@@ -561,18 +483,18 @@ var 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) => ({
+((Lens3) => {
+  Lens3.make = (get2, set2) => ({ get: get2, set: set2 });
+  Lens3.prop = () => (key) => (0, Lens3.make)((s) => s[key], (a) => (s) => ({ ...s, [key]: a }));
+  Lens3.get = (lens) => (s) => lens.get(s);
+  Lens3.set = (lens) => (a) => (s) => lens.set(a)(s);
+  Lens3.modify = (lens) => (f) => (s) => lens.set(f(lens.get(s)))(s);
+  Lens3.andThen = (inner) => (outer) => (0, Lens3.make)((s) => inner.get(outer.get(s)), (b) => (s) => outer.set(inner.set(b)(outer.get(s)))(s));
+  Lens3.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) => ({
+  Lens3.toOptional = (lens) => ({
     get: (s) => ({ kind: "Some", value: lens.get(s) }),
     set: lens.set
   });
@@ -600,8 +522,59 @@ var Logged;
     return data;
   };
   Logged2.run = (data) => [data.value, data.log];
+  Logged2.bindTo = (key) => (data) => (0, Logged2.map)((a) => ({ [key]: a }))(data);
+  Logged2.bind = (key, f) => (data) => (0, Logged2.chain)(
+    (a) => (0, Logged2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Logged || (Logged = {}));
 
+// src/Core/Maybe.ts
+var _none = { kind: "None" };
+var Maybe;
+((Maybe2) => {
+  Maybe2.some = (value) => ({ kind: "Some", value });
+  Maybe2.isSome = (data) => data.kind === "Some";
+  Maybe2.none = () => _none;
+  Maybe2.isNone = (data) => data.kind === "None";
+  Maybe2.fromNullable = (value) => value === null || value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
+  Maybe2.toNullable = (data) => (0, Maybe2.isSome)(data) ? data.value : null;
+  Maybe2.toUndefined = (data) => (0, Maybe2.isSome)(data) ? data.value : void 0;
+  Maybe2.fromPredicate = (pred) => (a) => pred(a) ? (0, Maybe2.some)(a) : (0, Maybe2.none)();
+  Maybe2.toResult = (onNone) => (data) => (0, Maybe2.isSome)(data) ? Result.ok(data.value) : Result.err(onNone());
+  Maybe2.fromResult = (data) => Result.isOk(data) ? (0, Maybe2.some)(data.value) : (0, Maybe2.none)();
+  Maybe2.map = (f) => (data) => (0, Maybe2.isSome)(data) ? (0, Maybe2.some)(f(data.value)) : data;
+  Maybe2.chain = (f) => (data) => (0, Maybe2.isSome)(data) ? f(data.value) : data;
+  Maybe2.fold = (onNone, onSome) => (data) => (0, Maybe2.isSome)(data) ? onSome(data.value) : onNone();
+  Maybe2.match = (cases) => (data) => (0, Maybe2.isSome)(data) ? cases.some(data.value) : cases.none();
+  Maybe2.getOrElse = (defaultValue) => (data) => (0, Maybe2.isSome)(data) ? data.value : defaultValue();
+  Maybe2.tap = (f) => (data) => {
+    if ((0, Maybe2.isSome)(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Maybe2.filter = (predicate) => (data) => (0, Maybe2.isSome)(data) ? predicate(data.value) ? data : (0, Maybe2.none)() : data;
+  Maybe2.recover = (fallback) => (data) => (0, Maybe2.isSome)(data) ? data : fallback();
+  Maybe2.ap = (arg) => (data) => (0, Maybe2.isSome)(data) && (0, Maybe2.isSome)(arg) ? (0, Maybe2.some)(data.value(arg.value)) : (0, Maybe2.none)();
+  Maybe2.bindTo = (key) => (data) => (0, Maybe2.map)((a) => ({ [key]: a }))(data);
+  Maybe2.bind = (key, f) => (data) => (0, Maybe2.chain)(
+    (a) => (0, Maybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  Maybe2.struct = (fields) => {
+    const result = {};
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const res = fields[key];
+        if ((0, Maybe2.isNone)(res)) {
+          return res;
+        }
+        result[key] = res.value;
+      }
+    }
+    return (0, Maybe2.some)(result);
+  };
+})(Maybe || (Maybe = {}));
+
 // src/Types/Brand.ts
 var Brand;
 ((Brand2) => {
@@ -627,6 +600,9 @@ 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/internal/Op.util.ts
 var _abortedNil = { kind: "OpNil", reason: "aborted" };
 var _droppedNil = { kind: "OpNil", reason: "dropped" };
@@ -1759,16 +1735,16 @@ var 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) => {
+((Ordering3) => {
+  Ordering3.string = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+  Ordering3.number = (a, b) => a - b;
+  Ordering3.date = (a, b) => a.getTime() - b.getTime();
+  Ordering3.reverse = (ord) => (a, b) => ord(b, a);
+  Ordering3.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));
+  Ordering3.by = (f) => (ord) => (a, b) => ord(f(a), f(b));
 })(Ordering || (Ordering = {}));
 
 // src/Core/Predicate.ts
@@ -1799,6 +1775,10 @@ var Reader;
   };
   Reader2.local = (f) => (data) => (env) => data(f(env));
   Reader2.run = (env) => (data) => data(env);
+  Reader2.bindTo = (key) => (data) => (0, Reader2.map)((a) => ({ [key]: a }))(data);
+  Reader2.bind = (key, f) => (data) => (0, Reader2.chain)(
+    (a) => (0, Reader2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Reader || (Reader = {}));
 
 // src/Core/Refinement.ts
@@ -1896,6 +1876,152 @@ 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/Core/Resource.ts
+var Resource;
+((Resource2) => {
+  Resource2.make = (acquire, release) => ({
+    acquire,
+    release
+  });
+  Resource2.fromTask = (acquire, release) => ({
+    acquire: Task.map((a) => Result.ok(a))(acquire),
+    release
+  });
+  Resource2.use = (f) => (resource) => Task.from(
+    (signal) => Deferred.toPromise(resource.acquire(signal)).then(async (acquired) => {
+      if (Result.isErr(acquired)) {
+        return acquired;
+      }
+      const a = acquired.value;
+      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(
+      (signal) => Deferred.toPromise(resourceA.acquire(signal)).then(async (acquiredA) => {
+        if (Result.isErr(acquiredA)) {
+          return acquiredA;
+        }
+        const a = acquiredA.value;
+        const acquiredB = await Deferred.toPromise(resourceB.acquire(signal));
+        if (Result.isErr(acquiredB)) {
+          await Deferred.toPromise(resourceA.release(a)(signal));
+          return acquiredB;
+        }
+        return Result.ok([a, acquiredB.value]);
+      })
+    ),
+    release: ([a, b]) => Task.from(
+      (signal) => Deferred.toPromise(resourceB.release(b)(signal)).then(() => Deferred.toPromise(resourceA.release(a)(signal)))
+    )
+  });
+})(Resource || (Resource = {}));
+
+// src/Core/Result.ts
+var Result;
+((Result4) => {
+  Result4.ok = (value) => ({ kind: "Ok", value });
+  Result4.err = (e) => ({ kind: "Err", error: e });
+  Result4.isOk = (data) => data.kind === "Ok";
+  Result4.isErr = (data) => data.kind === "Err";
+  Result4.tryCatch = (f, onError) => {
+    try {
+      return (0, Result4.ok)(f());
+    } catch (error) {
+      return (0, Result4.err)(onError(error));
+    }
+  };
+  Result4.map = (f) => (data) => (0, Result4.isOk)(data) ? (0, Result4.ok)(f(data.value)) : data;
+  Result4.mapError = (f) => (data) => (0, Result4.isErr)(data) ? (0, Result4.err)(f(data.error)) : data;
+  Result4.chain = (f) => (data) => (0, Result4.isOk)(data) ? f(data.value) : data;
+  Result4.fold = (onErr, onOk) => (data) => (0, Result4.isOk)(data) ? onOk(data.value) : onErr(data.error);
+  Result4.match = (cases) => (data) => (0, Result4.isOk)(data) ? cases.ok(data.value) : cases.err(data.error);
+  Result4.getOrElse = (defaultValue) => (data) => (0, Result4.isOk)(data) ? data.value : defaultValue();
+  Result4.tap = (f) => (data) => {
+    if ((0, Result4.isOk)(data)) {
+      f(data.value);
+    }
+    return data;
+  };
+  Result4.tapError = (f) => (data) => {
+    if ((0, Result4.isErr)(data)) {
+      f(data.error);
+    }
+    return data;
+  };
+  Result4.fromPredicate = (pred, onFalse) => (a) => pred(a) ? (0, Result4.ok)(a) : (0, Result4.err)(onFalse(a));
+  Result4.fromNullable = (onNull) => (value) => value === null || value === void 0 ? (0, Result4.err)(onNull()) : (0, Result4.ok)(value);
+  Result4.fromMaybe = (onNone) => (maybe) => Maybe.isNone(maybe) ? (0, Result4.err)(onNone()) : (0, Result4.ok)(maybe.value);
+  Result4.fromThrowable = (f, onError) => (...args) => {
+    try {
+      return (0, Result4.ok)(f(...args));
+    } catch (error) {
+      return (0, Result4.err)(onError(error));
+    }
+  };
+  Result4.recover = (fallback) => (data) => (0, Result4.isOk)(data) ? data : fallback(data.error);
+  Result4.recoverUnless = (isBlocked, fallback) => (data) => (0, Result4.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
+  Result4.toMaybe = (data) => (0, Result4.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
+  Result4.ap = (arg) => (data) => (0, Result4.isOk)(data) && (0, Result4.isOk)(arg) ? (0, Result4.ok)(data.value(arg.value)) : (0, Result4.isErr)(data) ? data : arg;
+  Result4.bindTo = (key) => (data) => (0, Result4.map)((a) => ({ [key]: a }))(data);
+  Result4.bind = (key, f) => (data) => (0, Result4.chain)(
+    (a) => (0, Result4.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+  Result4.struct = (fields) => {
+    const result = {};
+    for (const key in fields) {
+      if (Object.hasOwn(fields, key)) {
+        const res = fields[key];
+        if ((0, Result4.isErr)(res)) {
+          return res;
+        }
+        result[key] = res.value;
+      }
+    }
+    return (0, Result4.ok)(result);
+  };
+})(Result || (Result = {}));
+
+// src/Core/State.ts
+var State;
+((State2) => {
+  State2.resolve = (value) => (s) => [value, s];
+  State2.get = () => (s) => [s, s];
+  State2.gets = (f) => (s) => [f(s), s];
+  State2.put = (newState) => (_s) => [void 0, newState];
+  State2.modify = (f) => (s) => [void 0, f(s)];
+  State2.map = (f) => (st) => (s) => {
+    const [a, s1] = st(s);
+    return [f(a), s1];
+  };
+  State2.chain = (f) => (st) => (s) => {
+    const [a, s1] = st(s);
+    return f(a)(s1);
+  };
+  State2.ap = (arg) => (fn) => (s) => {
+    const [f, s1] = fn(s);
+    const [a, s2] = arg(s1);
+    return [f(a), s2];
+  };
+  State2.tap = (f) => (st) => (s) => {
+    const [a, s1] = st(s);
+    f(a);
+    return [a, s1];
+  };
+  State2.run = (initialState) => (st) => st(initialState);
+  State2.evaluate = (initialState) => (st) => st(initialState)[0];
+  State2.execute = (initialState) => (st) => st(initialState)[1];
+  State2.bindTo = (key) => (data) => (0, State2.map)((a) => ({ [key]: a }))(data);
+  State2.bind = (key, f) => (data) => (0, State2.chain)(
+    (a) => (0, State2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
+})(State || (State = {}));
+
 // src/Core/Task.ts
 var toPromise = (task, signal) => Deferred.toPromise(task(signal));
 var getMs2 = (duration) => Duration.toMilliseconds(duration);
@@ -2118,85 +2244,12 @@ var Task;
     return { task, abort };
   };
   Task2.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  Task2.bindTo = (key) => (data) => (0, Task2.map)((a) => ({ [key]: a }))(data);
+  Task2.bind = (key, f) => (data) => (0, Task2.chain)(
+    (a) => (0, Task2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Task || (Task = {}));
 
-// src/Core/Resource.ts
-var Resource;
-((Resource2) => {
-  Resource2.make = (acquire, release) => ({
-    acquire,
-    release
-  });
-  Resource2.fromTask = (acquire, release) => ({
-    acquire: Task.map((a) => Result.ok(a))(acquire),
-    release
-  });
-  Resource2.use = (f) => (resource) => Task.from(
-    (signal) => Deferred.toPromise(resource.acquire(signal)).then(async (acquired) => {
-      if (Result.isErr(acquired)) {
-        return acquired;
-      }
-      const a = acquired.value;
-      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(
-      (signal) => Deferred.toPromise(resourceA.acquire(signal)).then(async (acquiredA) => {
-        if (Result.isErr(acquiredA)) {
-          return acquiredA;
-        }
-        const a = acquiredA.value;
-        const acquiredB = await Deferred.toPromise(resourceB.acquire(signal));
-        if (Result.isErr(acquiredB)) {
-          await Deferred.toPromise(resourceA.release(a)(signal));
-          return acquiredB;
-        }
-        return Result.ok([a, acquiredB.value]);
-      })
-    ),
-    release: ([a, b]) => Task.from(
-      (signal) => Deferred.toPromise(resourceB.release(b)(signal)).then(() => Deferred.toPromise(resourceA.release(a)(signal)))
-    )
-  });
-})(Resource || (Resource = {}));
-
-// src/Core/State.ts
-var State;
-((State2) => {
-  State2.resolve = (value) => (s) => [value, s];
-  State2.get = () => (s) => [s, s];
-  State2.gets = (f) => (s) => [f(s), s];
-  State2.put = (newState) => (_s) => [void 0, newState];
-  State2.modify = (f) => (s) => [void 0, f(s)];
-  State2.map = (f) => (st) => (s) => {
-    const [a, s1] = st(s);
-    return [f(a), s1];
-  };
-  State2.chain = (f) => (st) => (s) => {
-    const [a, s1] = st(s);
-    return f(a)(s1);
-  };
-  State2.ap = (arg) => (fn) => (s) => {
-    const [f, s1] = fn(s);
-    const [a, s2] = arg(s1);
-    return [f(a), s2];
-  };
-  State2.tap = (f) => (st) => (s) => {
-    const [a, s1] = st(s);
-    f(a);
-    return [a, s1];
-  };
-  State2.run = (initialState) => (st) => st(initialState);
-  State2.evaluate = (initialState) => (st) => st(initialState)[0];
-  State2.execute = (initialState) => (st) => st(initialState)[1];
-})(State || (State = {}));
-
 // src/Core/TaskMaybe.ts
 var TaskMaybe;
 ((TaskMaybe2) => {
@@ -2220,99 +2273,63 @@ var TaskMaybe;
   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 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) => 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)))(
+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
   );
-  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(
+  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);
-  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(
+  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_)
     )
   );
-  TaskResult2.run = (signal) => (task) => Deferred.toPromise(task(signal));
-})(TaskResult || (TaskResult = {}));
-
-// 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) && (0, Validation2.isPassed)(arg)) {
-      return (0, Validation2.passed)(data.value(arg.value));
-    }
-    const errors = [...(0, Validation2.isFailed)(data) ? data.errors : [], ...(0, Validation2.isFailed)(arg) ? arg.errors : []];
-    return (0, Validation2.failedAll)(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) && (0, Validation2.isPassed)(second)) {
-      return (0, Validation2.passed)([first.value, second.value]);
-    }
-    const errors = [...(0, Validation2.isFailed)(first) ? first.errors : [], ...(0, Validation2.isFailed)(second) ? second.errors : []];
-    return (0, Validation2.failedAll)(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);
+  TaskResult4.run = (signal) => (task) => Deferred.toPromise(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)).then((res) => ({ key, res })));
+    return Promise.all(promises).then((results) => {
+      const record = {};
+      for (const key of keys) {
+        const found = results.find((r) => r.key === key);
+        if (found) {
+          if (Result.isErr(found.res)) {
+            return found.res;
+          }
+          record[key] = found.res.value;
+        }
       }
-    }
-    return errors.length > 0 ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(values);
-  };
-})(Validation || (Validation = {}));
+      return Result.ok(record);
+    });
+  });
+})(TaskResult3 || (TaskResult3 = {}));
 
 // src/Core/TaskValidation.ts
 var TaskValidation;
@@ -2458,8 +2475,81 @@ var Tuple;
   };
 })(Tuple || (Tuple = {}));
 
-// src/Types/NonEmptyList.ts
-var isNonEmptyList = (list) => list.length > 0;
+// 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) && (0, Validation2.isPassed)(arg)) {
+      return (0, Validation2.passed)(data.value(arg.value));
+    }
+    const errors = [...(0, Validation2.isFailed)(data) ? data.errors : [], ...(0, Validation2.isFailed)(arg) ? arg.errors : []];
+    return (0, Validation2.failedAll)(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) && (0, Validation2.isPassed)(second)) {
+      return (0, Validation2.passed)([first.value, second.value]);
+    }
+    const errors = [...(0, Validation2.isFailed)(first) ? first.errors : [], ...(0, Validation2.isFailed)(second) ? second.errors : []];
+    return (0, Validation2.failedAll)(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 errors.length > 0 ? (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 errors.length > 0 ? (0, Validation2.failedAll)(errors) : (0, Validation2.passed)(record);
+  };
+})(Validation || (Validation = {}));
 
 // src/Utils/Arr.ts
 var Arr;