Sun Apr 8 11:18:39 CEST 2012
Experimenting with Applicative
EDIT: Probably mostly meaningless..
Let's play with this a bit. Take the Functor (s ->). A functor value
F o is then (s -> o), i.e. an output where state is abstracted. The
<*> for the Applicative version of this would chain together
(s -> (i -> o))
(s -> i)
(s -> o)
This is actually the environment variable from . Can this
implement state machines? Doesn't look like it because 's' can't
depend on the valueo of the i->o or i types, because those types are
completely general (container!) and thus not accessible to the
implementation of <*>. What could happen though is a fixed update
s->s that's applied on every <*>, i.e. the increment of a counter.
Let's construct an example of "just" threading state.
data Thread s a = Thread (s -> s) a
runThread (Thread inc a) = (a, inc 0)
appThread :: Thread s (a -> b) -> Thread s a -> Thread s b
appThread (Thread cf f) (Thread ca a) = Thread cb b where
b = f a
cb = ca . cf
instance Applicative (Thread s) where
(<*>) = appThread
pure a = Thread (\n -> n) a
instance Functor (Thread s) where
fmap f = (pure f <*>)
An example of this would be a counter, wich counts the number of
elements used in a computation.
makeCount x = Thread (\n -> n + 1) x