# Differences

This shows you the differences between two versions of the page.

monadplus [2014/08/24 02:46] nikolaj created |
monadplus [2014/08/24 02:47] (current) nikolaj |
||
---|---|---|---|

Line 2: | Line 2: | ||

==== Haskell class ==== | ==== Haskell class ==== | ||

<code/Haskell> | <code/Haskell> | ||

- | class Monad m where | + | > |

- | return :: a -> m a | + | |

- | (>>=) :: m a -> (a -> m b) -> m b | + | |

</code> | </code> | ||

==== Discussion ==== | ==== Discussion ==== | ||

=== Postulates === | === Postulates === | ||

- | Right unit, left unit and associativity: | ||

- | |||

- | ^ m >>= return $\ \leftrightsquigarrow\ $ m ^ | ||

- | ^ return x >>= f $\ \leftrightsquigarrow\ $ f x ^ | ||

- | ^ (m >>= f) >>= g $\ \leftrightsquigarrow\ $ m >>= (\x -> f x >>= g) ^ | ||

- | |||

- | >In reference to [[Counit-unit adjunction]]: | ||

- | > | ||

- | >"F(f)" the progrmaming way: If fmap is the function mapping for a functor "F" for which we define >==, note that "(fmap f) mx" will be written as "mx >>= return . f". But >>= is a strong gadget, in that, of course, its second argument doesn't have to be of the form "return 'some function'". | ||

- | > | ||

- | >In Haskell, functions of several variables are implemented using lambda expressions and currying - here's how this interacts with >==: First note that the above is the same as "mx >>= \x->(return (f x))". If f is a function of two arguments x,y, then for arguments mx,my, the "lifted" function is "mx >>= \x->(my >>=\y ->(return (f x y)))". Syntactic sugar: Changing the symbols in between this expression gives Haskells do-noation "do {x <- mx; y <- my; return (f x y)}". | ||

- | > | ||

- | >liftM2 f mx my = mx >>= \x->(my >>= \y ->(return (f x y))) | ||

- | >liftM2 f mg my = mg >>= \g->(my >>= \y ->(return (f g y))) | ||

- | >liftM2 id mg my = mg >>= \g->(my >>= \y ->(return (g y))) | ||

- | ><*> mg my = mg >>= \g->(my >>= \y ->(return (g y))) | ||

- | > | ||

- | >Let $n\in\{0,1\}$. Among other things, given a function of type $a\to m^n\ b$, a monad enables you to get a function of type $m\ a\to m\ b$. | ||

- | >Consider a function space $A=a\to b$ and fix a term $p : m\ a$. Construct the higher order function $G:A\to m\ b$, which takes any function $g:A$ (for which $n=0$) and, using the monad, applies it to $p$. Next use the monad a second time, now on $G$ (which has $n=1$), to get a function from $m\ A$ to $m\ b$. Lambda abstraction over $p$ and flipping the arguments gives a function $<*> : m\ (a\to b)\to m\ a\to m\ b$. In this way, we've successfully lifted the apply function. | ||

- | >Given 'return', then 'join' (or '>>=') induces '<*>'. The converse isn't true and so the Applicative concept lies between Functor and Monad. | ||

- | > | ||

- | >Abstraction over $ma$ and flipping arguments gives a map $<*> : m (a->b)$ | ||

- | > | ||

- | >Monads sometimes have a "zero element" of monadic, acting like the multiplicative zero for bind. "Nothing" and the empty list "[]" are examples. Haskells list comprehension works by returning the empty list for elements x where a predicate returns false. | ||

=== Associated methods === | === Associated methods === | ||

Line 40: | Line 14: | ||

==== Parents ==== | ==== Parents ==== | ||

=== Subset of === | === Subset of === | ||

- | [[Applicative]] | + | [[Monad . Haskell]] |