       #=> :ok
       #=> Here's your coffee!
 
-  Notice we never call the FSM callbacks directly, they are called by
-  OTP whenever we interact with the server. `send_event` is
-  asynchronous, whereas `sync_send_event` is synchronous. In the
-  case of GenFSM's, the different values a callback can return depends
+  Notice we never call the GenFSM callbacks directly; they are called by
+  OTP whenever we interact with the server throught the API. `send_event` is
+  asynchronous, whereas `sync_send_event` is synchronous. For
+  a GenFSM, the different values a callback can return depend
   on the type of callback.
 
-  State handling returns for send_event callbacks:
+  State handling returns for `send_event` callbacks:
 
       { :next_state, next_state_name, new_state_data }
       { :next_state, next_state_name, new_state_data, timeout }
       { :next_state, next_state_name, new_state_data, :hibernate }
       { :stop, reason, new_state_data }
 
-  State handling returns for sync_send_event callbacks:
+  State handling returns for `sync_send_event` callbacks:
 
       { :reply, reply, next_state_name, new_state_data }
       { :reply, reply, next_state_name, new_state_data, timeout }


        def short_paid(:coin, state_data = StateData[coins: c, price: p])
          when c + 1 < p do
          { :next_state, :short_paid,
            state_data.coins fn old_coins -> old_coins +1 end }
        end

        def short_paid(:coin, state_data) do
          { :next_state, :paid_in_full,
            state_data.coins fn old_coins -> old_coins + 1 end }
        end

        def short_paid(:request_coffee, state_data) do
          { :next_state, :requested_short_paid, state_data }
        end

        def requested_short_paid(:coin, state_data=StateData[coins: c, price: p])
          when c+1 < p do
          { :next_state, :requested_short_paid, state_data.coins(c+1) }
        end

        def requested_short_paid(:coin, _state_data) do
          IO.puts "Here's your coffee!"
          { :next_state, :idle, StateData.new }
        end

        def paid_in_full(:coin, state_data) do
          { :next_state, :paid_in_full,
            state_data.update_coins fn old_coins -> old_coins + 1 end }
        end

        def paid_in_full(:request_coffee, _) do

  `:gen_fsm` module. For more information, please refer to the
  following:

  * http://www.erlang.org/doc/man/gen_fsm.html
  * http://www.erlang.org/doc/design_principles/fsm.html
  * http://learnyousomeerlang.com/finite-state-machines
  """

  @doc false
