@nlozgachev/pipekit 0.1.7 → 0.2.0

package/README.md

@@ -1,253 +1,76 @@
 # @nlozgachev/pipekit
 
-[![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)
+[![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)![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/nlozgachev/pipekit/publish.yml?style=for-the-badge&color=000&logo=githubactions&label&logoColor=fff)![Codecov](https://img.shields.io/codecov/c/github/nlozgachev/pipekit?style=for-the-badge&color=000&logo=codecov&label&logoColor=fff)[![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 TypeScript toolkit for writing code that means exactly what it says.
 
-## What is this?
-
-A TypeScript toolkit for expressing uncertainty precisely — absent values, fallible operations,
-async workflows, loading states — with types that carry their own intent and operations that
-compose.
-
-Most TypeScript code encodes state as flags and nullable fields: `data | null`,
-`error: Error | null`, `loading: boolean`. This works at small scale, but it pushes the burden of
-knowing which combinations are valid onto every consumer. Nothing in the type system tells you that
-`data` is only meaningful when `loading` is false and `error` is null — you just have to know, and
-check.
-
-This library takes a different approach: represent the state space precisely, then provide a small,
-consistent set of operations to work with it. `Option` doesn't let you access a value that might not
-exist without deciding what to do when it doesn't. `Result` makes it impossible to forget the error
-case. `RemoteData` replaces a trio of booleans with four named, mutually exclusive states. Each type
-comes with a module of functions — constructors, transformations, extractors — that follow the same
-conventions (`map`, `chain`, `match`, `getOrElse`) and work with `pipe`.
-
-The consistency means knowledge transfers: once you know `Option`, picking up `Result` or
-`TaskResult` is mostly recognising the same operations in a new context. The composition means logic
-reads in the order it executes. And precise types mean the compiler tracks what's possible — so you
-don't have to.
+```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`.
-- **`TaskOption<A>`** — a lazy async operation that may return nothing. `Task` + `Option` combined.
-  Replaces `Promise<T | null>`. Key operations: `tryCatch`, `map`, `chain`, `filter`, `match`,
-  `getOrElse`, `toTaskResult`.
-- **`TaskValidation<E, A>`** — a lazy async operation that accumulates errors. `Task` + `Validation`
-  combined. Use for async form validation or parallel async checks that all need to run. Key
-  operations: `tryCatch`, `map`, `chain`, `ap`, `match`, `recover`.
-- **`These<E, A>`** — an inclusive-OR: holds an error, a success value, or both simultaneously.
-  Unlike `Result` which is one or the other, `Both` carries a warning alongside a valid result — use
-  it when partial success with diagnostics matters. Key operations: `toErr`, `toOk`, `toBoth`,
-  `map`, `mapErr`, `bimap`, `chain`, `match`, `swap`, `toResult`.
-- **`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 for values that share the same underlying type. Prevents
-  passing a `CustomerId` where a `UserId` is expected, even though both are `string`. The brand
-  exists only at compile time — zero runtime cost. Key operations: `make`, `unwrap`.
+- **`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
+// 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
 );
-```
-
-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"),
-);
-
-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
-  );
-}
-```
-
-`Brand` applies the same idea at the type level. When `userId` and `customerId` are both `string`,
-nothing stops you from passing one where the other is expected — until you brand them:
 
-```ts
-import { Brand } from "@nlozgachev/pipekit/Types";
-
-type UserId = Brand<"UserId", string>;
-type CustomerId = Brand<"CustomerId", string>;
-
-const toUserId = Brand.make<"UserId", string>();
-const toCustomerId = Brand.make<"CustomerId", string>();
-
-function getUser(id: UserId): User {/* ... */}
-
-const cid = toCustomerId("c-99");
-getUser(cid); // TypeError: Argument of type 'CustomerId' is not assignable to parameter of type 'UserId'
-getUser(toUserId("u-42")); // ✓
-```
-
-The same idea applies to error handling with `Result`, form validation with `Validation`, async
-operations with `Task`, `TaskResult`, `TaskOption`, and `TaskValidation`, 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. For async
-equivalents of all three, reach for `TaskOption`, `TaskResult`, and `TaskValidation`.
+## Documentation
+
+Full guides and API reference at **[pipekit.lozgachev.dev](https://pipekit.lozgachev.dev)**.
 
 ## License
 

package/esm/src/Core/Arr.js

@@ -28,7 +28,7 @@ export var Arr;
      * Arr.head([]); // None
      * ```
      */
-    Arr.head = (data) => data.length > 0 ? Option.toSome(data[0]) : Option.toNone();
+    Arr.head = (data) => data.length > 0 ? Option.some(data[0]) : Option.none();
     /**
      * Returns the last element of an array, or None if the array is empty.
      *
@@ -38,7 +38,7 @@ export var Arr;
      * Arr.last([]); // None
      * ```
      */
-    Arr.last = (data) => data.length > 0 ? Option.toSome(data[data.length - 1]) : Option.toNone();
+    Arr.last = (data) => data.length > 0 ? Option.some(data[data.length - 1]) : Option.none();
     /**
      * Returns all elements except the first, or None if the array is empty.
      *
@@ -48,7 +48,7 @@ export var Arr;
      * Arr.tail([]); // None
      * ```
      */
-    Arr.tail = (data) => data.length > 0 ? Option.toSome(data.slice(1)) : Option.toNone();
+    Arr.tail = (data) => data.length > 0 ? Option.some(data.slice(1)) : Option.none();
     /**
      * Returns all elements except the last, or None if the array is empty.
      *
@@ -58,7 +58,7 @@ export var Arr;
      * Arr.init([]); // None
      * ```
      */
-    Arr.init = (data) => data.length > 0 ? Option.toSome(data.slice(0, -1)) : Option.toNone();
+    Arr.init = (data) => data.length > 0 ? Option.some(data.slice(0, -1)) : Option.none();
     // --- Search ---
     /**
      * Returns the first element matching the predicate, or None.
@@ -70,7 +70,7 @@ export var Arr;
      */
     Arr.findFirst = (predicate) => (data) => {
         const idx = data.findIndex(predicate);
-        return idx >= 0 ? Option.toSome(data[idx]) : Option.toNone();
+        return idx >= 0 ? Option.some(data[idx]) : Option.none();
     };
     /**
      * Returns the last element matching the predicate, or None.
@@ -83,9 +83,9 @@ export var Arr;
     Arr.findLast = (predicate) => (data) => {
         for (let i = data.length - 1; i >= 0; i--) {
             if (predicate(data[i]))
-                return Option.toSome(data[i]);
+                return Option.some(data[i]);
         }
-        return Option.toNone();
+        return Option.none();
     };
     /**
      * Returns the index of the first element matching the predicate, or None.
@@ -97,7 +97,7 @@ export var Arr;
      */
     Arr.findIndex = (predicate) => (data) => {
         const idx = data.findIndex(predicate);
-        return idx >= 0 ? Option.toSome(idx) : Option.toNone();
+        return idx >= 0 ? Option.some(idx) : Option.none();
     };
     // --- Transform ---
     /**
@@ -303,7 +303,7 @@ export var Arr;
      * ```ts
      * const parseNum = (s: string): Option<number> => {
      *   const n = Number(s);
-     *   return isNaN(n) ? Option.toNone() : Option.of(n);
+     *   return isNaN(n) ? Option.none() : Option.of(n);
      * };
      *
      * pipe(["1", "2", "3"], Arr.traverse(parseNum)); // Some([1, 2, 3])
@@ -315,10 +315,10 @@ export var Arr;
         for (const a of data) {
             const mapped = f(a);
             if (Option.isNone(mapped))
-                return Option.toNone();
+                return Option.none();
             result.push(mapped.value);
         }
-        return Option.toSome(result);
+        return Option.some(result);
     };
     /**
      * Maps each element to a Result and collects the results.
@@ -328,7 +328,7 @@ export var Arr;
      * ```ts
      * pipe(
      *   [1, 2, 3],
-     *   Arr.traverseResult(n => n > 0 ? Result.toOk(n) : Result.toErr("negative"))
+     *   Arr.traverseResult(n => n > 0 ? Result.ok(n) : Result.err("negative"))
      * ); // Ok([1, 2, 3])
      * ```
      */
@@ -340,7 +340,7 @@ export var Arr;
                 return mapped;
             result.push(mapped.value);
         }
-        return Result.toOk(result);
+        return Result.ok(result);
     };
     /**
      * Maps each element to a Task and runs all in parallel.
@@ -361,7 +361,7 @@ export var Arr;
      * @example
      * ```ts
      * Arr.sequence([Option.of(1), Option.of(2)]); // Some([1, 2])
-     * Arr.sequence([Option.of(1), Option.toNone()]); // None
+     * Arr.sequence([Option.of(1), Option.none()]); // None
      * ```
      */
     Arr.sequence = (data) => Arr.traverse((a) => a)(data);

package/esm/src/Core/Option.js

@@ -9,11 +9,11 @@ export var Option;
      * Option.of(42); // Some(42)
      * ```
      */
-    Option.of = (value) => Option.toSome(value);
+    Option.of = (value) => Option.some(value);
     /**
      * Creates a Some containing the given value.
      */
-    Option.toSome = (value) => ({ kind: "Some", value });
+    Option.some = (value) => ({ kind: "Some", value });
     /**
      * Type guard that checks if a Option is Some.
      */
@@ -21,7 +21,7 @@ export var Option;
     /**
      * Creates a None (empty Option).
      */
-    Option.toNone = () => ({ kind: "None" });
+    Option.none = () => ({ kind: "None" });
     /**
      * Type guard that checks if a Option is None.
      */
@@ -36,7 +36,7 @@ export var Option;
      * Option.fromNullable(42); // Some(42)
      * ```
      */
-    Option.fromNullable = (value) => value === null || value === undefined ? Option.toNone() : Option.toSome(value);
+    Option.fromNullable = (value) => value === null || value === undefined ? Option.none() : Option.some(value);
     /**
      * Extracts the value from a Option, returning null if None.
      */
@@ -49,7 +49,7 @@ export var Option;
      * Creates a Option from a possibly undefined value.
      * Returns None if undefined, Some otherwise.
      */
-    Option.fromUndefined = (value) => value === undefined ? Option.toNone() : Option.toSome(value);
+    Option.fromUndefined = (value) => value === undefined ? Option.none() : Option.some(value);
     /**
      * Converts an Option to a Result.
      * Some becomes Ok, None becomes Err with the provided error.
@@ -62,33 +62,33 @@ export var Option;
      * ); // Ok(42)
      *
      * pipe(
-     *   Option.toNone(),
+     *   Option.none(),
      *   Option.toResult(() => "Value was missing")
      * ); // Err("Value was missing")
      * ```
      */
-    Option.toResult = (onNone) => (data) => Option.isSome(data) ? Result.toOk(data.value) : Result.toErr(onNone());
+    Option.toResult = (onNone) => (data) => Option.isSome(data) ? Result.ok(data.value) : Result.err(onNone());
     /**
      * Creates an Option from a Result.
      * Ok becomes Some, Err becomes None (the error is discarded).
      *
      * @example
      * ```ts
-     * Option.fromResult(Result.toOk(42)); // Some(42)
-     * Option.fromResult(Result.toErr("oops")); // None
+     * Option.fromResult(Result.ok(42)); // Some(42)
+     * Option.fromResult(Result.err("oops")); // None
      * ```
      */
-    Option.fromResult = (data) => Result.isOk(data) ? Option.toSome(data.value) : Option.toNone();
+    Option.fromResult = (data) => Result.isOk(data) ? Option.some(data.value) : Option.none();
     /**
      * Transforms the value inside a Option if it exists.
      *
      * @example
      * ```ts
      * pipe(Option.of(5), Option.map(n => n * 2)); // Some(10)
-     * pipe(Option.toNone(), Option.map(n => n * 2)); // None
+     * pipe(Option.none(), Option.map(n => n * 2)); // None
      * ```
      */
-    Option.map = (f) => (data) => Option.isSome(data) ? Option.toSome(f(data.value)) : data;
+    Option.map = (f) => (data) => Option.isSome(data) ? Option.some(f(data.value)) : data;
     /**
      * Chains Option computations. If the first is Some, passes the value to f.
      * If the first is None, propagates None.
@@ -97,7 +97,7 @@ export var Option;
      * ```ts
      * const parseNumber = (s: string): Option<number> => {
      *   const n = parseInt(s, 10);
-     *   return isNaN(n) ? Option.toNone() : Option.of(n);
+     *   return isNaN(n) ? Option.none() : Option.of(n);
      * };
      *
      * pipe(Option.of("42"), Option.chain(parseNumber)); // Some(42)
@@ -141,7 +141,7 @@ export var Option;
      * @example
      * ```ts
      * pipe(Option.of(5), Option.getOrElse(0)); // 5
-     * pipe(Option.toNone(), Option.getOrElse(0)); // 0
+     * pipe(Option.none(), Option.getOrElse(0)); // 0
      * ```
      */
     Option.getOrElse = (defaultValue) => (data) => Option.isSome(data) ? data.value : defaultValue;
@@ -173,7 +173,7 @@ export var Option;
      * pipe(Option.of(2), Option.filter(n => n > 3)); // None
      * ```
      */
-    Option.filter = (predicate) => (data) => Option.isSome(data) && predicate(data.value) ? data : Option.toNone();
+    Option.filter = (predicate) => (data) => Option.isSome(data) && predicate(data.value) ? data : Option.none();
     /**
      * Recovers from a None by providing a fallback Option.
      */
@@ -191,5 +191,5 @@ export var Option;
      * ); // Some(8)
      * ```
      */
-    Option.ap = (arg) => (data) => Option.isSome(data) && Option.isSome(arg) ? Option.toSome(data.value(arg.value)) : Option.toNone();
+    Option.ap = (arg) => (data) => Option.isSome(data) && Option.isSome(arg) ? Option.some(data.value(arg.value)) : Option.none();
 })(Option || (Option = {}));

package/esm/src/Core/Rec.js

@@ -87,7 +87,7 @@ export var Rec;
      * pipe({ a: 1, b: 2 }, Rec.lookup("c")); // None
      * ```
      */
-    Rec.lookup = (key) => (data) => Object.prototype.hasOwnProperty.call(data, key) ? Option.toSome(data[key]) : Option.toNone();
+    Rec.lookup = (key) => (data) => Object.prototype.hasOwnProperty.call(data, key) ? Option.some(data[key]) : Option.none();
     /**
      * Returns all keys of a record.
      */

package/esm/src/Core/Result.js

@@ -8,15 +8,15 @@ export var Result;
      * Result.of(42); // Ok(42)
      * ```
      */
-    Result.of = (value) => Result.toOk(value);
+    Result.of = (value) => Result.ok(value);
     /**
      * Creates a failed Result with the given error.
      */
-    Result.toErr = (error) => ({ kind: "Error", error });
+    Result.err = (error) => ({ kind: "Error", error });
     /**
      * Creates a successful Result with the given value.
      */
-    Result.toOk = (value) => ({ kind: "Ok", value });
+    Result.ok = (value) => ({ kind: "Ok", value });
     /**
      * Type guard that checks if an Result is Ok.
      */
@@ -40,10 +40,10 @@ export var Result;
      */
     Result.tryCatch = (f, onError) => {
         try {
-            return Result.toOk(f());
+            return Result.ok(f());
         }
         catch (e) {
-            return Result.toErr(onError(e));
+            return Result.err(onError(e));
         }
     };
     /**
@@ -52,19 +52,19 @@ export var Result;
      * @example
      * ```ts
      * pipe(Result.of(5), Result.map(n => n * 2)); // Ok(10)
-     * pipe(Result.toErr("error"), Result.map(n => n * 2)); // Err("error")
+     * pipe(Result.err("error"), Result.map(n => n * 2)); // Err("error")
      * ```
      */
-    Result.map = (f) => (data) => Result.isOk(data) ? Result.toOk(f(data.value)) : data;
+    Result.map = (f) => (data) => Result.isOk(data) ? Result.ok(f(data.value)) : data;
     /**
      * Transforms the error value inside an Result.
      *
      * @example
      * ```ts
-     * pipe(Result.toErr("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
+     * pipe(Result.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
      * ```
      */
-    Result.mapError = (f) => (data) => Result.isErr(data) ? Result.toErr(f(data.error)) : data;
+    Result.mapError = (f) => (data) => Result.isErr(data) ? Result.err(f(data.error)) : data;
     /**
      * Chains Result computations. If the first is Ok, passes the value to f.
      * If the first is Err, propagates the error.
@@ -72,7 +72,7 @@ export var Result;
      * @example
      * ```ts
      * const validatePositive = (n: number): Result<string, number> =>
-     *   n > 0 ? Result.of(n) : Result.toErr("Must be positive");
+     *   n > 0 ? Result.of(n) : Result.err("Must be positive");
      *
      * pipe(Result.of(5), Result.chain(validatePositive)); // Ok(5)
      * pipe(Result.of(-1), Result.chain(validatePositive)); // Err("Must be positive")
@@ -115,7 +115,7 @@ export var Result;
      * @example
      * ```ts
      * pipe(Result.of(5), Result.getOrElse(0)); // 5
-     * pipe(Result.toErr("error"), Result.getOrElse(0)); // 0
+     * pipe(Result.err("error"), Result.getOrElse(0)); // 0
      * ```
      */
     Result.getOrElse = (defaultValue) => (data) => Result.isOk(data) ? data.value : defaultValue;
@@ -151,8 +151,8 @@ export var Result;
      *
      * @example
      * ```ts
-     * Result.toOption(Result.toOk(42)); // Some(42)
-     * Result.toOption(Result.toErr("oops")); // None
+     * Result.toOption(Result.ok(42)); // Some(42)
+     * Result.toOption(Result.err("oops")); // None
      * ```
      */
     Result.toOption = (data) => Result.isOk(data) ? { kind: "Some", value: data.value } : { kind: "None" };
@@ -169,5 +169,5 @@ export var Result;
      * ); // Ok(8)
      * ```
      */
-    Result.ap = (arg) => (data) => Result.isOk(data) && Result.isOk(arg) ? Result.toOk(data.value(arg.value)) : Result.isErr(data) ? data : arg;
+    Result.ap = (arg) => (data) => Result.isOk(data) && Result.isOk(arg) ? Result.ok(data.value(arg.value)) : Result.isErr(data) ? data : arg;
 })(Result || (Result = {}));