Monads in C#: Which Part Is The Monad?

   1: var foo = new Foo();

   2:  

   3: var output = foo.ToMaybe()

   4:     .Get(SomeMethodToRetrieveABar)

   5:     .If(CheckSomethingComplexWithBarHere)

   6:     .Get(r => r.Baz)

   7:     .Return(z => z.Name, "nothing here. move along");

   8:  

   9: Console.WriteLine(output);

</div> </div>

In this example, if any of the method calls or funcs returns a null, I will end up with “nothing here. move along” as the text written to my console. However, if none of them produces a null value, then I will end up retrieving the Baz.Name property from my object graph (which looks like: Foo, Foo.Bar, Bar.Baz, Baz.Name).

A Long, Confusing Definition Of Monad

Now that I have this in place, I find myself asking… which part of this is the actual monad? According to Wikipedia, a monad:

is a kind of abstract data type constructor used to represent computations (instead of data in the domain model). Monads allow the programmer to chain actions together to build a pipeline, in which each action is decorated with additional processing rules provided by the monad. Programs written in functional style can make use of monads to structure procedures that include sequenced operations, or to define arbitrary control flows (like handling concurrency, continuations, or exceptions).

Formally, a monad is constructed by defining two operations (bind and return) and a type constructor M that must fulfill several properties to allow the correct composition of monadic functions (i.e. functions that use values from the monad as their arguments). The return operation takes a value from a plain type and puts it into a monadic container of type M. The bind operation performs the reverse process, extracting the original value from the container and passing it to the associated next function in the pipeline.

A programmer will compose monadic functions to define a data-processing pipeline. The monad acts as a framework, as it’s a reusable behavior that decides the order in which the specific monadic functions in the pipeline are called, and manages all the undercover work required by the computation. The bind and return operators interleaved in the pipeline will be executed after each monadic function returns control, and will take care of the particular aspects handled by the monad.

When I first read this, I got lost… very lost. So I started reading other articles by other developers. However, it wasn’t until I had actually implemented the Maybe and a few other examples of what I think are monadic functions, that I started to understand what this text and those other articles are talking about. But I’m still not completely sure, here… so I want to pick out a few key parts of the above text and use them to analyze the code I wrote, hopefully identifying the actual monads in my sample code. </p>

Return And Bind

When I first started reading the Maybe examples, I thought it was the Maybe class itself that was the monad. After all, the second paragraph in the above text talks about putting values into a container and extracting them, calling this Return and Bind, respectfully. In the case of Maybe, that seems fairly obvious: I’m putting a value into the Maybe class through the constructor, which should be the Return part, and then I’m extracting the value through the .Value property, which should be the Bind part. The problem I ran into is that the Dmitri Nesteruk article I linked to (where I got the extension methods) does not use a Maybe class. This article uses the extension methods entirely, and yet it claims to be monads. I assume Dmitri knows what he is talking about and therefore my assumption of Maybe being the monad is incorrect. </p>

Monadic Functions

The third paragraph in the above text begins to give me a better picture, I think. “A programmer will compose monadic functions to define a data-processing pipeline.” Aha! Perhaps it is the actual extension methods that are the monads? Or at least, these are the monadic function that this paragraph refers to. But I don’t think that the extension methods are themselves the monad because the paragraph goes on to talk about the monad being a framework in which monadic functions are chained together. It also says the monad itself manages the order of execution. So then the monad isn’t the individual methods.

Are Monads In C# A Concept More Than A Construct?

I’m starting to get the feeling that a monad implemented in C# is more of a concept or aggregation of ideas and implementation detail, than an explicit construct. Given everything that the wikipedia article says, given all the examples I’ve looked at, and given the example that I show above, I think the actual monad is the aggregation of the extension methods, the Maybe and calling them in the specific order that I have laid out in my code. Therefore, this sample code is the actual monad: </p> </p>

   1: var output = foo.ToMaybe()

   2:     .Get(SomeMethodToRetrieveABar)

   3:     .If(CheckSomethingComplexWithBarHere)

   4:     .Get(r => r.Baz)

   5:     .Return(z => z.Name, "nothing here. move along");

   1: string postCode = this.With(x => person)

   2:     .If(x => HasMedicalRecord(x))]

   3:     .With(x => x.Address)

   4:     .Do(x => CheckAddress(x))

   5:     .With(x => x.PostCode)

   6:     .Return(x => x.ToString(), "UNKNOWN");