My pleasure.  I guess to help a bit more (because the list monad tends to be easier to comprehend) is to see how other types are implemented.  So here&#x27;s a very basic implementation of the Option&#x2F;Maybe monad:<p><pre><code>    public class Option&lt;T&gt;
    {
        public readonly bool HasValue;
        public readonly T Value;

        internal Option(bool hasValue, T value)
        {
            HasValue = hasValue;
            Value = value;
        }

        public Option&lt;U&gt; Select&lt;U&gt;(Func&lt;T, U&gt; map) =&gt;
            HasValue
                ? Option.Some&lt;U&gt;(map(Value))
                : Option.None&lt;U&gt;();

        public Option&lt;V&gt; SelectMany&lt;U,V&gt;(Func&lt;T, Option&lt;U&gt;&gt; bind, Func&lt;T,U,V&gt; project) =&gt;
            HasValue
                ? bind(Value).Select(u =&gt; project(Value,u))
                : Option.None&lt;V&gt;();
    }

    public static class Option
    {
        public static Option&lt;T&gt; Some&lt;T&gt;(T value) =&gt;
            new Option&lt;T&gt;(true, value);

        public static Option&lt;T&gt; None&lt;T&gt;() =&gt;
            new Option&lt;T&gt;(false, default(T));
    }
</code></pre>
The SelectMany implementation is slightly more complicated than I showed before.  This is an optimisation that C# does to group the bind and map together.  So it may look slightly scary as a function.  But hopefully you can see that if the Option&lt;T&gt; has a value then it first invokes bind, then uses the result of the bind (an Option&lt;U&gt;) to project the final result.  Here&#x27;s a more imperative version of it:<p><pre><code>        public Option&lt;V&gt; SelectMany&lt;U, V&gt;(Func&lt;T, Option&lt;U&gt;&gt; bind, Func&lt;T, U, V&gt; project)
        {
            if (HasValue)
            {
                var u = bind(Value);

                if (u.HasValue)
                {
                    return Option.Some(project(Value, u.Value));
                }
                else
                {
                    return Option.None&lt;V&gt;();
                }
            }
            else
            {
                return Option.None&lt;V&gt;();
            }
        }
</code></pre>
You can see that with the IEnumerable&lt;T&gt; version of Select and SelectMany it encapsulates list iteration.  With the Option monad it doesn&#x27;t do that.  It instead checks the HasValue field, and if it&#x27;s false then it doesn&#x27;t run the map or bind functions.<p>The second static class: Option, contains the &#x27;return&#x27; functions: Some or None.  These wrap a value of type T in an Option&lt;T&gt;.<p>Now if we use Option&lt;T&gt; in a LINQ expression:<p><pre><code>    var option1 = Option.Some(10);
    var option2 = Option.Some(10);
    var none    = Option.None&lt;int&gt;();

    var res1 = from x in option1
               from y in option2
               select x + y;

    &#x2F;&#x2F; res1.HasValue == true  res1.Value == 20 

    var res2 = from x in option1
               from y in none
               select x + y;

    &#x2F;&#x2F; res2.HasValue == false

    var res3 = from x in none
               from y in option2
               select x + y;

    &#x2F;&#x2F; res3.HasValue == false
</code></pre>
This is the same as using do notation in Haskell:<p><pre><code>    do x &lt;- option1
       y &lt;- option2
       return (x + y)
</code></pre>
If we were to do that imperatively it would look like this:<p><pre><code>    var res = Option.None&lt;int&gt;();
    if( option1.HasValue )
    {
        if( option2.HasValue )
        {
            res = Option.Some(option1.Value + option2.Value);
        }
    }
</code></pre>
Clearly more cluttered and error prone and importantly, not composable.  This is where the notion of &#x27;programmable semi-colons&#x27; comes from.  It appears that the monad is running behaviour &#x27;between the lines&#x27;, and it is.<p>Hopefully that clears the fog.  I&#x27;ll keep an eye on this thread for a few days, so feel free to drop any questions in here or on my project page.