@nlozgachev/pipekit 0.1.6 → 0.1.8

package/README.md

@@ -2,181 +2,76 @@
 
 [![npm](https://img.shields.io/npm/v/@nlozgachev/pipekit?style=for-the-badge&color=000&logo=npm&label&logoColor=fff)](https://www.npmjs.com/package/@nlozgachev/pipekit)[![JSR Version](https://img.shields.io/jsr/v/@nlozgachev/pipekit?style=for-the-badge&color=000&logo=jsr&label&logoColor=fff)](https://jsr.io/@nlozgachev/pipekit)[![TypeScript](https://img.shields.io/badge/-0?style=for-the-badge&color=000&logo=typescript&label&logoColor=fff)](https://www.typescriptlang.org)[![Deno](https://img.shields.io/badge/-0?style=for-the-badge&color=000&logo=Deno&label&logoColor=fff)](https://deno.com)
 
-A functional programming toolkit for TypeScript that speaks your language.
+A TypeScript toolkit for writing code that means exactly what it says.
 
-## What is this?
-
-A collection of types and utilities that help you write safer, composition-centric, more predictable TypeScript. If you've ever dealt with `null` checks scattered across your codebase, nested `try/catch` blocks, or `{ data: T | null; loading: boolean; error: Error | null }` — this library gives you better tools for all of that.
+```sh
+# npm / pnpm / yarn / bun
+npm add @nlozgachev/pipekit
 
-## Do I need to know functional programming to use this?
+# Deno
+deno add jsr:@nlozgachev/pipekit
+```
 
-No. The library avoids FP-specific jargon wherever possible. You won't find `Monad`, `Functor`, or `Applicative` in the API. Instead, you'll work with names that describe what they do:
+## What is this?
 
-- `Option` — a value that might not exist
-- `Result` — an operation that can succeed or fail
-- `map` — transform a value inside a container
-- `chain` — sequence operations that might fail
-- `match` — handle each case explicitly
+A toolkit for expressing uncertainty precisely. Instead of `T | null`, `try/catch`, and loading state flag soup, you get types that name every possible state and make invalid ones unrepresentable. Each type comes with a consistent set of operations — `map`, `chain`, `match`, `getOrElse` — that compose with `pipe` and `flow`.
 
-You can start using these right away and learn the underlying concepts as you go.
+No FP jargon required. You won't find `Monad`, `Functor`, or `Applicative` in the API.
 
 ## What's included?
 
 ### pipekit/Core
 
-Each of these is both a TypeScript type and a module of functions for working with values of that type — constructors, transformations, and ways to extract a value back out.
-
-- **`Option<A>`** — a value that might not exist. Replaces `T | null | undefined`. Key operations: `fromNullable`, `map`, `chain`, `filter`, `match`, `getOrElse`, `recover`.
-- **`Result<E, A>`** — an operation that succeeds with `A` or fails with `E`. Replaces `try/catch`. Key operations: `tryCatch`, `map`, `mapError`, `chain`, `match`, `getOrElse`, `recover`.
-- **`Validation<E, A>`** — like `Result`, but accumulates **all** errors instead of stopping at the first. Built for form validation. Key operations: `combine`, `combineAll`, `ap`, `map`, `match`.
-- **`Task<A>`** — a lazy async operation that doesn't run until called. Key operations: `from`, `map`, `chain`, `all`, `delay`.
-- **`TaskResult<E, A>`** — a lazy async operation that can fail. `Task` + `Result` combined. Key operations: `tryCatch`, `map`, `mapError`, `chain`, `match`, `recover`.
-- **`RemoteData<E, A>`** — models the four states of a data fetch: `NotAsked`, `Loading`, `Failure`, `Success`. Replaces `{ data, loading, error }` flag soup. Key operations: `notAsked`, `loading`, `failure`, `success`, `map`, `match`, `toResult`.
-- **`Arr`** — array operations that return `Option` instead of throwing or returning `undefined`. Operations: `head`, `last`, `findFirst`, `findLast`, `partition`, `groupBy`, `zip`, `traverse`, and more.
-- **`Rec`** — record/object operations. Operations: `lookup`, `map`, `filter`, `pick`, `omit`, `merge`, and more.
+- **`Option<A>`** — a value that might not exist. Replaces `T | null | undefined`.
+- **`Result<E, A>`** — an operation that succeeds or fails. Replaces `try/catch`.
+- **`Validation<E, A>`** — like `Result`, but accumulates all errors instead of stopping at the first.
+- **`Task<A>`** — a lazy async operation that doesn't run until called.
+- **`TaskResult<E, A>`** — `Task` + `Result`. A lazy async operation that can fail.
+- **`TaskOption<A>`** — `Task` + `Option`. Replaces `Promise<T | null>`.
+- **`TaskValidation<E, A>`** — `Task` + `Validation`. For async checks that all need to run.
+- **`These<E, A>`** — an inclusive OR: holds an error, a value, or both at once.
+- **`RemoteData<E, A>`** — the four states of a data fetch: `NotAsked`, `Loading`, `Failure`, `Success`.
+- **`Arr`** — array utilities that return `Option` instead of `undefined`.
+- **`Rec`** — record/object utilities.
 
 ### pipekit/Types
 
+- **`Brand<K, T>`** — nominal typing at compile time, zero runtime cost.
 - **`NonEmptyList<A>`** — an array guaranteed to have at least one element.
 
 ### pipekit/Composition
 
-- **`pipe`** — pass a value through a series of functions, left to right.
-- **`flow`** — compose functions into a reusable pipeline (like `pipe` without an initial value).
-- **`compose`** — compose functions right to left (traditional mathematical composition).
-- **`curry` / `uncurry`** — convert between multi-argument and single-argument functions.
-- **`tap`** — run a side effect (like logging) without breaking the pipeline.
-- **`memoize`** — cache function results.
-- **`identity`**, **`constant`**, **`not`**, **`and`**, **`or`**, **`once`**, **`flip`** — common function utilities.
+- **`pipe`**, **`flow`**, **`compose`** — function composition.
+- **`curry`** / **`uncurry`**, **`tap`**, **`memoize`**, and other function utilities.
 
-## What does "composition-centric" mean?
-
-Everything in the library is designed to work with `pipe` — a function that passes a value through a series of transformations, top to bottom. The alternative is nesting calls inside each other, which reads inside-out:
+## Example
 
 ```ts
-import { Option } from "@nlozgachev/pipekit/Core";
+import { Option, Result } from "@nlozgachev/pipekit/Core";
 import { pipe } from "@nlozgachev/pipekit/Composition";
 
-// Without pipe: execution order is the reverse of reading order
-const userName = Option.getOrElse(
-  Option.map(
-    Option.fromNullable(users.get("123")),
-    u => u.name
-  ),
-  "Anonymous"
-);
-
-// With pipe: reads top to bottom, matches execution order
-const userName = pipe(
-  users.get("123"),              // User | undefined
-  Option.fromNullable,           // Option<User>
-  Option.map(u => u.name),       // Option<string>
-  Option.getOrElse("Anonymous")  // string
-);
-```
-
-No method chaining, no class hierarchies. Just functions that connect together.
-
-## What does "data-last" mean and why should I care?
-
-Every operation takes the data it operates on as the **last** argument. This means you can partially apply them — get a function back without providing data yet — which makes `flow` work naturally.
-
-```ts
-import { Option } from "@nlozgachev/pipekit/Core";
-import { flow } from "@nlozgachev/pipekit/Composition";
-
-// Data-first: can't partially apply, so you're stuck writing wrapper functions
-function formatName(user: User | null): string {
-  const opt = Option.fromNullable(user);
-  const name = Option.map(opt, u => u.name);
-  return Option.getOrElse(name, "Anonymous");
-}
-
-users.map(u => formatName(u)); // needs an arrow function wrapper
-
-// Data-last: operations are curried, so flow connects them directly
-const formatName = flow(
-  Option.fromNullable<User>,
-  Option.map(u => u.name),
-  Option.getOrElse("Anonymous")
+// Chain nullable lookups without nested null checks
+const city = pipe(
+  getUser(userId),                                    // User | null
+  Option.fromNullable,                                // Option<User>
+  Option.chain((u) => Option.fromNullable(u.address)),// Option<Address>
+  Option.chain((a) => Option.fromNullable(a.city)),   // Option<string>
+  Option.map((c) => c.toUpperCase()),                 // Option<string>
+  Option.getOrElse("UNKNOWN"),                        // string
 );
 
-users.map(formatName); // no wrapper — it's already a function of User
-```
-
-## How does this help me write safer code?
-
-The core types make invalid states unrepresentable. Instead of stacking null checks and hoping you handled every branch, the shape of the code reflects the shape of the data:
-
-```ts
-// Before: null handling that doesn't scale
-function getDisplayCity(userId: string): string {
-  const user = getUser(userId);
-  if (user === null) return "UNKNOWN";
-  if (user.address === null) return "UNKNOWN";
-  if (user.address.city === null) return "UNKNOWN";
-  return user.address.city.toUpperCase();
-}
-
-// After: flat, readable, same guarantees
-function getDisplayCity(userId: string): string {
-  return pipe(
-    getUser(userId),                                        // User | null
-    Option.fromNullable,                                    // Option<User>
-    Option.chain(u => Option.fromNullable(u.address)),      // Option<Address>
-    Option.chain(a => Option.fromNullable(a.city)),         // Option<string>
-    Option.map(c => c.toUpperCase()),                       // Option<string>
-    Option.getOrElse("UNKNOWN")                             // string
-  );
-}
-```
-
-The same idea applies to error handling with `Result`, form validation with `Validation`, async operations with `Task` and `TaskResult`, and loading states with `RemoteData`.
-
-
-
-## How do I install it?
-
-```sh
-# Deno
-deno add jsr:@nlozgachev/pipekit
-
-# npm / pnpm / yarn / bun
-npm add @nlozgachev/pipekit
-```
-
-## How do I get started?
-
-Start with `pipe` and `Option`. These two cover the most common pain point — dealing with values that might not exist:
-
-```ts
-import { Option } from "@nlozgachev/pipekit/Core";
-import { pipe } from "@nlozgachev/pipekit/Composition";
-
-// Read a user's preferred language from their settings, fall back to the app default
-const language = pipe(
-  userSettings.get(userId),          // UserSettings | undefined
-  Option.fromNullable,               // Option<UserSettings>
-  Option.map(s => s.language),       // Option<string>
-  Option.getOrElse(DEFAULT_LANGUAGE) // string
-);
-```
-
-Once that feels natural, reach for `Result` when operations can fail with a meaningful error — parsing, network calls, database lookups:
-
-```ts
-import { Result } from "@nlozgachev/pipekit/Core";
-
-// Parse user input and look up the record — both steps can fail
+// Parse input and look up a record — both steps can fail
 const record = pipe(
-  parseId(rawInput),                 // Result<ParseError, number>
-  Result.chain(id => db.find(id)),   // Result<ParseError | NotFoundError, Record>
-  Result.map(r => r.name),           // Result<ParseError | NotFoundError, string>
+  parseId(rawInput),                    // Result<ParseError, number>
+  Result.chain((id) => db.find(id)),    // Result<ParseError | NotFoundError, Record>
+  Result.map((r) => r.name),            // Result<ParseError | NotFoundError, string>
 );
 ```
 
-And `Validation` when you need to collect multiple errors at once, like form validation.
+## Documentation
+
+Full guides and API reference at **[pipekit.lozgachev.dev](https://pipekit.lozgachev.dev)**.
 
 ## License
 
-MIT
+MIT

package/esm/src/Core/TaskOption.js

@@ -0,0 +1,99 @@
+import { Option } from "./Option.js";
+import { Task } from "./Task.js";
+export var TaskOption;
+(function (TaskOption) {
+    /**
+     * Wraps a value in a Some inside a Task.
+     */
+    TaskOption.of = (value) => Task.of(Option.of(value));
+    /**
+     * Creates a TaskOption that resolves to None.
+     */
+    TaskOption.none = () => Task.of(Option.toNone());
+    /**
+     * Lifts an Option into a TaskOption.
+     */
+    TaskOption.fromOption = (option) => Task.of(option);
+    /**
+     * Lifts a Task into a TaskOption by wrapping its result in Some.
+     */
+    TaskOption.fromTask = (task) => Task.map(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.of).catch(() => Option.toNone());
+    /**
+     * Transforms the value inside a TaskOption.
+     */
+    TaskOption.map = (f) => (data) => Task.map(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.chain((option) => Option.isSome(option) ? f(option.value) : Task.of(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.ap(oa)(of_));
+    /**
+     * Extracts a value from a TaskOption by providing handlers for both cases.
+     */
+    TaskOption.fold = (onNone, onSome) => (data) => Task.map(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.map(Option.match(cases))(data);
+    /**
+     * Returns the value or a default if the TaskOption resolves to None.
+     */
+    TaskOption.getOrElse = (defaultValue) => (data) => Task.map(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.map(Option.tap(f))(data);
+    /**
+     * Filters the value inside a TaskOption. Returns None if the predicate fails.
+     */
+    TaskOption.filter = (predicate) => (data) => Task.map(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.map(Option.toResult(onNone))(data);
+})(TaskOption || (TaskOption = {}));

package/esm/src/Core/TaskValidation.js

@@ -0,0 +1,93 @@
+import { Task } from "./Task.js";
+import { Validation } from "./Validation.js";
+export var TaskValidation;
+(function (TaskValidation) {
+    /**
+     * Wraps a value in a valid TaskValidation.
+     */
+    TaskValidation.of = (value) => Task.of(Validation.of(value));
+    /**
+     * Creates a failed TaskValidation with a single error.
+     */
+    TaskValidation.fail = (error) => Task.of(Validation.fail(error));
+    /**
+     * Lifts a Validation into a TaskValidation.
+     */
+    TaskValidation.fromValidation = (validation) => 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.of))
+        .catch((e) => Validation.fail(onError(e)));
+    /**
+     * Transforms the success value inside a TaskValidation.
+     */
+    TaskValidation.map = (f) => (data) => Task.map(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.chain((validation) => Validation.isValid(validation)
+        ? f(validation.value)
+        : Task.of(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.ap(va)(vf));
+    /**
+     * Extracts a value from a TaskValidation by providing handlers for both cases.
+     */
+    TaskValidation.fold = (onInvalid, onValid) => (data) => Task.map(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.map(Validation.match(cases))(data);
+    /**
+     * Returns the success value or a default value if the TaskValidation is invalid.
+     */
+    TaskValidation.getOrElse = (defaultValue) => (data) => Task.map(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.map(Validation.tap(f))(data);
+    /**
+     * Recovers from an Invalid state by providing a fallback TaskValidation.
+     */
+    TaskValidation.recover = (fallback) => (data) => Task.chain((validation) => Validation.isValid(validation) ? Task.of(validation) : fallback())(data);
+})(TaskValidation || (TaskValidation = {}));

package/esm/src/Core/These.js

@@ -0,0 +1,242 @@
+import { Result } from "./Result.js";
+export 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.toErr(error);
+    /**
+     * Creates a These holding only a success value (no error).
+     *
+     * @example
+     * ```ts
+     * These.toOk(42);
+     * ```
+     */
+    These.toOk = (value) => 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.toOk(data.value);
+        return data;
+    };
+})(These || (These = {}));

package/esm/src/Core/index.js

@@ -4,5 +4,8 @@ export * from "./Rec.js";
 export * from "./RemoteData.js";
 export * from "./Result.js";
 export * from "./Task.js";
+export * from "./TaskOption.js";
 export * from "./TaskResult.js";
+export * from "./TaskValidation.js";
+export * from "./These.js";
 export * from "./Validation.js";