* Performs the monadic computation `mm1`. If it fails, `mm2` is * returned, otherwise the result is (re-wrapped). */

* Evaluate two alternatives. * * If `e1` wraps a right value, it is instantly returned. Otherwise, * `e2` is checked for rightness. If both `

Defaults to Eq.

* Construct from `N`. * * This allows implicit conversion from `N` to `prod_monoid<N>`. The * purpose is of course to make the `prod_monoid`

* Embeds a value in the `maybe` context/container. * * Exactly equivalent to invoking `just` on the value. */

* Wrap a value in a lazyT. * * Essentially equivalent of invoking `M`'s pure on a deferred * computation that will result in `t`. */

Uses `M`'s pure to create a value (as opposed to `nothing`)

TODO: C++14 - Create version that lambda captures a by move Creates a function that returns `a`, regardless of its parameters.

* Embeds a single value in a set. * * In other words, produces a set with a single element of the value * `t`. */

* Creates a tuple with `a` as first element. * * All the other fields are initialised with their respective * `monoid::id()` results. */

* Create a computation that computes `t` * * Sounds a bit silly&mdash;we already know `t` after all&mdash;but * there are situations when it

* Embeds a value as a right value. * * \par Examples * * \code * either<int,string> e = monad<either<int,string>>::pure("foo"); *

* Encapsulate a pure value in the applicative functor. * * Defaults to `monad<F>::pure`, because any monad is also an * applicative functor.

Workaround because stoi is not unary

* Initialises the number as `0`. */