Chapter 14Python, 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 assure 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.)
Implementing simulation with monads
Monads are expected to pass through a kind of "pipeline": a monad will be passed as
an argument to a function and a similar monad will be returned as the value of the
function. The functions must be designed to accept and return similar structures.
We'll look at a simple pipeline that can be used for simulation of a process. This
kind of simulation may be a formal part of some Monte Carlo simulation. We'll take
the Monte Carlo simulation literally and simulate a casino dice game, Craps. This
involves what might be thought of as stateful rules for a fairly complex simulation.