docs: update docs

Author: richecr

README.md

@@ -39,13 +39,15 @@ npm install holo-fn
 ### Safe object access
 
 ```ts
+import { fromNullable, matchM } from 'holo-fn/maybe';
+
 const double = (n: number) => n * 2;
 
 const result = pipe(
   [5, 5, 6],
   (ns) => fromNullable(head(ns)),
   (x) => x.map(double),
-  M.matchM({
+  matchM({
     just: (n) => n,
     nothing: () => -1
   })
@@ -57,11 +59,18 @@ console.log(result); // 10
 ### Optional parsing
 
 ```ts
+import { fromNullable } from 'holo-fn/maybe';
+
 const parsePrice = (input: string) =>
   fromNullable(parseFloat(input))
     .map(n => (n > 0 ? n : null))
     .chain(fromNullable)
     .unwrapOr(0)
+
+console.log(parsePrice('123.45')) // 123.45
+console.log(parsePrice('0')) // 0
+console.log(parsePrice('-123.45')) // 0
+console.log(parsePrice('abc')) // 0
 ```
 
 ---

docs/either/index.md

@@ -3,11 +3,13 @@
 `Either` is used for computations that may fail. It is either a `Left<L>` (error) or a `Right<R>` (success).
 
 ```ts
-import { Right, Left, tryCatch } from 'holo-fn/either'
+import { Right } from 'holo-fn/either'
 
 const result = new Right<number, number>(10)
   .map(n => n * 2)
-  .unwrapOr(0) // 20
+  .unwrapOr(0)
+
+console.log(result); // 20
 ```
 
 ## Methods
@@ -42,9 +44,13 @@ Wraps a potentially throwing function in an `Either`.
 ```ts
 import { tryCatch } from 'holo-fn/either'
 
+const input = '{"user": "John Doe"}'
+
 const parsed = tryCatch(() => JSON.parse(input), e => 'Invalid JSON')
   .map(obj => obj.user)
   .unwrapOr('anonymous')
+
+console.log(parsed) // John Doe
 ```
 
 - Returns `Right<R>` if `fn()` succeeds
@@ -61,6 +67,8 @@ import { fromPromise } from 'holo-fn/either'
 
 const result = await fromPromise(fetch('/api'), e => 'Network error')
 
+console.log(result) // _Left { value: 'Network error' }
+
 ```
 
 - Resolves to `Right<R>` on success
@@ -77,6 +85,8 @@ import { fromAsync } from 'holo-fn/either'
 
 const result = await fromAsync(async () => await fetch('/api'), e => 'Request failed')
 
+console.log(result) // _Left { value: 'Request failed' }
+
 ```
 
 - Allows deferred execution
@@ -91,7 +101,7 @@ const result = await fromAsync(async () => await fetch('/api'), e => 'Request fa
 Curried version of `map` for `Either`. This allows functional composition with `pipe`.
 
 ```ts
-import { mapE } from 'holo-fn/either';
+import { mapE, Right } from 'holo-fn/either';
 
 const result = pipe(
   new Right(5),
@@ -109,15 +119,15 @@ console.log(result); // 10
 Curried version of `mapLeft` for `Either`. This allows mapping over the Left value in a functional pipeline.
 
 ```ts
-import { mapLeftE } from 'holo-fn/either';
+import { Left, mapLeftE } from 'holo-fn/either';
 
 const result = pipe(
   new Left("Error"),
   mapLeftE((e) => `Mapped error: ${e}`),
   (res) => res.unwrapOr("No value") 
 );
 
-console.log(result); // "Mapped error: Error"
+console.log(result); // "No value"
 ```
 
 ---
@@ -127,9 +137,7 @@ console.log(result); // "Mapped error: Error"
 Curried version of `chain` for `Either`. This allows chaining transformations on the **Right** value of `Either`, using a functional composition style.
 
 ```ts
-import { Right, Left, chainE } from 'holo-fn/either';
-
-const double = (n: number) => n * 2;
+import { Right, chainE } from 'holo-fn/either';
 
 const result = pipe(
   new Right(5),
@@ -147,11 +155,11 @@ console.log(result); // 10
 Curried version of `unwrapOr` for `Either`. This provides a cleaner way to unwrap the value in a `Either`, returning a default value if it's `Left`.
 
 ```ts
-import { unwrapOrE } from 'holo-fn/either';
+import { Left, unwrapOrE } from 'holo-fn/either';
 
 const result = pipe(
   new Left("Fail"),
-  unwrapOrE("No value")
+  unwrapOrE<string, unknown>("No value")
 );
 
 console.log(result); // "No value"
@@ -164,7 +172,7 @@ console.log(result); // "No value"
 Curried version of `match` for `Either`. This allows handling `Left` and `Right` in a functional way.
 
 ```ts
-import { matchE } from 'holo-fn/either';
+import { matchE, Right } from 'holo-fn/either';
 
 const result = pipe(
   new Right(10),

docs/maybe/index.md

@@ -8,6 +8,8 @@ import { fromNullable } from 'holo-fn/maybe'
 const name = fromNullable('Rich')
   .map(n => n.toUpperCase())
   .unwrapOr('Anonymous')
+
+console.log(name) // RICH
 ```
 
 ## Methods
@@ -52,7 +54,7 @@ const maybeEmail = fromNullable(user.email)
 Curried version of `map` for `Maybe`. This allows functional composition with `pipe`.
 
 ```ts
-import { mapM } from 'holo-fn/maybe';
+import { Just, mapM } from 'holo-fn/maybe';
 
 const result = pipe(
   new Just(10),
@@ -70,7 +72,7 @@ console.log(result); // 20
 Curried version of `chain` for `Maybe`. This allows chaining transformations in a functional pipeline.
 
 ```ts
-import { chainM } from 'holo-fn/maybe';
+import { chainM, Just } from 'holo-fn/maybe';
 
 const result = pipe(
   new Just(2),
@@ -88,10 +90,10 @@ console.log(result); // 20
 Curried version of `unwrapOr` for `Maybe`. This provides a cleaner way to unwrap the value in a `Maybe`.
 
 ```ts
-import { unwrapOrM } from 'holo-fn/maybe';
+import { Nothing, unwrapOrM } from 'holo-fn/maybe';
 
 const result = pipe(
-  new Nothing(),
+  new Nothing<string>(),
   unwrapOrM("No value")
 );
 
@@ -105,7 +107,7 @@ console.log(result); // "No value"
 Curried version of `match` for `Maybe`. This allows handling `Just` and `Nothing` in a functional way.
 
 ```ts
-import { matchM } from 'holo-fn/maybe';
+import { Just, matchM } from 'holo-fn/maybe';
 
 const result = pipe(
   new Just("hello"),

docs/result/index.md

@@ -3,11 +3,13 @@
 `Result` is used to represent computations that either succeed with a value (`Ok<T>`) or fail with an error (`Err<E>`).
 
 ```ts
-import { Ok, Err, fromThrowable, fromPromise, fromAsync } from 'holo-fn/result'
+import { Ok } from 'holo-fn/result'
 
 const result = new Ok<number, string>(10)
   .map(n => n + 1)
-  .unwrapOr(0) // 11
+  .unwrapOr(0)
+
+console.log(result) // 11
 ```
 
 ## Methods
@@ -40,7 +42,13 @@ Matches the value to execute either the `ok` or `err` case.
 Wraps a synchronous function in a `Result`.
 
 ```ts
+import { fromThrowable } from 'holo-fn';
+
+const input = '{"name": "John", "age": 30}'
+
 const result = fromThrowable(() => JSON.parse(input), e => 'Invalid JSON')
+
+console.log(result) // _Ok { value: { name: 'John', age: 30 } }
 ```
 
 - Returns `Ok<T>` if `fn()` succeeds
@@ -51,7 +59,11 @@ const result = fromThrowable(() => JSON.parse(input), e => 'Invalid JSON')
 Wraps a `Promise<T>` into a `Promise<Result<T, E>>`.
 
 ```ts
+import { fromPromise } from 'holo-fn/result';
+
 const result = await fromPromise(fetch('/api'), e => 'Network error')
+
+console.log(result) // _Err { error: 'Network error' }
 ```
 
 - Resolves to `Ok<T>` on success
@@ -62,7 +74,11 @@ const result = await fromPromise(fetch('/api'), e => 'Network error')
 Same as `fromPromise`, but lazy — receives a function returning a Promise.
 
 ```ts
+import { fromAsync } from 'holo-fn/result';
+
 const result = await fromAsync(() => fetch('/api'), e => 'Request failed')
+
+console.log(result) // _Err { error: 'Request failed' }
 ```
 
 - Allows deferred execution
@@ -77,7 +93,7 @@ const result = await fromAsync(() => fetch('/api'), e => 'Request failed')
 Curried version of the `map` function for `Result`. This allows you to apply a transformation to the **Ok** value in a more functional style.
 
 ```ts
-import { mapR } from 'holo-fn/result';
+import { mapR, Ok } from 'holo-fn/result';
 
 const result = pipe(
   new Ok(5),
@@ -95,15 +111,15 @@ console.log(result); // 10
 Curried version of `mapErr` for `Result`. This allows handling errors in a more functional composition style.
 
 ```ts
-import { mapErrR } from 'holo-fn/result';
+import { Err, mapErrR } from 'holo-fn/result';
 
 const result = pipe(
   new Err("Error"),
   mapErrR((e) => `Mapped error: ${e}`),
   (res) => res.unwrapOr("No value")
 );
 
-console.log(result); // "Mapped error: Error"
+console.log(result); // "No value"
 ```
 
 ---
@@ -113,7 +129,7 @@ console.log(result); // "Mapped error: Error"
 Curried version of `chain` for `Result`. This allows you to chain transformations on the Ok value in a functional pipeline.
 
 ```ts
-import { chainR } from 'holo-fn/result';
+import { chainR, Ok } from 'holo-fn/result';
 
 const result = pipe(
   new Ok(10),
@@ -131,7 +147,7 @@ console.log(result); // 15
 Curried version of `unwrapOr` for `Result`. This provides a cleaner way to unwrap the value in a `Result`, returning a default value if it's `Err`.
 
 ```ts
-import { unwrapOrR } from 'holo-fn/result';
+import { Ok, unwrapOrR } from 'holo-fn/result';
 
 const result = pipe(
   new Ok(42),
@@ -148,7 +164,7 @@ console.log(result); // 42
 Curried version of `match` for `Result`. This allows you to handle both `Ok` and `Err` in a functional way, providing a clean way to handle both cases.
 
 ```ts
-import { matchR } from 'holo-fn/result';
+import { matchR, Ok } from 'holo-fn/result';
 
 const result = pipe(
   new Ok(10),