This [1] might help &#x27;get it&#x27; with regards to monads.  Very easy to digest.<p>You mention LINQ and the List abstraction.  Yes IEnumerable&lt;T&gt; is a monad (LINQ isn&#x27;t in itself - it [the grammar] is the equivalent of &#x27;do&#x27; notation in Haskell).  Monads are simply &#x27;wrapper types&#x27; that follow a couple of rules:<p>1. You must be able to construct one from the un-wrapped value (return in Haskell, new List&lt;T&gt;(...) in C#)<p>2. It must implement the bind function.<p>If you understand &#x27;map&#x27; (or Select in LINQ) then bind is very similar, except instead of returning a mapped version of the wrapped value, it returns a mapped version of the wrapped value, <i>re-wrapped</i>.<p>So in C# parlance (because I assume from your comment you use this daily):<p><pre><code>    IEnumerable&lt;R&gt; Map&lt;T, R&gt;(this IEnumerable&lt;T&gt; self, Func&lt;T, R&gt; mapper)
    {
        foreach(var x in self)
        {
            yield return mapper(x);
        }
    }


    IEnumerable&lt;R&gt; Bind&lt;T, R&gt;(this IEnumerable&lt;T&gt; self, Func&lt;T, IEnumerable&lt;R&gt;&gt; binder)
    {
        foreach(var x in self)
        {
            foreach(var y in binder(x))
            {
                yield return y;
            }
        }
    }
</code></pre>
You may recognise that as SelectMany in LINQ. Select and SelectMany are special case function names in C# that allow the formation of LINQ expressions:<p><pre><code>    var res = from x in list
              select x + 1;
</code></pre>
Equates to:<p><pre><code>    var res = list.Select( x =&gt; x + 1);
</code></pre>
And:<p><pre><code>    var res = from x in list1
              from y in list2
              select x + y;
</code></pre>
Equates to:<p><pre><code>    var res = list1.SelectMany(x =&gt; list2.Select(y =&gt; x + y));
</code></pre>
The result is a &#x27;flattened&#x27; IEnumerable&lt;T&gt; - and that&#x27;s why this is also known as flat-map.<p>It&#x27;s been a while since I&#x27;ve done any Haskell, so forgive me if I get some of the syntax wrong here.  But the LINQ statement above translates very similarly:<p><pre><code>    do x &lt;- list1
       y &lt;- list2
       return x + y
</code></pre>
<i>(I know there&#x27;s a list comprehension syntax in Haskell, but I assume this is still right, Haskellers?)</i><p>The syntax is saying &#x27;get the value out of its wrapper (the list) for me, so I can use it as-is (the add operation), then put the result back in a new wrapper&#x27;.<p>So why do we do all of this?  It&#x27;s so you can write the functions once that behave on the wrapped types, whether they&#x27;re integers, strings or any type.  The monad concept allows you to create a &#x27;chain&#x27; of behaviour that from the outside is opaque, but internally it&#x27;s operating on the raw wrapped values, as-is; and that makes all of the existing functions available.  This is one of the key benefits.<p>A good analogy is to call them &#x27;programmable semi-colons&#x27;, because what makes each monad type what it is, is the behaviour of bind and return.  So a list monad (as seen above) knows how to iterate the collection - so you don&#x27;t have to write a for loop every time, an option monad knows when to not invoke the bind function if it&#x27;s in a None state - so you don&#x27;t have to test it yourself with an &#x27;if&#x27; every time, the state monad knows how to propagate state changes - so you don&#x27;t have to have extra context arguments on every function down the hierarchy, etc.<p>They remove boilerplate and capture common patterns.  That is the other key benefit.  At its core is an abstract idea, and I think that&#x27;s why it&#x27;s sometimes quite hard to grasp; but it&#x27;s just a design pattern.  Forget the category theory side of it, you don&#x27;t need to know any of that to use use them or write new ones.<p>If you&#x27;re more used to C# than Haskell, then you may want to check out my &#x27;C# functional language extensions&#x27; library [2] that has C# implementations of the following monads:<p>Option<p>Either<p>State<p>Reader<p>Writer<p>And a few others, but that should be enough to get started.  It may help you get your head around it in a language you&#x27;re more familiar with?<p>[1] <a href="http:&#x2F;&#x2F;adit.io&#x2F;posts&#x2F;2013-04-17-functors,_applicatives,_and_monads_in_pictures.html" rel="nofollow">http:&#x2F;&#x2F;adit.io&#x2F;posts&#x2F;2013-04-17-functors,_applicatives,_and_...</a><p>[2] <a href="https:&#x2F;&#x2F;github.com&#x2F;louthy&#x2F;language-ext" rel="nofollow">https:&#x2F;&#x2F;github.com&#x2F;louthy&#x2F;language-ext</a>