Having briefly looked at Haskell recently, what would be a *brief, succinct, practical* explanation as to what a monad essentially is?

I have found most explanations I&#39;ve come across to be fairly inaccessible and lacking in practical detail.


What is a monad?

**In terms that an OOP programmer would understand (without any functional programming background), what is a monad?**

What problem does it solve and what are the most common places it&#39;s used?

### Update

To clarify the kind of understanding I was looking for, let’s say you were converting an FP application that had monads into an OOP application. What would you do to port the responsibilities of the monads to the OOP app?


Monad in plain English? (For the OOP programmer with no FP background)

Who first said the following?

&gt; A monad is just a monoid in the
&gt; category of endofunctors, what&#39;s the
&gt; problem?

And on a less important note, is this true and if so could you give an explanation (hopefully one that can be understood by someone who doesn&#39;t have much Haskell experience)?


A monad is just a monoid in the category of endofunctors, what&#39;s the problem?

What is a good way to design/structure large functional programs, especially in Haskell?

I&#39;ve been through a bunch of the tutorials (Write Yourself a Scheme being my favorite, with Real World Haskell a close second) - but most of the programs are relatively small, and single-purpose.  Additionally, I don&#39;t consider some of them to be particularly elegant (for example, the vast lookup tables in WYAS).

I&#39;m now wanting to write larger programs, with more moving parts - acquiring data from a variety of different sources, cleaning it, processing it in various ways, displaying it in user interfaces, persisting it, communicating over networks, etc.  How could one best structure such code to be legible, maintainable, and adaptable to changing requirements?

There is quite a large literature addressing these questions for large object-oriented imperative programs. Ideas like MVC, design patterns, etc. are decent prescriptions for realizing broad goals like separation of concerns and reusability in an OO style.  Additionally, newer imperative languages lend themselves to a &#39;design as you grow&#39; style of refactoring to which, in my novice opinion, Haskell appears less well-suited.

Is there an equivalent literature for Haskell?  How is the zoo of exotic control structures available in functional programming (monads, arrows, applicative, etc.) best employed for this purpose? What best practices could you recommend?

Thanks!

EDIT (this is a follow-up to Don Stewart&#39;s answer):

@dons mentioned: &quot;Monads capture key architectural designs in types.&quot;

I guess my question is: how should one think about key architectural designs in a pure functional language?

Consider the example of several data streams, and several processing steps.  I can write modular parsers for the data streams to a set of data structures, and I can implement each processing step as a pure function.  The processing steps required for one piece of data will depend on its value and others&#39;.  Some of the steps should be followed by side-effects like GUI updates or database queries.

What&#39;s the &#39;Right&#39; way to tie the data and the parsing steps in a nice way?  One could write a big function which does the right thing for the various data types.  Or one could use a monad to keep track of what&#39;s been processed so far and have each processing step get whatever it needs next from the monad state.  Or one could write largely separate programs and send messages around (I don&#39;t much like this option).

The slides he linked have a Things we Need bullet: &quot;Idioms for mapping design onto 
types/functions/classes/monads&quot;.  What are the idioms? :)


Large-scale design in Haskell?

If I have an `EnumeratorT` and a corresponding `IterateeT` I can run them together:

    val en: EnumeratorT[String, Task] = EnumeratorT.enumList(List(&quot;a&quot;, &quot;b&quot;, &quot;c&quot;))
    val it: IterateeT[String, Task, Int] = IterateeT.length
    
    (it &amp;= en).run : Task[Int]

If the enumerator monad is &quot;bigger&quot; than the iteratee monad, I can use `up` or, more generally, `Hoist` to &quot;lift&quot; the iteratee to match:

    val en: EnumeratorT[String, Task] = ...
    val it: IterateeT[String, Id, Int] = ...
    
    val liftedIt = IterateeT.IterateeTMonadTrans[String].hoist(
      implicitly[Task |&gt;=| Id]).apply(it)
    (liftedIt &amp;= en).run: Task[Int]

But what do I do when the iteratee monad is &quot;bigger&quot; than the enumerator monad?

    val en: EnumeratorT[String, Id] = ...
    val it: IterateeT[String, Task, Int] = ...
    
    it &amp;= ???

There doesn&#39;t seem to be a `Hoist` instance for `EnumeratorT`, nor any obvious &quot;lift&quot; method.

Scalaz iteratees: &quot;Lifting&quot; `EnumeratorT` to match `IterateeT` for a &quot;bigger&quot; monad

I&#39;ve seen the term *Free Monad* pop up [every](http://www.haskellforall.com/2012/07/purify-code-using-free-monads.html) [now](http://www.haskell.org/haskellwiki/Free_monad) [and](http://www.haskell.org/pipermail/haskell-cafe/2010-January/072454.html) [then](http://comonad.com/reader/2011/free-monads-for-less/) for some time, but everyone just seems to use/discuss them without giving an explanation of what they are. So: what are free monads? (I&#39;d say I&#39;m familiar with monads and the Haskell basics, but have only a very rough knowledge of category theory.)

What are free monads?

In my humble opinion the answers to the famous question [&quot;What is a monad?&quot;][1], especially the most voted ones, try to explain what is a monad without clearly explaining *why monads are really necessary*.  Can they be explained as the solution to a problem?

  [1]: https://stackoverflow.com/questions/44965/what-is-a-monad

Why do we need monads?

While explaining to someone what a type class X is I struggle to find good examples of data structures which are exactly X.

So, I request examples for:

* A type constructor which is not a Functor.
* A type constructor which is a Functor, but not Applicative.
* A type constructor which is an Applicative, but is not a Monad.
* A type constructor which is a Monad.

I think there are plenty examples of Monad everywhere, but a good example of Monad with some relation to previous examples could complete the picture.

I look for examples which would be similar to each other, differing only in aspects important for belonging to the particular type class.

If one could manage to sneak up an example of Arrow somewhere in this hierarchy (is it between Applicative and Monad?), that would be great too!

Good examples of Not a Functor/Functor/Applicative/Monad?

There is a lot of talk about monads these days. I have read a few articles / blog posts, but I can&#39;t go far enough with their examples to fully grasp the concept. The reason is that monads are a functional language concept, and thus the examples are in languages I haven&#39;t worked with (since I haven&#39;t used a functional language in depth). I can&#39;t grasp the syntax deeply enough to follow the articles fully ... but I can tell there&#39;s something worth understanding there.
 
However, I know C# pretty well, including lambda expressions and other functional features. I know C# only has a subset of functional features, and so maybe monads can&#39;t be expressed in C#.

However, surely it is possible to convey the concept? At least I hope so. Maybe you can present a C# example as a foundation, and then describe what a C# developer would **wish** he could do from there but can&#39;t because the language lacks functional programming features. This would be fantastic, because it would convey the intent and benefits of monads. So here&#39;s my question: **What is the best explanation you can give of monads to a C# 3 developer?**

Thanks!

(EDIT: By the way, I know there are at least 3 &quot;what is a monad&quot; questions already on SO. However, I face the same problem with them ... so this question is needed imo, because of the C#-developer focus. Thanks.)

In C#, What is a monad?

Could anyone give some pointers on why the impure computations in Haskell are modelled as monads?

I mean monad is just an interface with 4 operations, so what was the reasoning to modelling side-effects in it? 


Why are side-effects modeled as monads in Haskell?

The reader monad is so complex and seems to be useless. In an imperative language like Java or C++, there is no equivalent concept for the reader monad, if I am not mistaken.

Can you give me a simple example and clear this up a little bit?


What is the purpose of the reader monad?

&gt; Applicatives compose, monads don&#39;t.

What does the above statement mean? And when is one preferable to other?

Applicatives compose, monads don&#39;t

Consider a situation where I have three (or more) ways of performing a calculation, each of which can fail with an exception. In order to attempt each calculation until we find one that succeeds, I have been doing the following:

    double val;
    
    try { val = calc1(); }
    catch (Calc1Exception e1)
    { 
        try { val = calc2(); }
        catch (Calc2Exception e2)
        {
            try { val = calc3(); }
            catch (Calc3Exception e3)
            {
                throw new NoCalcsWorkedException();
            }
        }
    }
    
Is there any accepted pattern which achieves this in a nicer way? Of course I could wrap each calculation in a helper method which returns null on failure, and then just use the `??` operator, but is there a way of doing this more generally (i.e. without having to write a helper method for each method I want to use)? I&#39;ve thought about writing a static method using generics which wraps any given method in a try/catch and returns null on failure, but I&#39;m not sure how I would go about this. Any ideas?

Pattern to avoid nested try catch blocks?

There are a lot of functional idioms: monads, applicatives, arrows, etc. They are documented in different articles but unfortunately I don&#39;t know any book or article where they&#39;re summarized in one place (there is [Typeclassopedia][1] but it has a lot of areas that aren&#39;t covered well). Can anyone recommend an article/book which covers them well in one place and which can be accessible to a programmer with intermediate skills in FP?


  [1]: http://www.haskell.org/haskellwiki/Typeclassopedia

Functional design patterns

    map :: (a -&gt; b) -&gt; [a] -&gt; [b]

    fmap :: Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b

    liftM :: Monad m =&gt; (a -&gt; b) -&gt; m a -&gt; m b

Why do we have three different functions that do essentially the same thing?

Why do we have map, fmap and liftM?

What is [indexed monad](https://hackage.haskell.org/package/indexed-0.1/docs/Control-Monad-Indexed.html) and the motivation for this monad?

I have read that it helps to keep track of the side effects. But the type signature and documentation doesn&#39;t lead me to anywhere.

What would be an example of how it can help to keep track of side effects (or any other valid example)?


What is indexed monad?

I&#39;m new to functional programming and recently learning at [Learn You a Haskell](http://learnyouahaskell.com/), but when I went through [this chapter](http://learnyouahaskell.com/for-a-few-monads-more), I got stuck with the program below:

    import Control.Monad.Writer  
  
    logNumber :: Int -&gt; Writer [String] Int  
    logNumber x = Writer (x, [&quot;Got number: &quot; ++ show x])  
  
    multWithLog :: Writer [String] Int  
    multWithLog = do  
        a &lt;- logNumber 3  
        b &lt;- logNumber 5  
        return (a*b)

I saved these lines in a .hs file and but failed to import it into my ghci which complained:

    more1.hs:4:15:
        Not in scope: data constructor `Writer&#39;
        Perhaps you meant `WriterT&#39; (imported from Control.Monad.Writer)
    Failed, modules loaded: none.

I examined the type by &quot;:info&quot; command:

    Prelude Control.Monad.Writer&gt; :info Writer
    type Writer w = WriterT w Data.Functor.Identity.Identity
          	       -- Defined in `Control.Monad.Trans.Writer.Lazy&#39;

From my point of view, this was supposed to be something like &quot;newtype Writer w a ...&quot;
so I&#39;m confused about how to feed the data constructor and get a Writer.

I guess it might be a version-related problem and my ghci version is 7.4.1

How to play with Control.Monad.Writer in haskell?

Hackage has several packages for monad transformers:

* [mtl](http://hackage.haskell.org/package/mtl): Monad transformer library
* [transformers](http://hackage.haskell.org/package/transformers): Concrete functor and monad transformers
* [monads-fd](http://hackage.haskell.org/package/monads-fd): Monad classes, using functional dependencies
* [monads-tf](http://hackage.haskell.org/package/monads-tf): Monad classes, using type families
* [monadLib](http://hackage.haskell.org/package/monadLib): A collection of monad transformers.
* [mtl-tf](http://hackage.haskell.org/package/mtl-tf): Monad transformer library using type families.
* [mmtl](http://hackage.haskell.org/package/mmtl): Modular Monad transformer library
* [mtlx](http://hackage.haskell.org/package/mtlx): Monad transformer library with type indexes, providing &#39;free&#39; copies.
* [compose-trans](http://hackage.haskell.org/package/compose-trans): Composable monad transformers

(and maybe I missed some)

Which one shall we use?

mtl is the one in the Haskell Platform, but I keep hearing on reddit that it&#39;s uncool.

But what&#39;s bad about choice anyway, isn&#39;t it just a good thing?

Well, I saw how for example the authors of data-accessor had to make all these to cater to just the popular choices:

* data-accessor-monadLib library: Accessor functions for monadLib&#39;s monads
* data-accessor-monads-fd library: Use Accessor to access state in monads-fd State monad class
* data-accessor-monads-tf library: Use Accessor to access state in monads-tf State monad type family
* data-accessor-mtl library: Use Accessor to access state in mtl State monad class
* data-accessor-transformers library: Use Accessor to access state in transformers State monad

I imagine that if this goes on and for example several competing Arrow packages evolve, we might see something like: spoonklink-arrows-transformers, spoonklink-arrows-monadLib, spoonklink-tfArrows-transformers, spoonklink-tfArrows-monadLib, ...

And then I worry that if spoonklink gets forked, Hackage will run out of disk space. :)

Questions:

* Why are there so many monad transformer packages?
* Why is mtl [considered] uncool?
* What are the key differences?
* Most of these seemingly competing packages were written by Andy Gill and are maintained by Ross Paterson. Does this mean that these packages are not competing but rather work together in some way? And do Andy and Ross consider any of their own packages as obsolete?
* Which one should you and I use?


mtl, transformers, monads-fd, monadLib, and the paradox of choice

I am working through [Write Yourself a Scheme in 48 Hours](http://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_Hours) (I&#39;m up to about 85hrs) and I&#39;ve gotten to the part about [Adding Variables and Assignments](http://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_Hours/Adding_Variables_and_Assignment). There is a big conceptual jump in this chapter, and I wish it had been done in two steps with a good refactoring in between rather then jumping at straight to the final solution. Anyway…

I&#39;ve gotten lost with a number of different classes that seem to serve the same purpose: `State`, `ST`, `IORef`, and `MVar`. The first three are mentioned in the text, while the last seems to be the favored answer to a lot of StackOverflow questions about the first three. They all seem to carry a state between consecutive invocations.

What are each of these and how do they differ from one another?

-----

In particular these sentences don&#39;t make sense:

&gt; Instead, we use a feature called _state threads_, letting Haskell manage the aggregate state for us. This lets us treat mutable variables as we would in any other programming language, using functions to get or set variables.

and

&gt;  The IORef module lets you use stateful variables **within the IO monad**.

All this makes the line `type ENV = IORef [(String, IORef LispVal)]` confusing - why the second `IORef`? What will break if I&#39;ll write `type ENV = State [(String, LispVal)]` instead?

Difference between State, ST, IORef, and MVar

I really don&#39;t seem to be understanding Map and FlatMap. What I am failing to understand is how a for-comprehension is a sequence of nested calls to map and flatMap. The following example is from [Functional Programming in Scala][1]

    def bothMatch(pat:String,pat2:String,s:String):Option[Boolean] = for {
                f &lt;- mkMatcher(pat)
                g &lt;- mkMatcher(pat2)
     } yield f(s) &amp;&amp; g(s)


translates to

    def bothMatch(pat:String,pat2:String,s:String):Option[Boolean] = 
             mkMatcher(pat) flatMap (f =&gt; 
             mkMatcher(pat2) map (g =&gt; f(s) &amp;&amp; g(s)))

The mkMatcher method is defined as follows:

      def mkMatcher(pat:String):Option[String =&gt; Boolean] = 
                 pattern(pat) map (p =&gt; (s:String) =&gt; p.matcher(s).matches)

And the pattern method is as follows:

    import java.util.regex._
    
    def pattern(s:String):Option[Pattern] = 
      try {
            Some(Pattern.compile(s))
       }catch{
           case e: PatternSyntaxException =&gt; None
       }

It will be great if someone could shed some light on the rationale behind using map and flatMap here.
 


  [1]: http://www.manning.com/bjarnason/

Confused with the for-comprehension to flatMap/Map transformation

It is well-known that applicative functors are closed under composition but monads are not.  However, I have been having trouble finding a concrete counterexample showing that monads do not always compose.

[This answer](https://stackoverflow.com/a/7040998/305559) gives `[String -&gt; a]` as an example of a non-monad.  After playing around with it for a bit, I believe it intuitively, but that answer just says &quot;join cannot be implemented&quot; without really giving any justification.  I would like something more formal.  Of course there are lots of functions with type `[String -&gt; [String -&gt; a]] -&gt; [String -&gt; a]`; one must show that any such function necessarily does not satisfy the monad laws.

Any example (with accompanying proof) will do; I am not necessarily looking for a proof of the above example in particular.

Concrete example showing that monads are not closed under composition (with proof)?

In the interests of helping to understand what a monad is, can someone provide an example using java ? Are they possible ?

Lambda expressions are possible using java if you download the pre-release lambda compatible JDK8   from here [http://jdk8.java.net/lambda/][1]

An example of a lambda using this JDK is shown below, can someone provide a comparably simple monad ?

 

    public interface TransformService {
            int[] transform(List&lt;Integer&gt; inputs);
        }
        public static void main(String ars[]) {
            TransformService transformService = (inputs) -&gt; {
                int[] ints = new int[inputs.size()];
                int i = 0;
                for (Integer element : inputs) {
                    ints[i] = element;
                }
                return ints;
            };
    
            List&lt;Integer&gt; inputs = new ArrayList&lt;Integer&gt;(5) {{
                add(10);
                add(10);
            }};
            int[] results = transformService.transform(inputs);
        }



  [1]: http://jdk8.java.net/lambda/

Monads with Java 8

I am not able to understand the point of `Option[T]` class in Scala. I mean, I am not able to see any advanages of `None` over `null`.

For example, consider the code:

    object Main{
      class Person(name: String, var age: int){
        def display = println(name+&quot; &quot;+age)
      }

      def getPerson1: Person = {
        // returns a Person instance or null
      }

      def getPerson2: Option[Person] = {
        // returns either Some[Person] or None
      }

      def main(argv: Array[String]): Unit = {
        val p = getPerson1
        if (p!=null) p.display
        
        getPerson2 match{
          case Some(person) =&gt; person.display
          case None =&gt; /* Do nothing */
        }
      }
    }
    
Now suppose, the method `getPerson1` returns `null`, then the call made to `display` on first line of `main` is bound to fail with `NPE`. Similarly if `getPerson2` returns `None`, the `display` call will again fail with some similar error.

If so, then why does Scala complicate things by introducing a new value wrapper (`Option[T]`) instead of following a simple approach used in Java?

**UPDATE:**

I have edited my code as per [@Mitch][2]&#39;s suggestion. I am still not able to see any particular advantage of `Option[T]`. I have to test for the exceptional `null` or `None` in both cases. :(

If I have understood correctly from [@Michael&#39;s reply][3], is the only advantage of `Option[T]` is that it explicitly tells the programmer that *this method could return None*? Is this the only reason behind this design choice?

  [1]: http://en.wikipedia.org/wiki/Currying
  [2]: https://stackoverflow.com/users/164075
  [3]: https://stackoverflow.com/questions/2079170/why-optiont/2079247#2079247


What is the point of the class Option[T]?

I&#39;ve been reading about monads in category theory. One definition of monads uses a pair of adjoint functors. A monad is defined by a round-trip using those functors. Apparently adjunctions are very important in category theory, but I haven&#39;t seen any explanation of Haskell monads in terms of adjoint functors. Has anyone given it a thought?

Monads as adjunctions

This is how the Cont monad is defined:

    newtype Cont r a = Cont { runCont :: (a -&gt; r) -&gt; r }

    instance Monad (Cont r) where
        return a = Cont ($ a)
        m &gt;&gt;= k  = Cont $ \c -&gt; runCont m $ \a -&gt; runCont (k a) c

Could you explain how and why this works? What is it doing?

How and why does the Haskell Cont monad work?

I understand that the ST monad is something like a little brother of IO, which in turn is the state monad with added `RealWorld` magic. I can picture states and I can picture that RealWorld is somehow put into IO, but every time I write a type signature of `ST` the `s` of the ST monad confuses me. 

Take, for example, `ST s (STArray s a b)`. How does the `s` work there? Is it just used to build up some artificial data dependency between computations without being able to be referenced like states in the state monad (due to the `forall`)?

I&#39;m just throwing out ideas and would really appreciate someone more knowledgeable than I to explain it to me.

How does the ST monad work?

The paper [&quot;Programming and reasoning with algebraic effects and dependent types&quot; by Edwin C. Brady][1] on effects in Idris contains the (unreferenced) claim that:

&gt; Although [effects and monad transformers] are not equivalent in power — monads and monad transformers can express more concepts — many common effectful computations are captured.

What examples are there that can be modelled by monad transformers but not effects?

  [1]: http://eb.host.cs.st-andrews.ac.uk/drafts/effects.pdf &quot;Edwin C. Brady (2013?): &#39;Programming and reasoning with algebraic effects and dependent types&#39;&quot;

&quot;Monad transformers more powerful than effects&quot; - Examples?

&gt; **Possible Duplicate:**  
&gt; [What is a monad?](https://stackoverflow.com/questions/44965/what-is-a-monad)  

&lt;!-- End of automatically inserted text --&gt;

I think I understand what &#39;Maybe Monads&#39; are, but I&#39;m not sure about the other types.

Can anyone explain Monads?

I&#39;m broadly familiar with the concepts of [monads][1] and [arrows][2] as used in functional programming. I also understand that they can be used to solve similar kinds of problems.

However, I&#39;m still a bit confused about how to select which one to use in any given situation.

When should I use monads and when should I use arrows?




  [1]: http://en.wikipedia.org/wiki/Monads_in_functional_programming
  [2]: http://en.wikipedia.org/wiki/Arrows_in_functional_programming

Monads vs. Arrows

Monads can do many amazing, crazy things. They can create variables which hold a superposition of values. They can allow you to access data from the future before you compute it. They can allow you to write destructive updates, but not really. And then the continuation monad allows you to _break people&#39;s minds!_ Ususally your own. ;-)

But here&#39;s a challenge: Can you make a monad which can be _paused_?

&lt;pre&gt;
data Pause s x
instance Monad (Pause s)
mutate :: (s -&gt; s) -&gt; Pause s ()
yield :: Pause s ()
step :: s -&gt; Pause s () -&gt; (s, Maybe (Pause s ()))
&lt;/pre&gt;

The `Pause` monad is a kind of state monad (hence `mutate`, with the obvious semantics). Normally a monad like this has some sort of &quot;run&quot; function, which runs the computation and hands you back the final state. But `Pause` is different: It provides a `step` function, which runs the computation until it calls the magical `yield` function. Here the computation is paused, returning to the caller enough information to resume the computation later.

For extra awesomness: Allow the caller to modify the state between `step` calls. (The type signatures above ought to allow this, for example.)

&lt;hr/&gt;

Use case: It&#39;s often easy to write code that does something complex, but a total PITA to transform it to also _output_ the intermediate states in its operation. If you want the user to be able to _change_ something mid-way through execution, things get complex really fast.

Implementation ideas:

* _Obviously_ it can be done with threads, locks and `IO`. But can we do better? ;-)

* Something insane with a continuation monad?

* Maybe some kind of writer monad, where `yield` just logs the current state, and then we can &quot;pretend&quot; to `step` it by iterating over the states in the log. (Obviously this precludes altering the state between steps, since we&#39;re not really &quot;pausing&quot; anything now.)


The Pause monad

Monads are usually explained in turns of `return` and `bind`. However, I gather you can also implement `bind` in terms of `join` (and `fmap`?)

In programming languages lacking first-class functions, `bind` is excruciatingly awkward to use. `join`, on the other hand, looks quite easy.

I&#39;m not completely sure I understand how `join` works, however. Obviously, it has the [Haskell] type

&lt;pre&gt;
join :: Monad m =&gt; m (m x) -&gt; m x
&lt;/pre&gt;

For the list monad, this is trivially and obviously `concat`. But for a general monad, what, operationally, does this method actually do? I see what it does to the type signatures, but I&#39;m trying to figure out how I&#39;d write something like this in, say, Java or similar.

(Actually, that&#39;s easy: I wouldn&#39;t. Because generics is broken. ;-) But in principle the question still stands...)

---

Oops. It looks like this has been asked before:

https://stackoverflow.com/questions/3382210/monad-join-function

Could somebody sketch out some implementations of common monads using `return`, `fmap` and `join`? (I.e., not mentioning `&gt;&gt;=` at all.) I think perhaps that might help it to sink in to my dumb brain...


Monads with Join() instead of Bind()

There seems to be a consensus that you should use Parsec as an applicative rather than a monad. What are the benefits of applicative parsing over monadic parsing?
 
 - style
 - performance
 - abstraction

Is monadic parsing out?


What are the benefits of applicative parsing over monadic parsing?

I have been studying Haskell for several weeks now (just for fun) and just watched Brian Beckman&#39;s great [video introducing monads](https://www.youtube.com/watch?v=ZhuHCtR3xq8).  He motivates monads with the need to create a more general composition operator.  Following this line of thought, if I have two functions:
```
f :: a -&gt; b
g :: b -&gt; c
```
the composition operator should satisfy
```
h = g . f :: a -&gt; c
```
and from this I can infer the correct type of the `.` operator:
```
(.) : (b -&gt; c) -&gt; (a -&gt; b) -&gt; (a -&gt; c)
```

When it comes to monads, suppose I have two functions:
```
f :: a -&gt; m b
g :: b -&gt; m c
```
It seems to me that the natural choice would have been to define a generalized composition operator that works as follows:
```
h = f &gt;&gt;= g :: a -&gt; m c
```
in which case the `&gt;&gt;=` operator would have a type signature of:
```
(&gt;&gt;=) :: (a -&gt; m b) -&gt; (b -&gt; m c) -&gt; (a -&gt; m c)
```
But actually the operator seems to be defined so that
```
h a = (f a) &gt;&gt;= g :: m c
```
and thus
```
(&gt;&gt;=) : m b -&gt; (b -&gt; m c) -&gt; m c
```
Could someone explain the reasoning behind this choice of definition for bind?  I assume there is some simple connection between the two choices where one can be expressed in terms of the other, but I&#39;m not seeing it at the moment.

Why is the bind operator (&gt;&gt;=) defined as it is?

So far, every monad (that can be represented as a data type) that I have encountered had a corresponding monad transformer, or could have one. Is there such a monad that can&#39;t have one? Or **do all monads have a corresponding transformer?**

By a _transformer `t` corresponding to monad `m`_ I mean that `t Identity` is isomorphic to `m`. And of course that it satisfies the monad transformer laws and that `t n` is a monad for any monad `n`.

I&#39;d like to see either a proof (ideally a constructive one) that every monad has one, or an example of a particular monad that doesn&#39;t have one (with a proof). I&#39;m interested in both more Haskell-oriented answers, as well as (category) theoretical ones.

As a follow-up question, is there a monad `m` that has two distinct transformers `t1` and `t2`? That is, `t1 Identity` is isomorphic to `t2 Identity` and to `m`, but there is a monad `n` such that `t1 n` is not isomorphic to `t2 n`.

(`IO` and `ST` have a special semantics so I don&#39;t take them into account here and let&#39;s disregard them completely. Let&#39;s focus only on &quot;pure&quot; monads that can be constructed using data types.)

Is there a monad that doesn&#39;t have a corresponding monad transformer (except IO)?

I just read the following from [typeclassopedia][1] about the difference between `Monad` and `Applicative`. I can understand that there is no `join` in `Applicative`. But the following description looks vague to me and I couldn&#39;t figure out what exactly is meant by &quot;the result&quot; of a monadic computation/action. So, if I put a value into `Maybe`, which makes a monad, what is the result of this &quot;computation&quot;?

&gt; Let’s look more closely at the type of (&gt;&gt;=). The basic intuition is
&gt; that it combines two computations into one larger computation. The
&gt; first argument, m a, is the first computation. However, it would be
&gt; boring if the second argument were just an m b; then there would be no
&gt; way for the computations to interact with one another (actually, this
&gt; is exactly the situation with Applicative). So, the second argument to
&gt; (&gt;&gt;=) has type a -&gt; m b: a function of this type, given a result of
&gt; the first computation, can produce a second computation to be run.
&gt; ... Intuitively, it is this ability to use the output from previous
&gt; computations to decide what computations to run next that makes Monad
&gt; more powerful than Applicative. The structure of an Applicative
&gt; computation is fixed, whereas the structure of a Monad computation can
&gt; change based on intermediate results.


  [1]: http://www.haskell.org/haskellwiki/Typeclassopedia#Intuition_3 &quot;typeclassopedia&quot;

Is there a concrete example illustrating &quot;ability to use the output from previous computations to decide what computations to run next&quot;, which Applicative does not have?



Difference between Monad and Applicative in Haskell

I have a list of strings, and tried this:

    ls = [ &quot;banana&quot;, &quot;mango&quot;, &quot;orange&quot; ]
    
    main = do
           map PutStrLn list_of_strings

That didn&#39;t work, and I can&#39;t understand why.

    ghc print-list.hs
    print-list.hs:3:0:
        Couldn&#39;t match expected type `IO t&#39; against inferred type `[IO ()]&#39;
        In the expression: main
        When checking the type of the function `main&#39;

Any hints? I suppose it has to do with map returning a list and not a value, but I didn&#39;t find an easy way to fix this.

Right now the only way I know to print a list of strings is to write a function that will iterate the list, printing each element (print if the list is [a], but print and recurse if it&#39;s (a:b)). But it would be *much* simpler to just use map...

Thanks!

Haskell: can&#39;t use &quot;map putStrLn&quot;?

One thing that has always confused me is whether or not it&#39;s an okay time to use an IORef. Are there any guidelines that should be followed when deciding whether or not to use an IORef for a task? When is a good time to use the State monad over an IORef?

When is it OK to use an IORef?

God I hate the term &quot;code smell&quot;, but I can&#39;t think of anything more accurate.

I&#39;m designing a high-level language &amp; compiler to [Whitespace][1] in my spare time to learn about compiler construction, language design, and functional programming (compiler is being written in Haskell).

During the code generation phase of the compiler, I have to maintain &quot;state&quot;-ish data as I traverse the syntax tree. For example, when compiling flow-control statements I need to generate unique names for the labels to jump to (labels generated from a counter that&#39;s passed in, updated, &amp; returned, and the old value of the counter must never be used again). Another example is when I come across in-line string literals in the syntax tree, they need to be permanently converted into heap variables (in Whitespace, strings are best stored on the heap). I&#39;m currently wrapping the entire code generation module in the state monad to handle this.

I&#39;ve been told that writing a compiler is a problem well suited to the functional paradigm, but I find that I&#39;m designing this in much the same way I would design it in C (you really can write C in any language - even Haskell w/ state monads).  

I want to learn how to think in Haskell (rather, in the functional paradigm) - not in C with Haskell syntax. Should I really try to eliminate/minimize use of the state monad, or is it a legitimate functional &quot;design pattern&quot;?

  [1]: http://compsoc.dur.ac.uk/whitespace/

Use of Haskell state monad a code smell?

What is the difference between the `map` and `flatMap` functions of `Iterable`?

scala Iterable#map vs. Iterable#flatMap

I am trying to define a new monad and I am getting a strange error

**newmonad.hs**
&lt;pre&gt;
newtype Wrapped a = Wrap {unwrap :: a}
instance Monad Wrapped where
  (&gt;&gt;=) (Wrap x) f =  f x
  return x = Wrap x

main = do
  putStrLn &quot;yay&quot;
&lt;/pre&gt;

&lt;pre&gt;
$ ghc --version
The Glorious Glasgow Haskell Compilation System, version 7.10.1

$ ghc newmonad.hs 
[1 of 1] Compiling Main             ( newmonad.hs, newmonad.o )

newmonad.hs:2:10:
    No instance for (Applicative Wrapped)
      arising from the superclasses of an instance declaration
    In the instance declaration for ‚&#196;&#242;Monad Wrapped‚&#196;&#244;
&lt;/pre&gt;

Why do I need to define an instance of `Applicative`?

Defining a new monad in haskell raises no instance for Applicative

Every other monad comes with a transformer version, and from what I know the idea of a transformer is a generic extension of monads. Following how the other transformers are build, `IOT` would be something like

    newtype IOT m a = IOT { runIOT :: m (IO a) }

for which I could make up useful applications on the spot: `IOT Maybe` can either do an IO action or nothing, `IOT []` can build a list that can later be `sequence`d.

So why is there no IO transformer in Haskell?

(Notes: I&#39;ve seen [this post on Haskell Cafe](http://www.haskell.org/pipermail/haskell-cafe/2004-December/008160.html), but can&#39;t make much sense of it. Also, [the Hackage page for the ST transformer](http://hackage.haskell.org/packages/archive/STMonadTrans/0.2/doc/html/Control-Monad-ST-Trans.html) mentions a possibly related issue in its description, but doesn&#39;t offer any details.)

Why is there no IO transformer in Haskell?

Why and how specifically is a Scala Future not a Monad; and would someone please compare it to something that is a Monad, like an Option?

The reason I&#39;m asking is Daniel Westheide&#39;s [The Neophyte&#39;s Guide to Scala Part 8: Welcome to the Future][1] where I asked whether or not a Scala Future was a Monad, and the author responded that it wasn&#39;t, which threw off base. I came here to ask for a clarification.

  [1]: http://danielwestheide.com/blog/2013/01/09/the-neophytes-guide-to-scala-part-8-welcome-to-the-future.html

Is Future in Scala a monad?

In my area of business - back office IT for a financial institution - it is very common for a software component to carry a global configuration around, to log its progress, to have some kind of error handling / computation short circuit... Things that can be modelled nicely by Reader-, Writer-, Maybe-monads and the like in Haskell and composed together with monad transformers. 

But there seem to some drawbacks: The concept behind monad transformers is quite tricky and hard to understand, monad transformers lead to very complex type signatures, and they inflict some performance penalty.

So I&#39;m wondering: Are monad transformers best practice when dealing with those common tasks  mentioned above?  

Has anyone ever encountered a Monad Transformer in the wild?

I wonder how I/O were done in Haskell in the days when IO monad was still not invented. Anyone knows an example.

Edit: Can I/O be done without the IO Monad in modern Haskell? I&#39;d prefer an example that works with modern GHC.

Haskell pre-monadic I/O

Could someone give a super simple (few lines) monad transformer example, which is non-trivial (i.e. not using the Identity monad - that I understand).

For example, how would someone create a monad that does IO and can handle failure (Maybe)? 

What would be the simplest example that would demonstrate this?

I have skimmed through a few monad transformer tutorials and they all seem to use State Monad or Parsers or something complicated (for a newbee). I would like to see something simpler than that. I think IO+Maybe would be simple, but I don&#39;t really know how to do that myself.

How could I use an IO+Maybe monad stack?
What would be on top? What would be on bottom? Why?


In what kind of use case would one want to use the IO+Maybe monad or the Maybe+IO monad? Would that make sense to create such a composite monad at all? If yes, when, and why?




Simplest non-trivial monad transformer example for &quot;dummies&quot;, IO+Maybe

I&#39;m looking for creative uses of monads to learn from. I&#39;ve read somewhere that monads have been used for example in AI, but being a monad newbie, I fail to see how.

Please include a link to the source code and sample usages. No [standard monads][1] please.


  [1]: https://web.archive.org/web/20100928141543/http://www.haskell.org/all_about_monads/html/introII.html

Creative uses of monads

I&#39;ve had the IO monad described to me as a State monad where the state is &quot;the real world&quot;. The proponents of this approach to IO argue that this makes IO operations pure, as in referentially transparent. Why is that? From my perspective it appears that code inside the IO monad have plenty of observable side effects. Also, isn&#39;t it possible to describe pretty much any non-pure function like a function of the real world? For example, can&#39;t we think of, say, C&#39;s malloc as being a function that takes a *RealWorld* and an Int and returns a pointer and a *RealWorld*, only just like in the IO monad the *RealWorld* is implicit?

Note: I know what a monad is and how it&#39;s used. Please don&#39;t respond with a link to a random monad tutorial unless it specifically adresses my question.

In what sense is the IO Monad pure?

Every time someone promises to &quot;explain monads&quot;, my interest is piqued, only to be replaced by frustration when the alleged &quot;explanation&quot; is a long list of examples terminated by some off-hand remark that the &quot;mathematical theory&quot; behind the &quot;esoteric ideas&quot; is &quot;too complicated to explain at this point&quot;.

Now I&#39;m asking for the opposite. I have a solid grasp on category theory and I&#39;m not afraid of diagram chasing, Yoneda&#39;s lemma or derived functors (and indeed on *monads* and adjunctions in the categorical sense).

Could someone give me a *clear and concise* definition of what a monad is in functional programming? The fewer examples the better: sometimes one clear concept says more than a hundred timid examples. Haskell would do nicely as a language for demonstration though I&#39;m not picky.

What is a monad in FP, in categorical terms?

I have a problem to which a stack of monad transformers (or even one monad transformer) over `IO`. Everything is good, except that using lift before every action is terribly annoying! I suspect there is really nothing to do about that, but I thought I&#39;d ask anyway.

I am aware of lifting entire blocks, but what if the code is really of mixed types? Would it not be nice if GHC threw in some syntactic sugar (for example, `&lt;-$` = `&lt;- lift`)?

Avoiding lift with monad transformers

I&#39;m attempting to use HSlogger to get some information about my program. So I add the following line to my function 

    import Data.Word
    import qualified Data.ByteString as B
    import qualified Data.ByteString.Lazy as L
    import Data.Bits
    import Data.Int
    import Data.ByteString.Parser
    
    import System.Log.Logger
    import System.Log.Handler.Syslog


    importFile :: FilePath -&gt; IO (Either String (PESFile ))
    importFile n = do
         warningM &quot;MyApp.Component2&quot; &quot;Something Bad is about to happen.&quot;
         ...

And that works fine, because the function is inside IO. 
However when I add a similar line to the following function:

    ...
    parsePES :: Parser PESFile
    parsePES = do
            header &lt;- string &quot;#PES&quot;
            warningM &quot;parsing header&quot;
            ...
            return (PESFile ...)

I get a type error: 

     Couldn&#39;t match expected type `Parser a0&#39;
                    with actual type `String -&gt; IO ()&#39;
        In the return type of a call of `warningM&#39;
        In a stmt of a &#39;do&#39; expression: warningM &quot;parsing header&quot;
        In the expression:
          do { header &lt;- string &quot;#PES&quot;;
               warningM &quot;parsing header&quot;;
            ...

And I totally understand why - parsePES is in the Parser monad, not the IO monad.
What I don&#39;t understand is what to do about it. Do I need a monad transformer so I can stack the Parser monad and the IO monad together? How do I go about that?




How do I do logging in Haskell?

I am getting very confused with these three concepts.

Is there any simple examples to illustrate the differences between
Category, Monoid and Monad ?

It would be very helpful if there is a illustration of these abstract concepts.


All Monads Solutions on Gang of Coders

Total of 51 Monads Solutions