# 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))`
• 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
}
``````