<p dir="ltr">Does it help if I bring your:</p>
<p dir="ltr">(\x -> x+7) <$> (+3) => (+10)</p>
<p dir="ltr">It doesn't magically become `(+10)`. The previous step unseen is `(+7) . (+3)`. fmap for ((->) r) is defined as function composition `.`.</p>
<p dir="ltr">fmap f g = f . g</p>
<p dir="ltr">You can think of functors as containers or contexts; both analogies work well up to some degree (with the latter maybe more abstract and thus flexible).</p>
<p dir="ltr">Another small terminology tip that could help you with your thinkering might be to call ((->) r) a partially applied function. Suddently, it narrows how you can potentially use/combine them.</p>
<p dir="ltr">Last tip, Monad ((->) r) is commonly refered to as the Reader monad. Example of how it'd be used:</p>
<p dir="ltr">doThings = do<br>
a <- (*2)<br>
b <- (+10)<br>
return (a + b)</p>
<p dir="ltr">Notice how we can work with partially applied functions to which something have yet to be applied and create a new partial function whose argument is going to fill all the open holes.</p>
<p dir="ltr">This isn't easy to explain without looking at the types of everything, so I encourage you to write it down and work out the types (:</p>
<p dir="ltr">Alex</p>
<div class="gmail_quote">On Jun 4, 2016 12:41 AM, "Raja" <<a href="mailto:rajasharan@gmail.com">rajasharan@gmail.com</a>> wrote:<br type="attribution"><blockquote class="quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir="ltr"><div><br></div><div>Everyone agrees ((->) r) is a Functor, an Applicative and a Monad but I've never seen any good writeup going into details of explaining this.<br></div><div><br>So I was trying to brainstorm with my brother and went pretty far into the concept for quite a few hours, but still got stuck when it came to Monads.</div><div><br></div><div>Before I showcase the question/problem I wanted to share our thinking process.<br><br>Lets stick with common types like Maybe a, [a], simple function (a -> b)</div><div><br></div><div>**Everything is a Container**</div><div><br> Just 4 => this is a container wrapping some value<br>[1,2,3] => this is a container wrapping bunch of values</div><div>(+3) => this is a container wrapping domains & ranges (infinite dictionary)</div><div><br></div><div>**When is a Container a Functor**</div><div><br></div><div>If we can peek inside a container and apply a simple function (a->b) to each of its values and wrap the result back inside the container, then it becomes a Functor.</div><div><br></div><div>Let's use (\x -> x+7) as simple function along with above three Containers</div><div><br></div><div>(\x -> x+7) <$> Just 4 => Just 11</div><div>(\x -> x+7) <$> [1,2,3] => [8,9,10]</div><div>(\x -> x+7) <$> (+3) => (+10) -- well there is no Show defined but you get the idea</div><div><br></div><div>**When is a Container an Applicative**</div><div><br></div><div>The simple function from above is also now wrapped inside a container and we should be able to peek to use it just like functor. Also lets simplify (\x -> x+7) to (+7).</div><div><br></div><div>Just (+7) <*> Just 4 => Just 11</div><div>[(+7)] <*> [1,2,3] => [8,9,10]</div><div>(\x -> (+7)) <*> (+3) => (+10) -- again no Show defined but works when pass a number</div><div>-- but (+7) still needs to be wrapped in a Container though</div><div><br></div><div>**When is a Container a Monad**</div><div><br></div><div>This time we don't have a simple function (a->b) instead we have a non-simple function (a -> Container). But rest stays almost the same. </div><div><br></div><div>We have to first peek inside a container and apply non-simple function to each of its values. Since its a non-simple function we need to collect all the returned Containers, unwrap them and wrap them all back in a Container again. </div><div>(it almost feels like unwrap and wrapping them back is going to complicate things)</div><div><br></div><div>Also Non-simple function cannot be reused as is for all three Containers like in Functors & Applicatives.</div><div><br></div><div>Just 4 >>= (\x -> Just (x+7)) => Just 11</div><div>[1,2,3] >>= (\x -> [x+7]) => [8,9,10]</div><div>(+3) >>= (\x -> (+7)) => (+7) </div><div><br></div><div>Wait a minute ... the last line doesn't look right. Or should I say it doesn't feel right to discard the `x' altogether. </div><div><br></div><div>OK let's jump to do this:</div><div>(+3) >>= (\x -> (+x)) => ??? -- apparently this solves for the equation: f(x) = 2x + 3</div><div><br></div><div>(is 2x + 3 obvious for anyone??? it took us way longer to derive it)</div><div>(Does it have anything to do with Monad laws by any chance?)</div><div><br></div><div>This is where it feels like "Functions as containers" concept starts to breakdown; its not the right analogy for Monads. </div><div><br></div><div>What does it even mean to unwrap a bunch of functions and wrap them back again?</div><div><br></div><div>Hope this intrigues some of you as it did to us. Any thoughts and comments greatly appreciated.</div><div><br></div><div>Thanks,</div><div>Raja</div></div>
<br>_______________________________________________<br>
Beginners mailing list<br>
<a href="mailto:Beginners@haskell.org">Beginners@haskell.org</a><br>
<a href="http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners" rel="noreferrer" target="_blank">http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners</a><br>
<br></blockquote></div>