Failure monad

Monads have a reputation for being difficult to understand, but in this article we will look at a simple Python implementation of a simple monad. This will hopefully give some insight into what monads are all about.

What is a monad

In functional programming, we use functions as our primary building block, and function composition as one of the basic ways to structure our code. By function composition we mean functions that call other functions, like this:

y = str(neg(int(x)))

This composed function takes a string, converts it to an integer, negates it, and converts it back to a string. So the string "1" is converted to "-1".

But there is a problem. What if our initial string is something like "XYZ"? Then int will throw a ValueError exception because it can't convert that string to an integer value. We will end up in an exception handler somewhere else in our code, or worse still our program might terminate with an error message. This is exactly the sort unpredictability the functional programming is supposed to solve.

Now imagine if the int function was able to return not only the integer value, but also a flag to say whether the conversion had succeeded or failed. This failed flag could be thought of as a context around the actual data - if the failed flag is false, the data is valid, if the failed flag is true we should ignore the data as it isn't valid.

Even better, suppose that the neg function could also take account of the context. When it receives a value from the int function, it checks the failed flag. If it is false, neg knows that the data is valid, so it negates the value and returns it with the failed flag set to false. If the failed flag is true, neg doesn't process the value at all, it just returns a context with the data set to None and the failed flag true.

And ideally, of course, the str function would do exactly the same thing. That means that the composed function above would always return a value. It would never throw an exception. But the value would have a context to say whether it was valid or not.

Unfortunately, the int, neg and str functions don't behave like this. That is where monads come in useful.

A monad is a design pattern that allows us to add a context to data values, and also allows us to easily compose existing functions so that they execute in a context aware manner.

The Failure monad

We will now implement the monad described above, which we will call the Failure monad. Notice that monads are a design pattern. Design patterns describe a general approach to solving a particular type of problem, but they don't dictate the exact implementation. The version here is written for simplicity and clarity above all else.

Here is a simple implementation of Failure:

class Failure():

    def __init__(self, value, failed=False):
        self.value = value
        self.failed = failed

    def get(self):
        return self.value

    def is_failed(self):
        return self.failed

    def __str__(self):
        return ' '.join([str(self.value), str(self.failed)])

    def bind(self, f):
        if self.failed:
            return self
        try:
            x = f(self.get())
            return Failure(x)
        except:
            return Failure(None, True)

This class holds a value, and a failed flag, that are set when the object is created. It also overloads the __str__ function. This function implements the str() built-in function and is also called when you print the object. It displays both the value and the failure state of the object.

The thing that turns this into a monad is the bind function. It is used like this:

x = '1'
y = Failure(x).bind(int)
print(y)

In this code, we create a Failure monad with the value "1". We then bind the int function to the monad. Here is what bind does:

• It extracts the value from the monad.
• It applies the function to the value.
• It then returns the value wrapped in a new monad.

The print statement prints the value (1) and the failed flag (False, because the operation succeeded).

Since bind returns a Failure monad, we can apply neg and str too. neg is actually a function from the operators module:

from operator import neg

x = '1'
y = Failure(x).bind(int).bind(neg).bind(str)
print(y)

This does the same as str(neg(int(x))), but with monads. But here is the clever bit:

x = 'XYZ'
y = Failure(x).bind(int).bind(neg).bind(str)
print(y)

In this case, int throws an exception because "XYZ" can't be converted to an integer. The bind method catches this exception, and returns Failure(None, True) - a Failure Monad that indicates a failed state.

When we bind neg to this value, the bind method detects that the failed flag is set. It doesn't call neg at all, it juts returns itself (ie the failed monad). The same thing happens when we bind str to the result. So:

• If all the functions operate without failure, the final result is a Failure monad containing the calculated value.
• If any function fails, the remaining functions don't execute and the result is a Failure monad with the failed flag set.

Syntax improvement

We can add the following method to our monad, to overload the or operator (symbol |) to invoke bind:

    def __or__(self, f):
        return self.bind(f)

With this new definition we can use a simpler syntax for chaining functions:

x = '1'
y = Failure(x) | int | neg | str
print(y)

Summary

This was a simple introduction to the idea of monads via a very basic implementation of one of the simplest monads. The concept of a context is very general, and can go far beyond a simple flag. But I hope this introduction might give you a small insight into how monads work.

See also

• Introduction to Functional Programming
• Functions
• Pure functions
• Lambda functions
• Iterators
• Iterators vs iterables
• Built-in functions on iterables
• Transforming iterables
• Map/reduce example
• Generators
• Functional design patterns
• Recursion and the lru_cache in Python
• Partial application
• Closures
• Monads
• List monad
• Maybe monad