@nlozgachev/pipekit 0.1.6 → 0.1.8

package/esm/src/Types/Brand.js

@@ -0,0 +1,28 @@
+export var Brand;
+(function (Brand) {
+    /**
+     * Creates a branding constructor for brand K over type T.
+     * The resulting function performs an unchecked cast — only use when the raw
+     * value is known to satisfy the brand's invariants.
+     *
+     * @example
+     * ```ts
+     * type PositiveNumber = Brand<"PositiveNumber", number>;
+     * const toPositiveNumber = Brand.make<"PositiveNumber", number>();
+     *
+     * const n: PositiveNumber = toPositiveNumber(42);
+     * ```
+     */
+    Brand.make = () => (value) => value;
+    /**
+     * Strips the brand and returns the underlying value.
+     * Since Brand<K, T> extends T this is rarely needed, but can improve readability.
+     *
+     * @example
+     * ```ts
+     * const userId: UserId = toUserId("user-123");
+     * const raw: string = Brand.unwrap(userId); // "user-123"
+     * ```
+     */
+    Brand.unwrap = (branded) => branded;
+})(Brand || (Brand = {}));

package/esm/src/Types/index.js

@@ -1 +1,2 @@
+export * from "./Brand.js";
 export * from "./NonEmptyList.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlozgachev/pipekit",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Simple functional programming toolkit for TypeScript",
   "keywords": [
     "functional",
@@ -9,6 +9,7 @@
     "composition",
     "pipe"
   ],
+  "homepage": "https://pipekit.lozgachev.dev",
   "repository": {
     "type": "git",
     "url": "https://github.com/nlozgachev/pipekit"

package/script/src/Core/TaskOption.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskOption = void 0;
+const Option_js_1 = require("./Option.js");
+const Task_js_1 = require("./Task.js");
+var TaskOption;
+(function (TaskOption) {
+    /**
+     * Wraps a value in a Some inside a Task.
+     */
+    TaskOption.of = (value) => Task_js_1.Task.of(Option_js_1.Option.of(value));
+    /**
+     * Creates a TaskOption that resolves to None.
+     */
+    TaskOption.none = () => Task_js_1.Task.of(Option_js_1.Option.toNone());
+    /**
+     * Lifts an Option into a TaskOption.
+     */
+    TaskOption.fromOption = (option) => Task_js_1.Task.of(option);
+    /**
+     * Lifts a Task into a TaskOption by wrapping its result in Some.
+     */
+    TaskOption.fromTask = (task) => Task_js_1.Task.map(Option_js_1.Option.of)(task);
+    /**
+     * Creates a TaskOption from a Promise-returning function.
+     * Returns Some if the promise resolves, None if it rejects.
+     *
+     * @example
+     * ```ts
+     * const fetchUser = TaskOption.tryCatch(() =>
+     *   fetch("/user/1").then(r => r.json())
+     * );
+     * ```
+     */
+    TaskOption.tryCatch = (f) => () => f().then(Option_js_1.Option.of).catch(() => Option_js_1.Option.toNone());
+    /**
+     * Transforms the value inside a TaskOption.
+     */
+    TaskOption.map = (f) => (data) => Task_js_1.Task.map(Option_js_1.Option.map(f))(data);
+    /**
+     * Chains TaskOption computations. If the first resolves to Some, passes the
+     * value to f. If the first resolves to None, propagates None.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   findUser("123"),
+     *   TaskOption.chain(user => findOrg(user.orgId))
+     * )();
+     * ```
+     */
+    TaskOption.chain = (f) => (data) => Task_js_1.Task.chain((option) => Option_js_1.Option.isSome(option) ? f(option.value) : Task_js_1.Task.of(Option_js_1.Option.toNone()))(data);
+    /**
+     * Applies a function wrapped in a TaskOption to a value wrapped in a TaskOption.
+     * Both Tasks run in parallel.
+     */
+    TaskOption.ap = (arg) => (data) => () => Promise.all([data(), arg()]).then(([of_, oa]) => Option_js_1.Option.ap(oa)(of_));
+    /**
+     * Extracts a value from a TaskOption by providing handlers for both cases.
+     */
+    TaskOption.fold = (onNone, onSome) => (data) => Task_js_1.Task.map(Option_js_1.Option.fold(onNone, onSome))(data);
+    /**
+     * Pattern matches on a TaskOption, returning a Task of the result.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   findUser("123"),
+     *   TaskOption.match({
+     *     some: user => `Hello, ${user.name}`,
+     *     none: () => "User not found"
+     *   })
+     * )();
+     * ```
+     */
+    TaskOption.match = (cases) => (data) => Task_js_1.Task.map(Option_js_1.Option.match(cases))(data);
+    /**
+     * Returns the value or a default if the TaskOption resolves to None.
+     */
+    TaskOption.getOrElse = (defaultValue) => (data) => Task_js_1.Task.map(Option_js_1.Option.getOrElse(defaultValue))(data);
+    /**
+     * Executes a side effect on the value without changing the TaskOption.
+     * Useful for logging or debugging.
+     */
+    TaskOption.tap = (f) => (data) => Task_js_1.Task.map(Option_js_1.Option.tap(f))(data);
+    /**
+     * Filters the value inside a TaskOption. Returns None if the predicate fails.
+     */
+    TaskOption.filter = (predicate) => (data) => Task_js_1.Task.map(Option_js_1.Option.filter(predicate))(data);
+    /**
+     * Converts a TaskOption to a TaskResult, using onNone to produce the error value.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   findUser("123"),
+     *   TaskOption.toTaskResult(() => "User not found")
+     * );
+     * ```
+     */
+    TaskOption.toTaskResult = (onNone) => (data) => Task_js_1.Task.map(Option_js_1.Option.toResult(onNone))(data);
+})(TaskOption || (exports.TaskOption = TaskOption = {}));

package/script/src/Core/TaskValidation.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskValidation = void 0;
+const Task_js_1 = require("./Task.js");
+const Validation_js_1 = require("./Validation.js");
+var TaskValidation;
+(function (TaskValidation) {
+    /**
+     * Wraps a value in a valid TaskValidation.
+     */
+    TaskValidation.of = (value) => Task_js_1.Task.of(Validation_js_1.Validation.of(value));
+    /**
+     * Creates a failed TaskValidation with a single error.
+     */
+    TaskValidation.fail = (error) => Task_js_1.Task.of(Validation_js_1.Validation.fail(error));
+    /**
+     * Lifts a Validation into a TaskValidation.
+     */
+    TaskValidation.fromValidation = (validation) => Task_js_1.Task.of(validation);
+    /**
+     * Creates a TaskValidation from a Promise-returning function.
+     * Catches any errors and transforms them using the onError function.
+     *
+     * @example
+     * ```ts
+     * const fetchUser = (id: string): TaskValidation<string, User> =>
+     *   TaskValidation.tryCatch(
+     *     () => fetch(`/users/${id}`).then(r => r.json()),
+     *     e => `Failed to fetch user: ${e}`
+     *   );
+     * ```
+     */
+    TaskValidation.tryCatch = (f, onError) => () => f()
+        .then((Validation_js_1.Validation.of))
+        .catch((e) => Validation_js_1.Validation.fail(onError(e)));
+    /**
+     * Transforms the success value inside a TaskValidation.
+     */
+    TaskValidation.map = (f) => (data) => Task_js_1.Task.map(Validation_js_1.Validation.map(f))(data);
+    /**
+     * Chains TaskValidation computations. If the first is Valid, passes the value
+     * to f. If the first is Invalid, propagates the errors.
+     *
+     * Note: chain short-circuits on first error. Use ap to accumulate errors.
+     */
+    TaskValidation.chain = (f) => (data) => Task_js_1.Task.chain((validation) => Validation_js_1.Validation.isValid(validation)
+        ? f(validation.value)
+        : Task_js_1.Task.of(Validation_js_1.Validation.toInvalid(validation.errors)))(data);
+    /**
+     * Applies a function wrapped in a TaskValidation to a value wrapped in a
+     * TaskValidation. Both Tasks run in parallel and errors from both sides
+     * are accumulated.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   TaskValidation.of((name: string) => (age: number) => ({ name, age })),
+     *   TaskValidation.ap(validateName(name)),
+     *   TaskValidation.ap(validateAge(age))
+     * )();
+     * ```
+     */
+    TaskValidation.ap = (arg) => (data) => () => Promise.all([data(), arg()]).then(([vf, va]) => Validation_js_1.Validation.ap(va)(vf));
+    /**
+     * Extracts a value from a TaskValidation by providing handlers for both cases.
+     */
+    TaskValidation.fold = (onInvalid, onValid) => (data) => Task_js_1.Task.map(Validation_js_1.Validation.fold(onInvalid, onValid))(data);
+    /**
+     * Pattern matches on a TaskValidation, returning a Task of the result.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   validateForm(input),
+     *   TaskValidation.match({
+     *     valid: data => save(data),
+     *     invalid: errors => showErrors(errors)
+     *   })
+     * )();
+     * ```
+     */
+    TaskValidation.match = (cases) => (data) => Task_js_1.Task.map(Validation_js_1.Validation.match(cases))(data);
+    /**
+     * Returns the success value or a default value if the TaskValidation is invalid.
+     */
+    TaskValidation.getOrElse = (defaultValue) => (data) => Task_js_1.Task.map(Validation_js_1.Validation.getOrElse(defaultValue))(data);
+    /**
+     * Executes a side effect on the success value without changing the TaskValidation.
+     * Useful for logging or debugging.
+     */
+    TaskValidation.tap = (f) => (data) => Task_js_1.Task.map(Validation_js_1.Validation.tap(f))(data);
+    /**
+     * Recovers from an Invalid state by providing a fallback TaskValidation.
+     */
+    TaskValidation.recover = (fallback) => (data) => Task_js_1.Task.chain((validation) => Validation_js_1.Validation.isValid(validation) ? Task_js_1.Task.of(validation) : fallback())(data);
+})(TaskValidation || (exports.TaskValidation = TaskValidation = {}));

package/script/src/Core/These.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.These = void 0;
+const Result_js_1 = require("./Result.js");
+var These;
+(function (These) {
+    /**
+     * Creates a These holding only an error/warning (no success value).
+     *
+     * @example
+     * ```ts
+     * These.toErr("Something went wrong");
+     * ```
+     */
+    These.toErr = (error) => Result_js_1.Result.toErr(error);
+    /**
+     * Creates a These holding only a success value (no error).
+     *
+     * @example
+     * ```ts
+     * These.toOk(42);
+     * ```
+     */
+    These.toOk = (value) => Result_js_1.Result.toOk(value);
+    /**
+     * Creates a These holding both an error/warning and a success value.
+     *
+     * @example
+     * ```ts
+     * These.toBoth("Deprecated API used", result);
+     * ```
+     */
+    These.toBoth = (error, value) => ({
+        kind: "Both",
+        error,
+        value,
+    });
+    /**
+     * Type guard — checks if a These holds only an error/warning.
+     */
+    These.isErr = (data) => data.kind === "Error";
+    /**
+     * Type guard — checks if a These holds only a success value.
+     */
+    These.isOk = (data) => data.kind === "Ok";
+    /**
+     * Type guard — checks if a These holds both an error/warning and a success value.
+     */
+    These.isBoth = (data) => data.kind === "Both";
+    /**
+     * Returns true if the These contains a success value (Ok or Both).
+     */
+    These.hasValue = (data) => data.kind === "Ok" || data.kind === "Both";
+    /**
+     * Returns true if the These contains an error/warning (Err or Both).
+     */
+    These.hasError = (data) => data.kind === "Error" || data.kind === "Both";
+    /**
+     * Transforms the success value, leaving the error unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(These.toOk(5), These.map(n => n * 2));          // Ok(10)
+     * pipe(These.toBoth("warn", 5), These.map(n => n * 2)); // Both("warn", 10)
+     * pipe(These.toErr("err"), These.map(n => n * 2));      // Err("err")
+     * ```
+     */
+    These.map = (f) => (data) => {
+        if (These.isErr(data))
+            return data;
+        if (These.isOk(data))
+            return These.toOk(f(data.value));
+        return These.toBoth(data.error, f(data.value));
+    };
+    /**
+     * Transforms the error/warning value, leaving the success value unchanged.
+     *
+     * @example
+     * ```ts
+     * pipe(These.toErr("err"), These.mapErr(e => e.toUpperCase()));         // Err("ERR")
+     * pipe(These.toBoth("warn", 5), These.mapErr(e => e.toUpperCase()));    // Both("WARN", 5)
+     * ```
+     */
+    These.mapErr = (f) => (data) => {
+        if (These.isOk(data))
+            return data;
+        if (These.isErr(data))
+            return These.toErr(f(data.error));
+        return These.toBoth(f(data.error), data.value);
+    };
+    /**
+     * Transforms both the error and success values independently.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   These.toBoth("warn", 5),
+     *   These.bimap(e => e.toUpperCase(), n => n * 2)
+     * ); // Both("WARN", 10)
+     * ```
+     */
+    These.bimap = (onErr, onOk) => (data) => {
+        if (These.isErr(data))
+            return These.toErr(onErr(data.error));
+        if (These.isOk(data))
+            return These.toOk(onOk(data.value));
+        return These.toBoth(onErr(data.error), onOk(data.value));
+    };
+    /**
+     * Chains These computations by passing the success value to f.
+     * - Err propagates unchanged.
+     * - Ok(a) applies f(a) directly.
+     * - Both(e, a): applies f(a); if the result is Ok(b), returns Both(e, b)
+     *   to preserve the warning. Otherwise returns f(a) as-is.
+     *
+     * @example
+     * ```ts
+     * const double = (n: number): These<string, number> => These.toOk(n * 2);
+     *
+     * pipe(These.toOk(5), These.chain(double));           // Ok(10)
+     * pipe(These.toBoth("warn", 5), These.chain(double)); // Both("warn", 10)
+     * pipe(These.toErr("err"), These.chain(double));      // Err("err")
+     * ```
+     */
+    These.chain = (f) => (data) => {
+        if (These.isErr(data))
+            return data;
+        if (These.isOk(data))
+            return f(data.value);
+        const result = f(data.value);
+        return These.isOk(result) ? These.toBoth(data.error, result.value) : result;
+    };
+    /**
+     * Extracts a value from a These by providing handlers for all three cases.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   these,
+     *   These.fold(
+     *     e => `Error: ${e}`,
+     *     a => `Value: ${a}`,
+     *     (e, a) => `Both: ${e} / ${a}`
+     *   )
+     * );
+     * ```
+     */
+    These.fold = (onErr, onOk, onBoth) => (data) => {
+        if (These.isErr(data))
+            return onErr(data.error);
+        if (These.isOk(data))
+            return onOk(data.value);
+        return onBoth(data.error, data.value);
+    };
+    /**
+     * Pattern matches on a These, returning the result of the matching case.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   these,
+     *   These.match({
+     *     err: e => `Error: ${e}`,
+     *     ok: a => `Value: ${a}`,
+     *     both: (e, a) => `Both: ${e} / ${a}`
+     *   })
+     * );
+     * ```
+     */
+    These.match = (cases) => (data) => {
+        if (These.isErr(data))
+            return cases.err(data.error);
+        if (These.isOk(data))
+            return cases.ok(data.value);
+        return cases.both(data.error, data.value);
+    };
+    /**
+     * Returns the success value, or a default if the These has no success value.
+     *
+     * @example
+     * ```ts
+     * pipe(These.toOk(5), These.getOrElse(0));           // 5
+     * pipe(These.toBoth("warn", 5), These.getOrElse(0)); // 5
+     * pipe(These.toErr("err"), These.getOrElse(0));      // 0
+     * ```
+     */
+    These.getOrElse = (defaultValue) => (data) => These.hasValue(data) ? data.value : defaultValue;
+    /**
+     * Executes a side effect on the success value without changing the These.
+     * Useful for logging or debugging.
+     */
+    These.tap = (f) => (data) => {
+        if (These.hasValue(data))
+            f(data.value);
+        return data;
+    };
+    /**
+     * Swaps the roles of error and success values.
+     * - Err(e)      → Ok(e)
+     * - Ok(a)       → Err(a)
+     * - Both(e, a)  → Both(a, e)
+     *
+     * @example
+     * ```ts
+     * These.swap(These.toErr("err"));        // Ok("err")
+     * These.swap(These.toOk(5));             // Err(5)
+     * These.swap(These.toBoth("warn", 5));   // Both(5, "warn")
+     * ```
+     */
+    These.swap = (data) => {
+        if (These.isErr(data))
+            return These.toOk(data.error);
+        if (These.isOk(data))
+            return These.toErr(data.value);
+        return These.toBoth(data.value, data.error);
+    };
+    /**
+     * Converts a These to an Option.
+     * Ok and Both produce Some; Err produces None.
+     *
+     * @example
+     * ```ts
+     * These.toOption(These.toOk(42));          // Some(42)
+     * These.toOption(These.toBoth("warn", 42)); // Some(42)
+     * These.toOption(These.toErr("err"));       // None
+     * ```
+     */
+    These.toOption = (data) => These.hasValue(data) ? { kind: "Some", value: data.value } : { kind: "None" };
+    /**
+     * Converts a These to a Result, discarding any warning from Both.
+     * Ok and Both produce Ok; Err produces Err.
+     *
+     * @example
+     * ```ts
+     * These.toResult(These.toOk(42));           // Ok(42)
+     * These.toResult(These.toBoth("warn", 42)); // Ok(42)
+     * These.toResult(These.toErr("err"));       // Err("err")
+     * ```
+     */
+    These.toResult = (data) => {
+        if (These.hasValue(data))
+            return Result_js_1.Result.toOk(data.value);
+        return data;
+    };
+})(These || (exports.These = These = {}));

package/script/src/Core/index.js

@@ -20,5 +20,8 @@ __exportStar(require("./Rec.js"), exports);
 __exportStar(require("./RemoteData.js"), exports);
 __exportStar(require("./Result.js"), exports);
 __exportStar(require("./Task.js"), exports);
+__exportStar(require("./TaskOption.js"), exports);
 __exportStar(require("./TaskResult.js"), exports);
+__exportStar(require("./TaskValidation.js"), exports);
+__exportStar(require("./These.js"), exports);
 __exportStar(require("./Validation.js"), exports);

package/script/src/Types/Brand.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Brand = void 0;
+var Brand;
+(function (Brand) {
+    /**
+     * Creates a branding constructor for brand K over type T.
+     * The resulting function performs an unchecked cast — only use when the raw
+     * value is known to satisfy the brand's invariants.
+     *
+     * @example
+     * ```ts
+     * type PositiveNumber = Brand<"PositiveNumber", number>;
+     * const toPositiveNumber = Brand.make<"PositiveNumber", number>();
+     *
+     * const n: PositiveNumber = toPositiveNumber(42);
+     * ```
+     */
+    Brand.make = () => (value) => value;
+    /**
+     * Strips the brand and returns the underlying value.
+     * Since Brand<K, T> extends T this is rarely needed, but can improve readability.
+     *
+     * @example
+     * ```ts
+     * const userId: UserId = toUserId("user-123");
+     * const raw: string = Brand.unwrap(userId); // "user-123"
+     * ```
+     */
+    Brand.unwrap = (branded) => branded;
+})(Brand || (exports.Brand = Brand = {}));

package/script/src/Types/index.js

@@ -14,4 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Brand.js"), exports);
 __exportStar(require("./NonEmptyList.js"), exports);

package/types/src/Core/TaskOption.d.ts

@@ -0,0 +1,120 @@
+import { Option } from "./Option.js";
+import { Task } from "./Task.js";
+import { TaskResult } from "./TaskResult.js";
+/**
+ * A Task that resolves to an optional value.
+ * Combines async operations with the Option type for values that may not exist.
+ *
+ * @example
+ * ```ts
+ * const findUser = (id: string): TaskOption<User> =>
+ *   TaskOption.tryCatch(() => db.users.findById(id));
+ *
+ * pipe(
+ *   findUser("123"),
+ *   TaskOption.map(user => user.name),
+ *   TaskOption.getOrElse("Unknown")
+ * )();
+ * ```
+ */
+export type TaskOption<A> = Task<Option<A>>;
+export declare namespace TaskOption {
+    /**
+     * Wraps a value in a Some inside a Task.
+     */
+    const of: <A>(value: A) => TaskOption<A>;
+    /**
+     * Creates a TaskOption that resolves to None.
+     */
+    const none: <A = never>() => TaskOption<A>;
+    /**
+     * Lifts an Option into a TaskOption.
+     */
+    const fromOption: <A>(option: Option<A>) => TaskOption<A>;
+    /**
+     * Lifts a Task into a TaskOption by wrapping its result in Some.
+     */
+    const fromTask: <A>(task: Task<A>) => TaskOption<A>;
+    /**
+     * Creates a TaskOption from a Promise-returning function.
+     * Returns Some if the promise resolves, None if it rejects.
+     *
+     * @example
+     * ```ts
+     * const fetchUser = TaskOption.tryCatch(() =>
+     *   fetch("/user/1").then(r => r.json())
+     * );
+     * ```
+     */
+    const tryCatch: <A>(f: () => Promise<A>) => TaskOption<A>;
+    /**
+     * Transforms the value inside a TaskOption.
+     */
+    const map: <A, B>(f: (a: A) => B) => (data: TaskOption<A>) => TaskOption<B>;
+    /**
+     * Chains TaskOption computations. If the first resolves to Some, passes the
+     * value to f. If the first resolves to None, propagates None.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   findUser("123"),
+     *   TaskOption.chain(user => findOrg(user.orgId))
+     * )();
+     * ```
+     */
+    const chain: <A, B>(f: (a: A) => TaskOption<B>) => (data: TaskOption<A>) => TaskOption<B>;
+    /**
+     * Applies a function wrapped in a TaskOption to a value wrapped in a TaskOption.
+     * Both Tasks run in parallel.
+     */
+    const ap: <A>(arg: TaskOption<A>) => <B>(data: TaskOption<(a: A) => B>) => TaskOption<B>;
+    /**
+     * Extracts a value from a TaskOption by providing handlers for both cases.
+     */
+    const fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: TaskOption<A>) => Task<B>;
+    /**
+     * Pattern matches on a TaskOption, returning a Task of the result.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   findUser("123"),
+     *   TaskOption.match({
+     *     some: user => `Hello, ${user.name}`,
+     *     none: () => "User not found"
+     *   })
+     * )();
+     * ```
+     */
+    const match: <A, B>(cases: {
+        none: () => B;
+        some: (a: A) => B;
+    }) => (data: TaskOption<A>) => Task<B>;
+    /**
+     * Returns the value or a default if the TaskOption resolves to None.
+     */
+    const getOrElse: <A>(defaultValue: A) => (data: TaskOption<A>) => Task<A>;
+    /**
+     * Executes a side effect on the value without changing the TaskOption.
+     * Useful for logging or debugging.
+     */
+    const tap: <A>(f: (a: A) => void) => (data: TaskOption<A>) => TaskOption<A>;
+    /**
+     * Filters the value inside a TaskOption. Returns None if the predicate fails.
+     */
+    const filter: <A>(predicate: (a: A) => boolean) => (data: TaskOption<A>) => TaskOption<A>;
+    /**
+     * Converts a TaskOption to a TaskResult, using onNone to produce the error value.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   findUser("123"),
+     *   TaskOption.toTaskResult(() => "User not found")
+     * );
+     * ```
+     */
+    const toTaskResult: <E>(onNone: () => E) => <A>(data: TaskOption<A>) => TaskResult<E, A>;
+}
+//# sourceMappingURL=TaskOption.d.ts.map

package/types/src/Core/TaskOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TaskOption.d.ts","sourceRoot":"","sources":["../../../src/src/Core/TaskOption.ts"],"names":[],"mappings":"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"}