
  -spec exit(Pid, Reason) -> true
                when Pid :: pid() | port(), Reason :: term().

  Sends an exit signal with exit reason Reason to the process or
  port identified by Pid.

  The following behavior applies if Reason is any term, except 
  normal or kill, and P is the process or port identified by 
  Pid:

   • If P is not trapping exits, P exits with exit reason 
     Reason.

   • If P is trapping exits, the exit signal is transformed
     into a message {'EXIT', From, Reason}, where From is the
     process identifier of the process that sent the exit signal,
     and delivered to the message queue of P.

  The following behavior applies if Reason is the term normal
  and Pid is the identifier of a process P which is not the same
  as the process that invoked erlang:exit(Pid, normal) (the
  behavior when a process sends a signal with the normal reason to
  itself is described in the warning):

   • If P is trapping exits, the exit signal is transformed
     into a message {'EXIT', From, normal}, where From is the
     process identifier of the process that sent the exit signal,
     and delivered to P's message queue.

   • The signal has no effect if P is not trapping exits.

  If Reason is the atom kill, that is, if exit(Pid, kill) is
  called, an untrappable exit signal is sent to the process that is
  identified by Pid, which unconditionally exits with exit reason 
  killed. The exit reason is changed from kill to killed to
  hint to linked processes that the killed process got killed by a
  call to exit(Pid, kill).

  Note:
    The functions erlang:exit/1 and erlang:exit/2 are named
    similarly but provide very different functionalities. The 
    erlang:exit/1 function should be used when the intent is to
    stop the current process while erlang:exit/2 should be used
    when the intent is to send an exit signal to another process.
    Note also that erlang:exit/1 raises an exception that can be
    caught while erlang:exit/2 does not cause any exception to
    be raised.

  Warning:
    The only scenario that has not been covered by the description
    above is when a process P sends an exit signal with reason 
    normal to itself, that is erlang:exit(self(), normal). The
    behavior in this scenario is as follows:

     • If P is trapping exits, the exit signal is
       transformed into a message {'EXIT', From, normal},
       where From is P's process identifier, and delivered
       to P's message queue.

     • P exits with reason normal if P is not trapping
       exits.

    Note that the behavior described above is different from when
    a process sends an exit signal with reason normal to another
    process. This is arguably strange but this behavior is kept
    for backward compatibility reasons.
