The name of the PyMonad library comes from the functional programming concept of a monad, a function that has a strict order. The underlying assumption behind much functional programming is that functional evaluation is liberal: it can be optimized or rearranged as necessary. A monad provides an exception that imposes a strict left-to-right order.
Python, as we have seen, is strict. It doesn't require monads. We can, however, still apply the concept in places where it can help clarify a complex algorithm.
The technology for imposing strict evaluation is a binding between a monad and a function that will return a monad. A flat expression will become nested bindings that can't be reordered by an optimizing compiler. The bind() function is mapped to the >> operator, allowing us to write expressions like this:
Just(some file) >> read header >> read next >> read next
The preceding expression would be converted to the following:
bind(
bind(
bind(Just(some file), read header),
read next),
read next)
The bind() functions ensure that a strict left-to-right evaluation is imposed on this expression when it's evaluated. Also, note that the preceding expression is an example of functional composition. When we create a monad with the >> operator, we're creating a complex object that will be evaluated when we finally use the getValue() method.
The Just() subclass is required to create a simple monad compatible object that wraps a simple Python object.
The monad concept is central to expressing a strict evaluation order in a language that's heavily optimized and lenient. Python doesn't require a monad because it uses left-to-right strict evaluation. This makes the monad difficult to demonstrate because it doesn't really do something completely novel in a Python context. Indeed, the monad redundantly states the typical strict rules that Python follows.
In other languages, such as Haskell, a monad is crucial for file input and output where strict ordering is required. Python's imperative mode is much like a Haskell do block, which has an implicit Haskell >>= operator to force the statements to be evaluated in order. (PyMonad uses the bind() function and the >> operator for Haskell's >>= operation.)