docs: update imports and type annotations across documentation for clarity and consistency

Author: richecr

docs/either/index.md

@@ -226,7 +226,7 @@ console.log(result2); // 0
 Compares `this` to another `Either`, returns `false` if the values inside are different.
 
 ```ts
-import { Either, Left, Right } from "holo-fn/either";
+import { type Either, Left, Right } from "holo-fn/either";
 
 const calculate = (a: number, b: number): Either<string, number> => {
   if (b === 0) {
@@ -247,7 +247,6 @@ const result2 = calculate(10, 2)
   .map(n => n + 1);
 
 console.log(result2.equals(new Right(0))); // false
-
 ```
 
 ## Helpers
@@ -509,6 +508,7 @@ Curried version of `equals` for `Either`. Compares `this` to another `Either`, r
 
 ```ts
 import { equals, Right } from 'holo-fn/either';
+import { pipe } from 'remeda';
 
 const result = pipe(
   new Right(10),
@@ -525,9 +525,9 @@ console.log(result); // true
 Combines an array of `Either` values into a single `Either`. Returns `Right` with all values if all are `Right`, or `Left` with all errors if any are `Left`.
 
 ```ts
-import { all, right, left } from 'holo-fn/either';
+import { all, left, right, type Either } from 'holo-fn/either';
 
-const result1 = all([right(1), right(2), right(3)]);
+const result1: Either<unknown, number[]> = all([right(1), right(2), right(3)]);
 console.log(result1.unwrapOr([])); // [1, 2, 3]
 
 const result2 = all([left('Name required'), left('Email invalid'), right(25)]);
@@ -552,9 +552,9 @@ Combines an array of `Either` values into a single `Either`, stopping at the fir
 Unlike `all` which collects all errors, `sequence` returns immediately when it finds the first `Left`.
 
 ```ts
-import { sequence, right, left } from 'holo-fn/either';
+import { left, right, sequence, type Either } from 'holo-fn/either';
 
-const result1 = sequence([right(1), right(2), right(3)]);
+const result1: Either<unknown, number[]> = sequence([right(1), right(2), right(3)]);
 console.log(result1.unwrapOr([])); // [1, 2, 3]
 
 const result2 = sequence([
@@ -577,7 +577,7 @@ Separates an array of `Either` values into two groups: `lefts` and `rights`. Alw
 Unlike `all` and `sequence` which return an `Either`, `partition` returns a plain object with two arrays.
 
 ```ts
-import { partition, left, right } from 'holo-fn/either';
+import { left, partition, right } from 'holo-fn/either';
 
 const eithers = [
   right<string, number>(1),
@@ -604,8 +604,8 @@ errors.forEach((err) => console.error(err));
 ### Discriminated union errors
 
 ```ts
-import { pipe } from 'rambda';
 import { left, match, type Either } from 'holo-fn/either';
+import { pipe } from 'rambda';
 
 type User = {
   name: string;
@@ -643,8 +643,8 @@ const message = pipe(
 ### Batch operations with error tracking
 
 ```ts
-import { pipe } from 'rambda';
 import { all, left, match, right } from 'holo-fn/either';
+import { pipe } from 'rambda';
 
 type AddressData = {
   street: string;

docs/helpers/inspect.md

@@ -39,8 +39,9 @@ pipe(
 ### Without Label
 
 ```typescript
-import { ok } from 'holo-fn/result';
 import { inspect } from 'holo-fn';
+import { map, ok } from 'holo-fn/result';
+import { pipe } from 'rambda';
 
 pipe(
   ok({ id: 1, name: 'Alice' }),
@@ -52,9 +53,9 @@ pipe(
 ### Debugging Pipelines
 
 ```typescript
-import { pipe } from 'rambda';
-import { just, map } from 'holo-fn/maybe';
 import { inspect } from 'holo-fn';
+import { just, map } from 'holo-fn/maybe';
+import { pipe } from 'rambda';
 
 const result = pipe(
   just(10),
@@ -69,8 +70,8 @@ const result = pipe(
 ### With Arrays
 
 ```typescript
-import { pipe } from 'rambda';
 import { inspect } from 'holo-fn';
+import { pipe } from 'rambda';
 
 pipe(
   [1, 2, 3, 4],
@@ -85,8 +86,8 @@ pipe(
 ### With Plain Objects
 
 ```typescript
-import { pipe } from 'rambda';
 import { inspect } from 'holo-fn';
+import { pipe } from 'rambda';
 
 const user = pipe(
   { id: 1, name: 'Alice', age: 30 },
@@ -101,9 +102,9 @@ const user = pipe(
 ### Debugging Complex Transformations
 
 ```typescript
-import { pipe } from 'rambda';
-import { fromNullable, map, chain } from 'holo-fn/maybe';
 import { inspect } from 'holo-fn';
+import { chain, fromNullable, map } from 'holo-fn/maybe';
+import { pipe } from 'rambda';
 
 const getUserEmail = (userId: number) =>
   pipe(
@@ -120,9 +121,9 @@ const getUserEmail = (userId: number) =>
 ### Finding Where Transformations Fail
 
 ```typescript
-import { pipe } from 'rambda';
-import { fromThrowable } from 'holo-fn/result';
 import { inspect } from 'holo-fn';
+import { fromThrowable, map } from 'holo-fn/result';
+import { pipe } from 'rambda';
 
 const parseAndValidate = (input: string) =>
   pipe(
@@ -138,9 +139,9 @@ const parseAndValidate = (input: string) =>
 ### Monitoring Data Flow
 
 ```typescript
-import { pipe } from 'rambda';
-import { all } from 'holo-fn/maybe';
 import { inspect } from 'holo-fn';
+import { all, map } from 'holo-fn/maybe';
+import { pipe } from 'rambda';
 
 const results = pipe(
   [

docs/helpers/tap.md

@@ -28,7 +28,8 @@ A function that:
 ### With Maybe
 
 ```typescript
-import { just, map, tap } from "holo-fn";
+import { tap } from "holo-fn";
+import { just, map } from "holo-fn/maybe";
 import { pipe } from "rambda";
 
 const result = pipe(
@@ -45,7 +46,8 @@ const result = pipe(
 ### With Result
 
 ```typescript
-import { ok, map, tap } from "holo-fn";
+import { tap } from "holo-fn";
+import { map, ok } from "holo-fn/result";
 import { pipe } from "rambda";
 
 const result = pipe(
@@ -62,7 +64,8 @@ const result = pipe(
 ### With Either
 
 ```typescript
-import { right, map, tap } from "holo-fn";
+import { tap } from "holo-fn";
+import { map, right } from "holo-fn/either";
 import { pipe } from "rambda";
 
 const result = pipe(
@@ -234,7 +237,7 @@ TypeScript correctly infers the type through `tap`:
 const result: Maybe<number> = pipe(
   just(42),
   tap(x => console.log(x)), // x: Maybe<number>
-  map(x => x * 2)            // Type: Maybe<number>
+  map(x => x * 2)           // Type: Maybe<number>
 );
 
 // Works with union types

docs/maybe/index.md

@@ -118,14 +118,15 @@ console.log(result2); // "No value"
 Compares the values inside `this` and the other, returns `true` if both are `Nothing` or if the values are equal.
 
 ```ts
+import type { Maybe } from "holo-fn";
 import { Just, Nothing } from "holo-fn/maybe";
 
 const result1 = new Just("value").chain(v => new Just(v + " modified"));
 
 console.log(result1.equals(new Just("value"))); // false
 console.log(result1.equals(new Just("value modified"))); // true
 
-const result2 = new Just("value").chain(v => new Nothing());
+const result2: Maybe<string> = new Just("value").chain(v => new Nothing());
 console.log(result2.equals(new Nothing())); // true
 console.log(result2.equals(new Just("value"))); // false
 ```
@@ -320,10 +321,10 @@ console.log(result); // true
 Combines an array of `Maybe` values into a single `Maybe` containing an array. Returns `Just` with all values if all are `Just`, or `Nothing` if any is `Nothing`.
 
 ```ts
-import { all, just, nothing } from 'holo-fn/maybe';
+import { all, just, nothing, type Maybe } from 'holo-fn/maybe';
 
 // All success case
-const result1 = all([just(1), just(2), just(3)]);
+const result1: Maybe<number[]> = all([just(1), just(2), just(3)]);
 console.log(result1.unwrapOr([])); // [1, 2, 3]
 
 // Any failure case
@@ -344,8 +345,9 @@ console.log(result3.unwrapOr([])); // []
 When you need to work with multiple `Maybe` values:
 
 ```ts
-import { pipe } from 'rambda';
+
 import { all, just, match } from 'holo-fn/maybe';
+import { pipe } from 'rambda';
 
 const name = just('Test User');
 const age = just(25);
@@ -361,14 +363,13 @@ const user = pipe(
 
 console.log(user);
 // Output: { name: 'Test User', age: 25, email: '[email protected]' }
-
 ```
 
 ### Conditional logic with predicates
 
 ```ts
-import { pipe } from 'rambda';
 import { just, match } from 'holo-fn/maybe';
+import { pipe } from 'rambda';
 
 const value = just(42);
 
@@ -390,8 +391,8 @@ console.log(`The number is categorized as: ${category}`);
 ### Chaining operations with early exit
 
 ```ts
-import { pipe } from 'rambda';
 import { chain, filter, fromNullable, map } from 'holo-fn/maybe';
+import { pipe } from 'rambda';
 
 const user: { email?: string } | null = { email: '[email protected]' };
 

docs/result/index.md

@@ -316,6 +316,9 @@ console.log(validateAge(15)); // 0 (fails validation)
 **Common use cases:**
 
 ```ts
+import { fromThrowable, ok, validate } from "holo-fn/result";
+import { pipe } from "remeda";
+
 // Validate email format
 const validateEmail = (email: string) =>
   pipe(
@@ -325,7 +328,7 @@ const validateEmail = (email: string) =>
     validate((s) => s.includes('.'), 'Invalid domain')
   );
 
-console.log(validateEmail('test@example.com').unwrapOr('Invalid'));
+console.log(validateEmail('testexample.com').unwrapOr('Invalid'));
 
 // Parse and validate numbers
 const parsePositive = (input: string) =>
@@ -339,7 +342,7 @@ const parsePositive = (input: string) =>
   );
 
 console.log(parsePositive('42').unwrapOr(0)); // 42
-console.log(parsePositive('-5').unwrapOr(0));
+console.log(parsePositive('-5').unwrapOr(0)); // 0
 
 // Validate objects
 type User = { name: string; age: number };
@@ -399,6 +402,7 @@ Curried version of `equals` for `Result`. Compares `this` to another `Result`, r
 
 ```ts
 import { equals, Ok } from 'holo-fn/result';
+import { pipe } from 'remeda';
 
 const result1 = pipe(
   new Ok(10),
@@ -422,9 +426,10 @@ console.log(result2); // false
 Combines an array of `Result` values into a single `Result`. Returns `Ok` with all values if all are `Ok`, or `Err` with all errors if any are `Err`.
 
 ```ts
-import { all, ok, err } from 'holo-fn/result';
+import type { Result } from 'holo-fn';
+import { all, err, ok } from 'holo-fn/result';
 
-const result1 = all([ok(1), ok(2), ok(3)]);
+const result1: Result<number[], unknown[]> = all([ok(1), ok(2), ok(3)]);
 console.log(result1.unwrapOr([])); // [1, 2, 3]
 
 const result2 = all([err('Name required'), err('Email invalid'), ok(25)]);
@@ -448,9 +453,10 @@ Combines an array of `Result` values into a single `Result`, stopping at the fir
 Unlike `all` which collects all errors, `sequence` returns immediately when it finds the first `Err`.
 
 ```ts
-import { sequence, ok, err } from 'holo-fn/result';
+import type { Result } from 'holo-fn';
+import { err, ok, sequence } from 'holo-fn/result';
 
-const result1 = sequence([ok(1), ok(2), ok(3)]);
+const result1: Result<number[], unknown> = sequence([ok(1), ok(2), ok(3)]);
 console.log(result1.unwrapOr([])); // [1, 2, 3]
 
 const result2 = sequence([
@@ -461,7 +467,7 @@ const result2 = sequence([
 console.log(result2.match({
   ok: (v) => v,
   err: (e) => e
-})); // 'First error' (not an array!)
+})); // 'First error'
 ```
 
 ---
@@ -473,7 +479,7 @@ Separates an array of `Result` values into two groups: successes (`oks`) and fai
 Unlike `all` and `sequence` which return a `Result`, `partition` returns a plain object with two arrays.
 
 ```ts
-import { partition, ok, err } from 'holo-fn/result';
+import { err, ok, partition } from 'holo-fn/result';
 
 const results = [
   ok<number, string>(1),