Tillmann Rendel wrote:
Seriously, what are you talking about? The haddock page for
Control.Applicative hoogle links to begins with
This module describes a structure intermediate between a functor and
a monad: it provides pure expressions and sequencing, but no binding.
(Technically, a strong lax monoidal functor.) For more details, see
Applicative Programming with Effects, by Conor McBride and Ross
Paterson, online at
http://www.soi.city.ac.uk/~ross/papers/Applicative.html.
This interface was introduced for parsers by Niklas Röjemo, because
it admits more sharing than the monadic interface. The names here are
mostly based on recent parsing work by Doaitse Swierstra.
This class is also useful with instances of the Traversable class.
I agree that this is hard to understand, but it's more then just
"strong lax monoidal functor", isn't it? More importantly, there is a
reference to a wonderful and easy to read paper. (easy in the "easy
for Haskell programmers" sense, not in the "easy for the authors, and
maybe the inventors of Haskell" sense). Just give it a try.
Just in case you missed the link for some reason, here is it again:
http://www.soi.city.ac.uk/~ross/papers/Applicative.html
You must have a radically different idea of "easy to read paper" than I
have. ;-)
Anyway, after multiple hours of staring at this paper and watching
intricate type signatures swim before my eyes, I simply ended up being
highly confused. (I especially like the way that what's described in the
paper doesn't quite match what's in the actual Haskell standard
libraries...) After many hours of thinking about this, I eventually
began to vaguely comprehend what it's saying. (I suspect the problem is
that, rather like monads, the concepts it's attempting to explain are
just so extremely abstract that it's hard to develop an intuitive notion
about them.)
So... something that's "applicative" is sort-of like a monad, but where
the next action cannot vary depending on the result of some prior
action? Is that about the size of it? (If so, why didn't you just *say* so?)
But on the other hand, that would seem to imply that every monad is
trivially applicative, yet studying the libraries this is not the case.
Indeed several of the libraries seem to go out of their way to implement
duplicate functionallity for monad and applicative. (Hence the sea of
identical and nearly identical type sigantures for functions with
totally different names that had me confused for so long.)
If you think in terms of containers, then "c x" is a container of "x
values". Then, the type signature
sequence :: c1 (c2 x) -> c2 (c1 x)
kind-of makes sense. (Obviously the two containers are constrained to
particular classes.) So that's "traversable", is it?
Again, we have "sequence" and "sequenceA", indicating that monads and
applicatives aren't actually the same somehow. Also, before you can put
anything into Traversable, it has to be in Functor (no hardship there)
and Foldable. Foldable seems simplish, except that it refers to some odd
"monoid" class that looks suspiciously like "MonadPlus" but isn't... wuh?
OK, maybe I should just stop attempting to comprehend this stuff and
write the code... At this point learning about applicative and
traversable isn't actually solving my problem.
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
