Last time in this series we finally worked out the actual rules for the monad pattern. The pattern in C# is that a monad is a generic type
M<T> that “amplifies” the power of a type
T. There is always a way to construct an
M<T> from a value of
T, which we characterized as the existence of a helper method:
static M<T> CreateSimpleM<T>(T t)
And if you have a function that takes any type
A and produces an
M<R> then there is a way to apply that function to an instance of
M<A> in a way that still produces an
M<R>. We characterized this as the existence of a helper method:
static M<R> ApplySpecialFunction<A, R>(
Func<A, M<R>> function)
Is that it? Not quite. In order to actually be a valid implementation of the monad pattern, these two helper methods need to have a few additional restrictions placed on them, to ensure that they are well-behaved. Specifically: the construction helper function can be thought of as “wrapping up” a value, and the application helper function knows how to “unwrap” a value; it seems reasonable that we require that wrapping and unwrapping operations preserve the value.
We are closing in on the actual requirements of the “monad pattern”. So far we’ve seen that for a monadic type
M<T>, there must be a simple way to “wrap up” any value of
T into an
M<T>. And last time we saw that any function that takes an
A and returns an
R can be applied to an
M<A> to produce an
M<R> such that both the action of the function and the “amplification” of the monad are preserved, which is pretty cool. It looks like we’re done; what more could you possibly want?
Well, let me throw a spanner into the works here and we’ll see what grinds to a halt. I said that you can take any one-parameter function that has any non-void return type whatsoever, and apply that function to a monad to produce an
M<R> for the return type. Any return type whatsoever, eh? OK then. Suppose we have this function of one parameter:
(Again, for expository purposes I am writing the code far less concisely than I normally would, and of course we are ignoring the fact that
double already has a “null” value,
static Nullable<double> SafeLog(int x)
if (x > 0)
return new Nullable<double>(Math.Log(x));
return new Nullable<double>();
Seems like a pretty reasonable function of one parameter. This means that we should be able to apply that function to a
Nullable<int> and get back out…
So far we’ve seen that if you have a type that follows the monad pattern, you can always create a “wrapped” value from any value of the “underlying” type. We also showed how five different monadic types enable you to add one to a wrapped integer, and thereby produce a new wrapped integer that preserves the desired “amplification” — nullability, laziness, and so on. Let’s march forth (HA HA HA!) and see if we can generalize the pattern to operations other than adding one to an integer.
In this series we’re approaching an understanding of monads “bottom up”, by trying to suss out the pattern, rather than by going “top down”, starting with category theory or functional language practice. Last time I identified five generic types that are frequently used in C#; today we’ll start looking for commonalities beyond their being generic types.
Last time on FAIC I set out to explore monads from an object-oriented programmer’s perspective, rather than delving into the functional programmer’s perspective immediately. The “monad pattern” is a design pattern for types, and a “monad” is a type that uses that pattern. Rather than describing the pattern itself, let’s start by listing some monad-ish types that you are almost certainly very familiar with, and see what they have in common.
These five types are the ones that immediately come to my mind; I am probably missing some. If you have an example of a commonly-used C# type that is monadic in nature, please leave a comment.
Nullable<T> — represents a T that could be null
Func<T> — represents a T that can be computed on demand
Lazy<T> — represents a T that can be computed on demand once, then cached
Task<T> — represents a T that is being computed asynchronously and will be available in the future, if it isn’t already
IEnumerable<T> — represents an ordered, read-only sequence of zero or more Ts
Lots of other bloggers have attempted this, but what the heck, I’ll give it a shot too. In this series I’m going to attempt to answer the question:
I’m a C# programmer with no “functional programming” background whatsoever. What is this “monad” thing I keep hearing about, and what use is it to me?
Bloggers often attempt to tackle this problem by jumping straight into the functional programming usage of the term, and start talking about “bind” and “unit” operations, and higher-order functional programming with higher-order types. Even worse is to go all the way back to the category theory underpinning monads and start talking about “monoids in the category endofunctors” and the like. I want to start from a much more pragmatic, object-oriented, C#-type-system focussed place and move towards the rarefied heights of functional programming as we go. Continue reading