`foo :: Maybe a -> [a]`

will automatically be a nautral transformation (?)
Let's try and check if the list functor is representable. If I pick `foo :: (Integer -> x) -> [x]`

this direction can be implemented as `foo f = fmap f [0,1..]`

. On the other hand, the
other way round does not work: `foo:: [x] -> (Integer -> x)`

can't always be implemented. It's
not representable (proof by haskell intuition).
```
{-# LANGUAGE ExplicitForAll #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE InstanceSigs #-}
type Hom a b = a -> b
type Nat f g = forall x. f x -> g x
class Representable f where
type Rep f :: * -- the representing object o whose Hom(o, -) ~= f
-- tabulate :: Nat (Hom (Rep f)) f
-- tabulate :: forall x. Hom (Rep f) x -> f x
tabulate :: forall x. ((Rep f -> x)) -> f x
-- index :: Nat f (Hom (Rep f))
-- index :: forall x. f x -> (Hom (Rep f) x)
index :: forall x. f x -> (Rep f -> x)
```

`Stream`

is representable:
```
data Stream a = Cons a (Stream a)
instance Representable Stream where
type Rep Stream = Integer
tabulate i2x = go i2x 0 where
go :: (Integer -> x) -> Integer -> Stream x
go f i = Cons (f i) (go f (i+1))
index :: Stream x -> Integer -> x
index (Cons x xs) n = case n of 0 -> x; not0 -> index xs (n-1)
```

In general, things that are products tend to be representable, while things
that are sums tend not to.
```
C | c -a→ d
Set | P(c) -P(a)→ P(d)
Set | u ∈ P(c) -P(a)→ d ∋ P(a)(u)
el P | (c∈C, u∈P(c))
el P | (c∈C, u∈P(c)) -el a→ (d∈C, P(a)(u)∈P(d))
```

So, this category gives us a way to "locate ourselves" within the set $P(c)$, which will be instrumental
in creating the arrows (natural transformations) of the form $Hom(c_j, -) \rightarrow P(c_j)$, as asked of us by the cocone.
This also hints at why we use colimis and not limits: because the yoneda goes from the $Hom(c_j, -)$ to $P$, we can only conjure
arrows into $P$ via Yoneda, thereby forcing us to use a colimit.
We claim that we should choose the diagram category as $J\equiv el(P)$, with the diagram functor $dgrm: el(P) \rightarrow [C, Set]$ given
by $dgrm(c \in C, u \in P(c)) : el(P) \equiv Hom(c, -) : [C, Set]$. This embeds $(c, u \in P(C))$ where $u$ is a way to locate $P$'s
view of $C$ as a Hom-set $Hom(c -)$. To give the natural transformation from the image of the diagram to the apex of the cocone $P$,
we use Yoneda: We need an arrow $Hom(c, -) \rightarrow P$, which we know is in bijection with elements of $P(c)$ through yoneda.
Luckily, we have $u \in P(c))$ to invoke yoneda, so we build the arrows from $dgrm(c, u) = Hom(c, -)$ to $P$,
given by applying Yoneda to $u \in P(c)$. Thus, we can at least form a cocone. Whether the arrows of the base of
the cocone commute with the apex-pointing arrows, and whether this is universal is to be checked next.
Given some other cocone $Q \in [C, Set]$, with co-cone morphisms $\sigma_j: Hom(c_j, -) \rightarrow Q$, we need to
create a natural transformation $\theta: P \rightarrow Q$. Let's do this pointwise. for some $c \in C$,
we need to build a map $\theta_c: P(c) \rightarrow Q(c)$. Since the domain and codomain are pointwise,
let's pick some element $x \in P(c)$. See that this can be seen as an element $(c \in C, x \in P(c)$ which is
an element of the category $el(P)$. But, recall that this was our index category $el(P)$. Thus, there is going
to be an arrow $dgrm((c \in C, x \in P(c)) = Hom(c, -) \xrightarrow{q(c,x)} Q$ since $Q$ is a cocone.
But since $q(c, x) \in [Hom(c, -), Q]$, it's an element of $Q(c)$. We have thus found a way to map $P(c)$ into $Q(c)$
by "pulling back" into the index category and then "pushing forward" via Yoneda. [What the fuck is actually happening here?]
- Reference
- Density theorem proof#Proof)