• Sequential Computation: do X, and once finished do Y, and once finished do Z


  1. Given a value, a, that is stored in a box-like type, m
  2. Extract the a from the box, m
  3. Pass it into a function, (a -> m b)
    • The function uses the value a to compute a new value, b.
    • The function wraps the new value b into the same box-like type, m.
    • The function returns a box, m, that stores the new value, b.
  4. Refer to the b value as a and repeat Steps 1-3 until we run out of functions
  5. The last function returns the final b value that is stored in the same box-like type, m.


See its docs: Bind

Below, we'll show two instances for Bind:

  1. A flipped version of bind that shows how it relates to Functor and Apply
  2. The correct version:
-- in real definition, 'f' (functor) is really 'm' (monad)
class (Appy f) <= Bind f where
  bind :: forall a b. f a -> (a -> f b) -> f b

infixl 1 bind as >>=

data Box a = Box a

instance Functor Box where
  map :: forall a b.         (a ->     b) -> Box a -> Box  b
  map                         f             (Box a) = Box (f a)

instance Apply Box where
  apply :: forall a b.   Box (a ->     b) -> Box a -> Box  b
  apply                 (Box  f         )   (Box a) = Box (f a)

-- Wrong: Flipped order of two args!
instance Bind_ Box where
  bindFlipped :: forall a b. (a -> Box b) -> Box a -> Box  b
  bindFlipped                 f             (Box a) = f a

-- Correct order of args
instance Bind Box where
  bind :: forall a b.  Box a -> (a -> Box b) -> Box b
  bind                (Box a)    f            = f a

bind's type signature is weird. How did we ever come up with that? To understand it (and understand why we have the below 'derived functions'), watch Category Theory 10.1: Monads and refer to the code below for help in understanding it:

-- >=> the "fish operator" is
-- called "composeKleisli"
infix composeKleisli 6 >=>

-- see "(a -> m b)" as the definition
-- of `pure` from the `Applicative` type class.
composeKleisli :: forall m a b c. Functor f => (a -> m b) -> (b -> m c) -> (a -> m c)
composeKleisli f g =
  \a ->
    let mb = f a
    in (bind mb g)

    bind :: m b -> (b -> m c) -> m c
    bind functor function = join (map function functor)

    join :: m (m a) -> m a
    join = -- implementation



(This law enables "do notation", which we'll explain soon.)

Definition: (x >>= f) >>= g == x >>= (\x' -> f x' >>= g)

TODO: prove the above law using Box (a lot of work, so ignoring for now...)

Derived Functions

  • If you have nested boxes and need to remove the outer one (join):
    • join (Box (Box a)) == Box a
  • Make chained multiple aToMB functions easier to read...
    • going forwards (composeKleisli/>=>):
      • ma >=> aToMB >=> bToMC >=> ...
    • going backwards (composeKleisliFlipped/<=<):
      • ... <=< bToMC <=< aToMB <=< ma
  • if computeCondition then truePathComputation else falsePathComputation (ifM)
  • If you want bind/>>= to go in the opposite direction (bindFlipped/=<<):
    • ma >>= aToMB == aToMB =<< ma