# Category Theory

# Category Theory

## Rules

- There are
`objects`

and`arrows`

(morphisms) - Composition:
- If there’s a morphism
`f`

from`A`

to`B`

, and there’s a morphism`g`

from

`B`

to`C`

, there must be a morphism from`A`

to`C`

(`g . f`

). `const compose = (f, g) => (x) => f(g(x))`

- If there’s a morphism
- Associativity of composition:
`(h . g) . f == h . (g . f)`

- Identity: For each
`A`

there must be a morphism from`A`

to`A`

.`const id = a => a`

## Types

Types are sets of values>

In Set, objects are sets and morphisms are functions, and idenity maps each

element to a set of itself.

Bottom (`⊥`

) is a value in every type, corresponding to a non-terminating

computation. Functions that can return bottom are partial functions.

`Void`

is a type with no values (empty set). There’s only one function that can

return `Void`

, which is an idenity of `Void`

:

```
voidIdentity :: Void -> Void
voidIdentity a = a
```

`()`

is called ‘unit,’ which is similar to `void`

in imperative languages (think

C++). Usually used for functions with side effects or that discard arguments.

```
foo :: Char -> ()
foo _ = ()
```

There are two possible functions that just take a `Bool`

and return a `Bool`

:

```
const id = a => a
// id(true) -> true
const not = a => !a
// not(true) -> false
```

## Orders

- Preorder is a category where morphisms are relations of being less than or

equal. - Partial order is preorder where for all
`a <= b`

and`b <= a`

,`a == b`

. - Linear order (aka total order) is partual order where any two objects are in a

relation with each other, one way or another. - Hom-set is a set of all morphisms from
`a`

to`b`

in category`C`

(`C(a, b)`

).

## Monoid as Set

Monoid is a set with binary operation which is associative, and there must be a

`unit`

in the set.

```
-- the Monoid type class:
class Monoid m where
mempty :: m
mappend :: m -> m -> m
```

## Misc

```
const left = a => ({ type: 'left', value: a })
const right = a => ({ type: 'right', value: a })
const m = e => {
if (e.type === 'left') return e.value
else return e.value ? 0 : 1
}
```