+* A complex type that's built around some more basic type. Usually
+ the complex type will be polymorphic, and so can apply to different basic types.
+ In our division example, the polymorphism of the `'a option` type
+ provides a way of building an option out of any other type of object.
+ People often use a container metaphor: if `u` has type `int option`,
+ then `u` is a box that (may) contain an integer.
+
+ type 'a option = None | Some of 'a;;
+
+* A way to turn an ordinary value into a monadic value. In OCaml, we
+ did this for any integer `x` by mapping it to
+ the option `Some x`. In the general case, this operation is
+ known as `unit` or `return.` Both of those names are terrible. This
+ operation is only very loosely connected to the `unit` type we were
+ discussing earlier (whose value is written `()`). It's also only
+ very loosely connected to the "return" keyword in many other
+ programming languages like C. But these are the names that the literature
+ uses. [The rationale for "unit" comes from the monad laws
+ (see below), where the unit function serves as an identity,
+ just like the unit number (i.e., 1) serves as the identity
+ object for multiplication. The rationale for "return" comes
+ from a misguided desire to resonate with C programmers and
+ other imperative types.]
+
+ The unit/return operation is a way of lifting an ordinary object into
+ the monadic box you've defined, in the simplest way possible. You can think
+ of the singleton function as an example: it takes an ordinary object
+ and returns a set containing that object. In the example we've been
+ considering:
+
+ let unit x = Some x;;
+ val unit : 'a -> 'a option = <fun>
+
+ So `unit` is a way to put something inside of a monadic box. It's crucial
+ to the usefulness of monads that there will be monadic boxes that
+ aren't the result of that operation. In the option/maybe monad, for
+ instance, there's also the empty box `None`. In another (whimsical)
+ example, you might have, in addition to boxes merely containing integers,
+ special boxes that contain integers and also sing a song when they're opened.
+
+ The unit/return operation will always be the simplest, conceptually
+ most straightforward way to lift an ordinary value into a monadic value
+ of the monadic type in question.
+
+* Thirdly, an operation that's often called `bind`. As we said before, this is another
+ unfortunate name: this operation is only very loosely connected to
+ what linguists usually mean by "binding." In our option/maybe monad, the
+ bind operation is:
+
+ let bind u f = match u with None -> None | Some x -> f x;;
+ val bind : 'a option -> ('a -> 'b option) -> 'b option = <fun>
+
+ Note the type: `bind` takes two arguments: first, a monadic box
+ (in this case, an `'a option`); and second, a function from
+ ordinary objects to monadic boxes. `bind` then returns a monadic
+ value: in this case, a `'b option` (you can start with, e.g., `int option`s
+ and end with `bool option`s).
+
+ Intuitively, the interpretation of what `bind` does is this:
+ the first argument is a monadic value `u`, which
+ evaluates to a box that (maybe) contains some ordinary value, call it `x`.
+ Then the second argument uses `x` to compute a new monadic
+ value. Conceptually, then, we have
+
+ let bind u f = (let x = unbox u in f x);;
+
+ The guts of the definition of the `bind` operation amount to
+ specifying how to unbox the monadic value `u`. In the `bind`
+ operator for the option monad, we unboxed the monadic value by
+ matching it with the pattern `Some x`---whenever `u`
+ happened to be a box containing an integer `x`, this allowed us to
+ get our hands on that `x` and feed it to `f`.
+
+ If the monadic box didn't contain any ordinary value,
+ we instead pass through the empty box unaltered.
+
+ In a more complicated case, like our whimsical "singing box" example
+ from before, if the monadic value happened to be a singing box
+ containing an integer `x`, then the `bind` operation would probably
+ be defined so as to make sure that the result of `f x` was also
+ a singing box. If `f` also wanted to insert a song, you'd have to decide
+ whether both songs would be carried through, or only one of them.
+ (Are you beginning to realize how wierd and wonderful monads
+ can be?)
+
+ There is no single `bind` function that dictates how this must go.
+ For each new monadic type, this has to be worked out in an
+ useful way.
+
+So the "option/maybe monad" consists of the polymorphic `option` type, the
+`unit`/return function, and the `bind` function.
+
+
+A note on notation: Haskell uses the infix operator `>>=` to stand for
+`bind`: wherever you see `u >>= f`, that means `bind u f`.
+Wadler uses ⋆, but that hasn't been widely adopted (unfortunately).
+
+Also, if you ever see this notation:
+
+ do
+ x <- u
+ f x
+
+That's a Haskell shorthand for `u >>= (\x -> f x)`, that is, `bind u f`.
+Similarly:
+
+ do
+ x <- u
+ y <- v
+ f x y
+
+is shorthand for `u >>= (\x -> v >>= (\y -> f x y))`, that is, `bind u
+(fun x -> bind v (fun y -> f x y))`. Those who did last week's
+homework may recognize this last expression. You can think of the
+notation like this: take the singing box `u` and evaluate it (which
+includes listening to the song). Take the int contained in the
+singing box (the end result of evaluting `u`) and bind the variable
+`x` to that int. So `x <- u` means "Sing me up an int, which I'll call
+`x`".
+
+(Note that the above "do" notation comes from Haskell. We're mentioning it here
+because you're likely to see it when reading about monads. It won't work in
+OCaml. In fact, the `<-` symbol already means something different in OCaml,
+having to do with mutable record fields. We'll be discussing mutation someday
+soon.)
+
+As we proceed, we'll be seeing a variety of other monad systems. For example, another monad is the list monad. Here the monadic type is:
+
+ # type 'a list
+
+The `unit`/return operation is:
+
+ # let unit x = [x];;
+ val unit : 'a -> 'a list = <fun>
+
+That is, the simplest way to lift an `'a` into an `'a list` is just to make a
+singleton list of that `'a`. Finally, the `bind` operation is:
+
+ # let bind u f = List.concat (List.map f u);;
+ val bind : 'a list -> ('a -> 'b list) -> 'b list = <fun>
+
+What's going on here? Well, consider `List.map f u` first. This goes through all
+the members of the list `u`. There may be just a single member, if `u = unit x`
+for some `x`. Or on the other hand, there may be no members, or many members. In
+any case, we go through them in turn and feed them to `f`. Anything that gets fed
+to `f` will be an `'a`. `f` takes those values, and for each one, returns a `'b list`.
+For example, it might return a list of all that value's divisors. Then we'll
+have a bunch of `'b list`s. The surrounding `List.concat ( )` converts that bunch
+of `'b list`s into a single `'b list`:
+
+ # List.concat [[1]; [1;2]; [1;3]; [1;2;4]]
+ - : int list = [1; 1; 2; 1; 3; 1; 2; 4]
+
+So now we've seen two monads: the option/maybe monad, and the list monad. For any
+monadic system, there has to be a specification of the complex monad type,
+which will be parameterized on some simpler type `'a`, and the `unit`/return
+operation, and the `bind` operation. These will be different for different
+monadic systems.
+
+Many monadic systems will also define special-purpose operations that only make
+sense for that system.