## Practical Payoffs

### Before: Nested Null Checks

```typescript
function processUser(id: string) {
const user = getUser(id);
if (user === null) return null;

const profile = getProfile(user.profileId);
if (profile === null) return null;

return formatOutput(user, profile);
}
```

### After: Monadic Composition

```typescript
const processUser = (id: string) =>
getUser(id)
.flatMap(user => getProfile(user.profileId))
.map(profile => formatOutput(profile));
```

The monad laws **guarantee** safe refactoring. You're relying on mathematics, not convention.

## Project Structure

## Installation

```bash
npm install
npm run build
npm test
```

## Usage

```typescript
import {
// Core
morphism, compose, identity, pipe,
// Option monad
some, none, isSome, OptionMonad,
// Either monad
left, right, isRight, EitherMonad,
// Other monads
ReaderMonad, StateMonad, IOMonad,
// Law verification
checkFunctorLaws, checkMonadLaws,
} from 'category-theory-js';

// Create morphisms with explicit types
const double = morphism('number', 'number', (x: number) => x * 2);
const toString = morphism('number', 'string', (x: number) => `Value: ${x}`);

// Compose them (right-to-left, mathematical style)
const doubleAndStringify = compose(toString, double);
console.log(doubleAndStringify.apply(21)); // "Value: 42"

// Option monad - safe null handling
const safeDivide = (a: number, b: number) =>
b === 0 ? none : some(a / b);

const result = OptionMonad.flatMap(
OptionMonad.flatMap(some(10), x => safeDivide(x, 2)),
x => safeDivide(x, 5)
);
console.log(result); // { _tag: 'Some', value: 1 }

// Either monad - typed error handling
const parseNumber = (s: string) => {
const n = parseFloat(s);
return isNaN(n) ? left('Not a number') : right(n);
};

const parsed = EitherMonad.flatMap(
parseNumber('42'),
n => right(n * 2)
);
console.log(parsed); // { _tag: 'Right', right: 84 }
```

## Available Monads

## The Laws (Testable!)

```typescript
import {
checkFunctorLaws,
checkMonadLaws,
verifyNaturality,
checkAdjunctionLaws,
} from 'category-theory-js';

// Verify functor laws for Array
const functorResult = checkFunctorLaws(
'Array',
{ fmap: (arr, f) => arr.map(f) },
[
{ value: [1, 2, 3], f: (x: number) => x * 2, g: (x: number) => x + 1 }
]
);
console.log(functorResult.passed); // true

// Verify monad laws for Option
const monadResult = checkMonadLaws(
'Option',
OptionMonad,
[{
value: 5,
monadicValue: some(5),
f: (x: number) => some(x * 2),
g: (x: number) => some(x + 1),
}]
);
console.log(monadResult.passed); // true
// Results include: Left Identity, Right Identity, Associativity
```

### The Three Monad Laws

1. **Left Identity**: `pure(a).flatMap(f) === f(a)`
2. **Right Identity**: `m.flatMap(pure) === m`
3. **Associativity**: `m.flatMap(f).flatMap(g) === m.flatMap(x => f(x).flatMap(g))`

## Yoneda Lemma

The Yoneda lemma is one of the most profound results in category theory. In programming terms:

```typescript
import {
toYoneda, fromYoneda, yonedaMap,
cont, contMap, contFlatMap, runCont,
demonstrateFusion,
} from 'category-theory-js';

// Yoneda gives you FREE functor mapping through function composition
// Multiple maps fuse into a single traversal:

const result = demonstrateFusion(
[1, 2, 3],
x => x * 2, // double
x => x + 1, // increment
x => x * x // square
);
// Without fusion: 3 traversals
// With Yoneda: 1 traversal with composed function (x => ((x * 2) + 1)²)
console.log(result.isEqual); // true

const computation = contFlatMap(
contFlatMap(cont(10), x => cont(x * 2)),
x => cont(x + 5)
);
console.log(runCont(computation)); // 25
```

**Why it matters:**
- **CPS is Yoneda**: Continuation-passing style is the Yoneda embedding
- **Fusion**: Multiple `map` calls become one traversal
- **Coyoneda**: Get a functor instance for ANY type, for free

## Further Reading

- [Category Theory for Programmers](https://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/) - Bartosz Milewski
- [fp-ts](https://gcanti.github.io/fp-ts/) - Functional programming in TypeScript
- [Effect](https://effect.website/) - A powerful effect system for TypeScript
- [Professor Frisby's Mostly Adequate Guide](https://mostly-adequate.gitbook.io/mostly-adequate-guide/)

## Related

- [Blog post: Category Theory for JavaScript/TypeScript Developers](https://ibrahimcesar.cloud/blog/category-theory-for-javascript-typescript-developers)

## License