# 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 2014/08/24 02:47 nikolaj 2014/08/24 02:46 nikolaj created 2014/08/24 02:47 nikolaj 2014/08/24 02:46 nikolaj created 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 + ​ ==== 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]]