Merge branch 'xsipewe_gen_statem1' of https://github.com/xsipewe/otp into raimo/polish-gen_statem/OTP-13065

Conflicts:
	lib/stdlib/doc/src/gen_statem.xml

7 files changed, 1278 insertions, 1193 deletions

diff --git a/erts/emulator/beam/erl_alloc.types b/erts/emulator/beam/erl_alloc.types
index ad62a87326..ba216c7eb4 100644
--- a/erts/emulator/beam/erl_alloc.types
+++ b/erts/emulator/beam/erl_alloc.types
@@ -264,7 +264,6 @@ type	PRTSD		STANDARD	SYSTEM		port_specific_data
 type	CPUDATA		LONG_LIVED	SYSTEM		cpu_data
 type	TMP_CPU_IDS	SHORT_LIVED	SYSTEM		tmp_cpu_ids
 type	EXT_TERM_DATA	SHORT_LIVED	PROCESSES	external_term_data
-type	ZLIB		STANDARD	SYSTEM		zlib
 type	CPU_GRPS_MAP	LONG_LIVED	SYSTEM		cpu_groups_map
 type	AUX_WORK_TMO	LONG_LIVED	SYSTEM		aux_work_timeouts
 type	MISC_AUX_WORK_Q	LONG_LIVED	SYSTEM		misc_aux_work_q
@@ -297,8 +296,10 @@ type	THR_Q_LL	LONG_LIVED	SYSTEM		long_lived_thr_queue
 
 +if smp
 type	ASYNC		SHORT_LIVED	SYSTEM		async
+type	ZLIB		STANDARD	SYSTEM		zlib
 +else
-# sl_alloc is not thread safe in non smp build; therefore, we use driver_alloc
+# sl/std_alloc is not thread safe in non smp build; therefore, we use driver_alloc
+type	ZLIB		DRIVER   	SYSTEM		zlib
 type	ASYNC		DRIVER		SYSTEM		async
 +endif
 
diff --git a/erts/emulator/beam/erl_alloc_util.c b/erts/emulator/beam/erl_alloc_util.c
index be7c16cc05..2995f2f822 100644
--- a/erts/emulator/beam/erl_alloc_util.c
+++ b/erts/emulator/beam/erl_alloc_util.c
@@ -860,8 +860,9 @@ erts_alcu_literal_32_mseg_alloc(Allctr_t *allctr, Uint *size_p, Uint flags)
 {
     void* res;
     Uint sz = ERTS_SUPERALIGNED_CEILING(*size_p);
-    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL
-                   && !allctr->t && allctr->thread_safe);
+    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL &&
+                   allctr->t == 0);
+    ERTS_SMP_LC_ASSERT(allctr->thread_safe);
 
     res = erts_alcu_mseg_alloc(allctr, &sz, flags);
     if (res) {
@@ -877,8 +878,9 @@ erts_alcu_literal_32_mseg_realloc(Allctr_t *allctr, void *seg,
 {
     void* res;
     Uint new_sz = ERTS_SUPERALIGNED_CEILING(*new_size_p);
-    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL
-                   && !allctr->t && allctr->thread_safe);
+    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL &&
+                   allctr->t == 0);
+    ERTS_SMP_LC_ASSERT(allctr->thread_safe);
 
     if (seg && old_size)
         clear_literal_range(seg, old_size);
@@ -894,8 +896,9 @@ void
 erts_alcu_literal_32_mseg_dealloc(Allctr_t *allctr, void *seg, Uint size,
                                Uint flags)
 {
-    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL
-                   && !allctr->t && allctr->thread_safe);
+    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL &&
+                   allctr->t == 0);
+    ERTS_SMP_LC_ASSERT(allctr->thread_safe);
 
     erts_alcu_mseg_dealloc(allctr, seg, size, flags);
 
@@ -1007,8 +1010,9 @@ erts_alcu_literal_32_sys_alloc(Allctr_t *allctr, Uint* size_p, int superalign)
 {
     void* res;
     Uint size = ERTS_SUPERALIGNED_CEILING(*size_p);
-    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL
-                   && !allctr->t && allctr->thread_safe);
+    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL &&
+                   allctr->t == 0);
+    ERTS_SMP_LC_ASSERT(allctr->thread_safe);
 
     res = erts_alcu_sys_alloc(allctr, &size, 1);
     if (res) {
@@ -1024,8 +1028,9 @@ erts_alcu_literal_32_sys_realloc(Allctr_t *allctr, void *ptr, Uint* size_p, Uint
     void* res;
     Uint size = ERTS_SUPERALIGNED_CEILING(*size_p);
 
-    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL
-                   && !allctr->t && allctr->thread_safe);
+    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL &&
+                   allctr->t == 0);
+    ERTS_SMP_LC_ASSERT(allctr->thread_safe);
 
     if (ptr && old_size)
         clear_literal_range(ptr, old_size);
@@ -1040,8 +1045,9 @@ erts_alcu_literal_32_sys_realloc(Allctr_t *allctr, void *ptr, Uint* size_p, Uint
 void
 erts_alcu_literal_32_sys_dealloc(Allctr_t *allctr, void *ptr, Uint size, int superalign)
 {
-    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL
-                   && !allctr->t && allctr->thread_safe);
+    ERTS_LC_ASSERT(allctr->alloc_no == ERTS_ALC_A_LITERAL &&
+                   allctr->t == 0);
+    ERTS_SMP_LC_ASSERT(allctr->thread_safe);
 
     erts_alcu_sys_dealloc(allctr, ptr, size, 1);
 
diff --git a/lib/common_test/test_server/ts_run.erl b/lib/common_test/test_server/ts_run.erl
index a856fc6f8d..66db1ff9a7 100644
--- a/lib/common_test/test_server/ts_run.erl
+++ b/lib/common_test/test_server/ts_run.erl
@@ -261,7 +261,7 @@ run_batch(Vars, _Spec, State) ->
     Command = State#state.command ++ " -noinput -s erlang halt",
     ts_lib:progress(Vars, 1, "Command: ~ts~n", [Command]),
     io:format(user, "Command: ~ts~n",[Command]),
-    Port = open_port({spawn, Command}, [stream, in, eof]),
+    Port = open_port({spawn, Command}, [stream, in, eof, exit_status]),
     Timeout = 30000 * case os:getenv("TS_RUN_VALGRIND") of
 			  false -> 1;
 			  _ -> 100
@@ -284,7 +284,16 @@ tricky_print_data(Port, Timeout) ->
 		    ok
 	    after 1 ->				% force context switch
 		    ok
-	    end
+	    end,
+            receive
+                {Port, {exit_status, 0}} ->
+                    ok;
+                {Port, {exit_status, N}} ->
+                    io:format(user, "Test run exited with status ~p~n", [N])
+            after 1 ->
+                    %% This shouldn't happen, but better safe then hanging
+                    ok
+            end
     after Timeout ->
 	    case erl_epmd:names() of
 		{ok,Names} ->
diff --git a/lib/public_key/doc/src/using_public_key.xml b/lib/public_key/doc/src/using_public_key.xml
index 86808adbea..e3a1eed4be 100644
--- a/lib/public_key/doc/src/using_public_key.xml
+++ b/lib/public_key/doc/src/using_public_key.xml
@@ -124,7 +124,7 @@
                   ...>>,
                 not_encrypted},
  {'Certificate',<<48,130,3,200,48,130,3,49,160,3,2,1,2,2,1,
-                  1,48,13,6,9,42,134,72,134,247,...>>>,
+                  1,48,13,6,9,42,134,72,134,247,...>>,
                 not_encrypted}]</code>
       
       <p>Certificates can be decoded as usual:</p>
diff --git a/lib/stdlib/doc/src/binary.xml b/lib/stdlib/doc/src/binary.xml
index 5402fd0163..933157fc34 100644
--- a/lib/stdlib/doc/src/binary.xml
+++ b/lib/stdlib/doc/src/binary.xml
@@ -366,7 +366,7 @@
 
 <code>
 1> binary:matches(&lt;&lt;"abcde"&gt;&gt;,
-                  [&lt;&lt;"bcde"&gt;&gt;,&lt;&lt;"bc"&gt;&gt;>,&lt;&lt;"de"&gt;&gt;],[]).
+                  [&lt;&lt;"bcde"&gt;&gt;,&lt;&lt;"bc"&gt;&gt;,&lt;&lt;"de"&gt;&gt;],[]).
 [{1,4}]
 </code>
 
diff --git a/lib/stdlib/doc/src/gen_statem.xml b/lib/stdlib/doc/src/gen_statem.xml
index d83e17b177..be90488a1f 100644
--- a/lib/stdlib/doc/src/gen_statem.xml
+++ b/lib/stdlib/doc/src/gen_statem.xml
@@ -29,39 +29,49 @@
     <rev></rev>
   </header>
   <module>gen_statem</module>
-  <modulesummary>Generic State Machine Behaviour</modulesummary>
+  <modulesummary>Generic state machine behavior.</modulesummary>
   <description>
     <p>
-      A behaviour module for implementing a state machine. Two
+      This behavior module provides a state machine. Two
       <seealso marker="#type-callback_mode"><em>callback modes</em></seealso>
-      are supported.  One for finite state machines
-      (<seealso marker="gen_fsm"><c>gen_fsm</c></seealso> like)
-      that requires the state to be an atom and uses that state as
-      the name of the current callback function,
-      and one without restriction on the state data type
-      that uses one callback function for all states.
-    </p>
-    <p>
-      This is a new behaviour in OTP-19.0.
-      It has been thoroughly reviewed, is stable enough
-      to be used by at least two heavy OTP applications, and is here to stay.
-      But depending on user feedback, we do not expect
-      but might find it necessary to make minor
-      not backwards compatible changes into OTP-20.0,
-      so its state can be designated as "not quite experimental"...
+      are supported:
     </p>
+    <list type="bulleted">
+      <item>
+        <p>One for finite-state machines
+          (<seealso marker="gen_fsm"><c>gen_fsm</c></seealso> like),
+          which requires the state to be an atom and uses that state as
+          the name of the current callback function
+        </p>
+      </item>
+      <item>
+        <p>One without restriction on the state data type
+          that uses one callback function for all states
+        </p>
+      </item>
+    </list>
+    <note>
+      <p>
+        This is a new behavior in Erlang/OTP 19.0.
+        It has been thoroughly reviewed, is stable enough
+        to be used by at least two heavy OTP applications, and is here to stay.
+        Depending on user feedback, we do not expect
+        but can find it necessary to make minor
+        not backward compatible changes into Erlang/OTP 20.0.
+      </p>
+    </note>
     <p>
-      The <c>gen_statem</c> behaviour is intended to replace
+      The <c>gen_statem</c> behavior is intended to replace
       <seealso marker="gen_fsm"><c>gen_fsm</c></seealso> for new code.
-      It has the same features and add some really useful:
+      It has the same features and adds some really useful:
     </p>
     <list type="bulleted">
-      <item>State code is gathered</item>
-      <item>The state can be any term</item>
-      <item>Events can be postponed</item>
-      <item>Events can be self generated</item>
-      <item>A reply can be sent from a later state</item>
-      <item>There can be multiple sys traceable replies</item>
+      <item>State code is gathered.</item>
+      <item>The state can be any term.</item>
+      <item>Events can be postponed.</item>
+      <item>Events can be self-generated.</item>
+      <item>A reply can be sent from a later state.</item>
+      <item>There can be multiple <c>sys</c> traceable replies.</item>
     </list>
     <p>
       The callback model(s) for <c>gen_statem</c> differs from
@@ -71,19 +81,18 @@
     </p>
     <p>
       A generic state machine process (<c>gen_statem</c>) implemented
-      using this module will have a standard set of interface functions
-      and include functionality for tracing and error reporting.
-      It will also fit into an OTP supervision tree. Refer to
+      using this module has a standard set of interface functions
+      and includes functionality for tracing and error reporting.
+      It also fits into an OTP supervision tree. For more information, see
       <seealso marker="doc/design_principles:statem">
         OTP Design Principles
-      </seealso>
-      for more information.
+      </seealso>.
     </p>
     <p>
       A <c>gen_statem</c> assumes all specific parts to be located in a
-      callback module exporting a pre-defined set of functions.
-      The relationship between the behaviour functions and the callback
-      functions can be illustrated as follows:</p>
+      callback module exporting a predefined set of functions.
+      The relationship between the behavior functions and the callback
+      functions is as follows:</p>
     <pre>
 gen_statem module            Callback module
 -----------------            ---------------
@@ -103,37 +112,37 @@ erlang:'!'            -----> Module:StateName/3
 -                     -----> Module:code_change/4</pre>
     <p>
       Events are of different
-      <seealso marker="#type-event_type">types</seealso>
+      <seealso marker="#type-event_type">types</seealso>,
       so the callback functions can know the origin of an event
       and how to respond.
     </p>
     <p>
       If a callback function fails or returns a bad value,
-      the <c>gen_statem</c> will terminate.  An exception of class
-      <seealso marker="erts:erlang#throw/1"><c>throw</c></seealso>,
-      however, is not regarded as an error but as a valid return.
+      the <c>gen_statem</c> terminates. However, an exception of class
+      <seealso marker="erts:erlang#throw/1"><c>throw</c></seealso>
+      is not regarded as an error but as a valid return.
     </p>
-    <marker id="state_function" />
+    <marker id="state_function"/>
     <p>
       The "<em>state function</em>" for a specific
       <seealso marker="#type-state">state</seealso>
       in a <c>gen_statem</c> is the callback function that is called
-      for all events in this state, and is selected depending on which
+      for all events in this state. It is selected depending on which
       <seealso marker="#type-callback_mode"><em>callback mode</em></seealso>
-      that the implementation specifies when the the server starts.
+      that the implementation specifies when the server starts.
     </p>
     <p>
       When the
       <seealso marker="#type-callback_mode"><em>callback mode</em></seealso>
-      is <c>state_functions</c>, the state has to be an atom and
-      is used as the state function name.  See
+      is <c>state_functions</c>, the state must be an atom and
+      is used as the state function name; see
       <seealso marker="#Module:StateName/3">
         <c>Module:StateName/3</c>
       </seealso>.
       This gathers all code for a specific state
       in one function and hence dispatches on state first.
-      Note that in this mode the fact that there is
-      a mandatory callback function
+      Notice that in this mode
+      the mandatory callback function
       <seealso marker="#Module:terminate/3">
         <c>Module:terminate/3</c>
       </seealso> makes the state name <c>terminate</c> unusable.
@@ -141,21 +150,21 @@ erlang:'!'            -----> Module:StateName/3
     <p>
       When the
       <seealso marker="#type-callback_mode"><em>callback mode</em></seealso>
-      is <c>handle_event_function</c> the state can be any term
+      is <c>handle_event_function</c>, the state can be any term
       and the state function name is
       <seealso marker="#Module:handle_event/4">
         <c>Module:handle_event/4</c>
       </seealso>.
       This makes it easy to dispatch on state or on event as you desire.
       Be careful about which events you handle in which
-      states so you do not accidentally postpone one event
+      states so that you do not accidentally postpone one event
       forever creating an infinite busy loop.
     </p>
     <p>
       The <c>gen_statem</c> enqueues incoming events in order of arrival
       and presents these to the
       <seealso marker="#state_function">state function</seealso>
-      in that order.  The state function can postpone an event
+      in that order. The state function can postpone an event
       so it is not retried in the current state.
       After a state change the queue restarts with the postponed events.
     </p>
@@ -163,7 +172,7 @@ erlang:'!'            -----> Module:StateName/3
       The <c>gen_statem</c> event queue model is sufficient
       to emulate the normal process message queue with selective receive.
       Postponing an event corresponds to not matching it
-      in a receive statement and changing states corresponds
+      in a receive statement, and changing states corresponds
       to entering a new receive statement.
     </p>
     <p>
@@ -173,73 +182,76 @@ erlang:'!'            -----> Module:StateName/3
 	<c>action()</c> <c>next_event</c>
       </seealso>
       and such an event is inserted as the next to present
-      to the state function.  That is: as if it is
-      the oldest incoming event.  There is a dedicated
+      to the state function. That is, as if it is
+      the oldest incoming event. A dedicated
       <seealso marker="#type-event_type">
         <c>event_type()</c>
       </seealso>
-      <c>internal</c> that can be used for such events making them impossible
+      <c>internal</c> can be used for such events making them impossible
       to mistake for external events.
     </p>
     <p>
       Inserting an event replaces the trick of calling your own
       state handling functions that you often would have to
-      resort to in for example <seealso marker="gen_fsm"><c>gen_fsm</c></seealso>
+      resort to in, for example,
+      <seealso marker="gen_fsm"><c>gen_fsm</c></seealso>
       to force processing an inserted event before others.
-      A warning, though: if you in <c>gen_statem</c> for example
-      postpone an event in one state and then call some other state function of yours,
-      you have not changed states and hence the postponed event will not be retried,
-      which is logical but might be confusing.
     </p>
+    <note>
+      <p>If you in <c>gen_statem</c>, for example, postpone
+        an event in one state and then call another state function
+        of yours, you have not changed states and hence the postponed event
+        is not retried, which is logical but can be confusing.
+      </p>
+    </note>
     <p>
-      See the type
+      For the details of a state transition, see type
       <seealso marker="#type-transition_option">
-	<c>transition_option()</c>
-      </seealso>
-      for the details of a state transition.
+        <c>transition_option()</c>
+      </seealso>.
     </p>
     <p>
-      A <c>gen_statem</c> handles system messages as documented in
+      A <c>gen_statem</c> handles system messages as described in
       <seealso marker="sys"><c>sys</c></seealso>.
       The <c>sys</c>module can be used for debugging a <c>gen_statem</c>.
     </p>
     <p>
-      Note that a <c>gen_statem</c> does not trap exit signals
+      Notice that a <c>gen_statem</c> does not trap exit signals
       automatically, this must be explicitly initiated in
       the callback module (by calling
       <seealso marker="erts:erlang#process_flag/2">
-	<c>process_flag(trap_exit, true)</c></seealso>.
+        <c>process_flag(trap_exit, true)</c></seealso>.
     </p>
     <p>
       Unless otherwise stated, all functions in this module fail if
       the specified <c>gen_statem</c> does not exist or
-      if bad arguments are given.
+      if bad arguments are specified.
     </p>
     <p>
       The <c>gen_statem</c> process can go into hibernation; see
       <seealso marker="proc_lib#hibernate/3">
-	<c>proc_lib:hibernate/3</c>.
-      </seealso>
+        <c>proc_lib:hibernate/3</c>
+      </seealso>.
       It is done when a
       <seealso marker="#state_function">state function</seealso> or
       <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>
       specifies <c>hibernate</c> in the returned
       <seealso marker="#type-action"><c>Actions</c></seealso>
-      list. This feature might be useful to reclaim process heap memory
+      list. This feature can be useful to reclaim process heap memory
       while the server is expected to be idle for a long time.
-      However, use this feature with care
-      since hibernation can be too costly
+      However, use this feature with care,
+      as hibernation can be too costly
       to use after every event; see
       <seealso marker="erts:erlang#hibernate/3">
-	<c>erlang:hibernate/3</c>.
-      </seealso>
+        <c>erlang:hibernate/3</c>
+      </seealso>.
     </p>
   </description>
 
   <section>
-    <title>EXAMPLE</title>
+    <title>Example</title>
     <p>
-      This example shows a simple pushbutton model
+      The following example shows a simple pushbutton model
       for a toggling pushbutton implemented with
       <seealso marker="#type-callback_mode"><em>callback mode</em></seealso>
       <c>state_functions</c>.
@@ -247,7 +259,8 @@ erlang:'!'            -----> Module:StateName/3
       and you can ask for a count of how many times it has been
       pushed to on.
     </p>
-    <p>This is the complete callback module file <c>pushbutton.erl</c>:</p>
+    <p>The following is the complete callback module file
+      <c>pushbutton.erl</c>:</p>
     <code type="erl">
 -module(pushbutton).
 -behaviour(gen_statem).
@@ -305,7 +318,7 @@ handle_event(_, _, Data) ->
     %% Ignore all other events
     {keep_state,Data}.
     </code>
-    <p>And this is a shell session when running it:</p>
+    <p>The following is a shell session when running it:</p>
     <pre>
 1> pushbutton:start().
 {ok,&lt;0.36.0>}
@@ -326,12 +339,11 @@ ok
      in function  gen:do_for_proc/2 (gen.erl, line 261)
      in call from gen_statem:call/3 (gen_statem.erl, line 386)
     </pre>
-
     <p>
-      And just to compare styles here is the same example using
+      To compare styles, here follows the same example using
       <seealso marker="#type-callback_mode"><em>callback mode</em></seealso>
-      <c>state_functions</c>, or rather here is code to replace
-      from the <c>init/1</c> function of the <c>pushbutton.erl</c>
+      <c>state_functions</c>, or rather the code to replace
+      from function <c>init/1</c> of the <c>pushbutton.erl</c>
       example file above:
     </p>
     <code type="erl">
@@ -364,11 +376,11 @@ handle_event(_, _, State, Data) ->
 
   <datatypes>
     <datatype>
-      <name name="server_name" />
+      <name name="server_name"/>
       <desc>
 	<p>
 	  Name specification to use when starting
-	  a <c>gen_statem</c> server.  See
+	  a <c>gen_statem</c> server. See
 	  <seealso marker="#start_link/3">
 	    <c>start_link/3</c>
 	  </seealso>
@@ -380,7 +392,7 @@ handle_event(_, _, State, Data) ->
       </desc>
     </datatype>
     <datatype>
-      <name name="server_ref" />
+      <name name="server_ref"/>
       <desc>
 	<p>
 	  Server specification to use when addressing
@@ -393,75 +405,83 @@ handle_event(_, _, State, Data) ->
 	</p>
 	<p>It can be:</p>
 	<taglist>
-	  <tag><c>pid()</c><br />
-	  <c>LocalName</c></tag>
-	  <item>The <c>gen_statem</c> is locally registered.</item>
+	  <tag><c>pid()</c> | <c>LocalName</c></tag>
+	  <item>
+            <p>
+              The <c>gen_statem</c> is locally registered.
+            </p>
+          </item>
 	  <tag><c>{Name,Node}</c></tag>
 	  <item>
-	    The <c>gen_statem</c> is locally registered
-	    on another node.
+            <p>
+	      The <c>gen_statem</c> is locally registered
+	      on another node.
+            </p>
 	  </item>
 	  <tag><c>{global,GlobalName}</c></tag>
 	  <item>
-	    The <c>gen_statem</c> is globally registered
-	    in <seealso marker="kernel:global"><c>global</c></seealso>.
+            <p>
+	      The <c>gen_statem</c> is globally registered
+	      in <seealso marker="kernel:global"><c>kernel:global</c></seealso>.
+            </p>
 	  </item>
 	  <tag><c>{via,RegMod,ViaName}</c></tag>
 	  <item>
-	    The <c>gen_statem</c> is registered through
-	    an alternative process registry.
-	    The registry callback module <c>RegMod</c>
-	    should export the functions
-	    <c>register_name/2</c>, <c>unregister_name/1</c>,
-	    <c>whereis_name/1</c> and <c>send/2</c>,
-	    which should behave like the corresponding functions
-	    in <seealso marker="kernel:global"><c>global</c></seealso>.
-	    Thus, <c>{via,global,GlobalName}</c> is the same as
-	    <c>{global,GlobalName}</c>.
+            <p>
+	      The <c>gen_statem</c> is registered through
+	      an alternative process registry.
+	      The registry callback module <c>RegMod</c>
+	      is to export functions
+	      <c>register_name/2</c>, <c>unregister_name/1</c>,
+	      <c>whereis_name/1</c>, and <c>send/2</c>,
+	      which are to behave like the corresponding functions
+	      in <seealso marker="kernel:global"><c>kernel:global</c></seealso>.
+	      Thus, <c>{via,global,GlobalName}</c> is the same as
+	      <c>{global,GlobalName}</c>.
+            </p>
 	  </item>
 	</taglist>
       </desc>
     </datatype>
     <datatype>
-      <name name="debug_opt" />
+      <name name="debug_opt"/>
       <desc>
 	<p>
 	  Debug option that can be used when starting
-	  a <c>gen_statem</c> server through for example
+	  a <c>gen_statem</c> server through, for example,
 	  <seealso marker="#enter_loop/5"><c>enter_loop/5</c></seealso>.
 	</p>
 	<p>
-	  For every entry in <c><anno>Dbgs</anno></c>
+	  For every entry in <c><anno>Dbgs</anno></c>,
 	  the corresponding function in
-	  <seealso marker="sys"><c>sys</c></seealso> will be called.
+	  <seealso marker="sys"><c>sys</c></seealso> is called.
 	</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="start_opt" />
+      <name name="start_opt"/>
       <desc>
 	<p>
 	  Options that can be used when starting
-	  a <c>gen_statem</c> server through for example
+	  a <c>gen_statem</c> server through, for example,
 	  <seealso marker="#start_link/3"><c>start_link/3</c></seealso>.
 	</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="start_ret" />
+      <name name="start_ret"/>
       <desc>
 	<p>
-	  Return value from the start functions for_example
+	  Return value from the start functions, for example,
 	  <seealso marker="#start_link/3"><c>start_link/3</c></seealso>.
 	</p>
       </desc>
     </datatype>
-
     <datatype>
-      <name name="from" />
+      <name name="from"/>
       <desc>
 	<p>
-	  Destination to use when replying through for example the
+	  Destination to use when replying through, for example, the
 	  <seealso marker="#type-action">
 	    <c>action()</c>
 	  </seealso>
@@ -472,178 +492,194 @@ handle_event(_, _, State, Data) ->
       </desc>
     </datatype>
     <datatype>
-      <name name="state" />
+      <name name="state"/>
       <desc>
 	<p>
-	  After a state change (<c>NextState =/= State</c>)
+	  After a state change (<c>NextState =/= State</c>),
 	  all postponed events are retried.
 	</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="state_name" />
+      <name name="state_name"/>
       <desc>
 	<p>
 	  If the
 	  <seealso marker="#type-callback_mode"><em>callback mode</em></seealso>
 	  is <c>state_functions</c>,
-	  the state has to be of this type.
+	  the state must be of this type.
 	</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="data" />
+      <name name="data"/>
       <desc>
 	<p>
 	  A term in which the state machine implementation
-	  should store any server data it needs.  The difference between
+	  is to store any server data it needs. The difference between
 	  this and the <seealso marker="#type-state"><c>state()</c></seealso>
 	  itself is that a change in this data does not cause
-	  postponed events to be retried.  Hence if a change
+	  postponed events to be retried. Hence, if a change
 	  in this data would change the set of events that
-	  are handled than that data item should be made
+	  are handled, then that data item is to be made
 	  a part of the state.
 	</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="event_type" />
+      <name name="event_type"/>
       <desc>
 	<p>
-	  External events are of 3 different type:
-	  <c>{call,<anno>From</anno>}</c>, <c>cast</c> or <c>info</c>.
+	  External events are of three types:
+	  <c>{call,<anno>From</anno>}</c>, <c>cast</c>, or <c>info</c>.
 	  <seealso marker="#call/2">Calls</seealso>
 	  (synchronous) and
 	  <seealso marker="#cast/2">casts</seealso>
 	  originate from the corresponding API functions.
-	  For calls the event contain whom to reply to.
+	  For calls, the event contains whom to reply to.
 	  Type <c>info</c> originates from regular process messages sent
-	  to the <c>gen_statem</c>. It is also possible for the state machine
-	  implementation to generate events of types
+	  to the <c>gen_statem</c>. Also, the state machine
+	  implementation can generate events of types
 	  <c>timeout</c> and <c>internal</c> to itself.
 	</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="callback_mode" />
+      <name name="callback_mode"/>
       <desc>
 	<p>
 	  The <em>callback mode</em> is selected when starting the
 	  <c>gen_statem</c> using the return value from
 	  <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>
 	  or when calling
-	  <seealso marker="#enter_loop/5"><c>enter_loop/5-7</c></seealso>,
+	  <seealso marker="#enter_loop/5"><c>enter_loop/5,6,7</c></seealso>,
 	  and with the return value from
 	  <seealso marker="#Module:code_change/4">
-	    <c>Module:code_change/4</c>.
-	  </seealso>
+	    <c>Module:code_change/4</c>
+	  </seealso>.
 	</p>
 	<taglist>
 	  <tag><c>state_functions</c></tag>
 	  <item>
-	    The state has to be of type
-	    <seealso marker="#type-state_name"><c>state_name()</c></seealso>
-	    and one callback function per state that is
-	    <seealso marker="#Module:StateName/3">
-	      <c>Module:StateName/3</c>
-	    </seealso>
-	    is used.
+	    <p>
+	      The state must be of type
+	      <seealso marker="#type-state_name"><c>state_name()</c></seealso>
+	      and one callback function per state, that is,
+	      <seealso marker="#Module:StateName/3">
+	        <c>Module:StateName/3</c>
+	      </seealso>,
+	      is used.
+	    </p>
 	  </item>
 	  <tag><c>handle_event_function</c></tag>
 	  <item>
-	    The state can be any term and the callback function
-	    <seealso marker="#Module:handle_event/4">
-	      <c>Module:handle_event/4</c>
-	    </seealso>
-	    is used for all states.
+	    <p>
+	      The state can be any term and the callback function
+	      <seealso marker="#Module:handle_event/4">
+	        <c>Module:handle_event/4</c>
+	      </seealso>
+	      is used for all states.
+	    </p>
 	  </item>
 	</taglist>
       </desc>
     </datatype>
     <datatype>
-      <name name="transition_option" />
+      <name name="transition_option"/>
       <desc>
 	<p>
-	  Transition options may be set by
+	  Transition options can be set by
 	  <seealso marker="#type-action">actions</seealso>
-	  and they modify some details below in how
+	  and they modify the following in how
 	  the state transition is done:
 	</p>
 	<list type="ordered">
 	  <item>
-	    All
-            <seealso marker="#type-action">actions</seealso>
-	    are processed in order of appearance.
+	    <p>
+	      All
+              <seealso marker="#type-action">actions</seealso>
+	      are processed in order of appearance.
+            </p>
 	  </item>
 	  <item>
-	    If
-            <seealso marker="#type-postpone">
-	      <c>postpone()</c>
-	    </seealso>
-	    is <c>true</c>
-	    the current event is postponed.
+            <p>
+	      If
+              <seealso marker="#type-postpone">
+	        <c>postpone()</c>
+	      </seealso>
+	      is <c>true</c>,
+	      the current event is postponed.
+	    </p>
 	  </item>
 	  <item>
-	    If the state changes the queue of incoming events
-            is reset to start with the oldest postponed.
+	    <p>
+	      If the state changes, the queue of incoming events
+              is reset to start with the oldest postponed.
+	    </p>
 	  </item>
 	  <item>
-	    All events stored with
-	    <seealso marker="#type-action">
-	      <c>action()</c>
-	    </seealso>
-	    <c>next_event</c>
-	    are inserted in the queue to be processed before
-	    all other events.
+            <p>
+	      All events stored with
+	      <seealso marker="#type-action">
+	        <c>action()</c>
+	      </seealso>
+	      <c>next_event</c>
+	      are inserted in the queue to be processed before
+	      all other events.
+            </p>
 	  </item>
 	  <item>
-	    If an
-            <seealso marker="#type-event_timeout">
-	      <c>event_timeout()</c>
-	    </seealso>
-	    is set through
-            <seealso marker="#type-action">
-	      <c>action()</c>
-	    </seealso>
-	    <c>timeout</c>
-	    an event timer may be started or a timeout zero event
-	    may be enqueued.
+	    <p>
+	      If an
+              <seealso marker="#type-event_timeout">
+	        <c>event_timeout()</c>
+	      </seealso>
+	      is set through
+	      <seealso marker="#type-action">
+	        <c>action()</c>
+	      </seealso>
+	      <c>timeout</c>,
+	      an event timer can be started or a time-out zero event
+	      can be enqueued.
+	    </p>
 	  </item>
 	  <item>
-	    The (possibly new)
-            <seealso marker="#state_function">state function</seealso>
-            is called with the oldest enqueued event if there is any,
-	    otherwise the <c>gen_statem</c> goes into <c>receive</c>
-	    or hibernation
-	    (if
-            <seealso marker="#type-hibernate">
-	      <c>hibernate()</c>
-	    </seealso>
-	    is <c>true</c>)
-	    to wait for the next message.  In hibernation the next
-	    non-system event awakens the <c>gen_statem</c>, or rather
-	    the next incoming message awakens the <c>gen_statem</c>
-	    but if it is a system event
-	    it goes right back into hibernation.
+	    <p>
+	      The (possibly new)
+	      <seealso marker="#state_function">state function</seealso>
+	      is called with the oldest enqueued event if there is any,
+	      otherwise the <c>gen_statem</c> goes into <c>receive</c>
+	      or hibernation
+	      (if
+	      <seealso marker="#type-hibernate">
+	        <c>hibernate()</c>
+	      </seealso>
+	      is <c>true</c>)
+	      to wait for the next message. In hibernation the next
+	      non-system event awakens the <c>gen_statem</c>, or rather
+	      the next incoming message awakens the <c>gen_statem</c>,
+	      but if it is a system event
+	      it goes right back into hibernation.
+	    </p>
 	  </item>
 	</list>
       </desc>
     </datatype>
     <datatype>
-      <name name="postpone" />
+      <name name="postpone"/>
       <desc>
 	<p>
-	  If <c>true</c> postpone the current event and retry
+	  If <c>true</c>, postpones the current event and retries
 	  it when the state changes
 	  (<c>NextState =/= State</c>).
 	</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="hibernate" />
+      <name name="hibernate"/>
       <desc>
 	<p>
-	  If <c>true</c> hibernate the <c>gen_statem</c>
+	  If <c>true</c>, hibernates the <c>gen_statem</c>
 	  by calling
 	  <seealso marker="proc_lib#hibernate/3">
 	    <c>proc_lib:hibernate/3</c>
@@ -651,9 +687,9 @@ handle_event(_, _, State, Data) ->
 	  before going into <c>receive</c>
 	  to wait for a new external event.
 	  If there are enqueued events,
-	  to prevent receiving any new event; a
+	  to prevent receiving any new event, an
 	  <seealso marker="erts:erlang#garbage_collect/0">
-	    <c>garbage_collect/0</c>
+	    <c>erlang:garbage_collect/0</c>
 	  </seealso> is done instead to simulate
 	  that the <c>gen_statem</c> entered hibernation
 	  and immediately got awakened by the oldest enqueued event.
@@ -661,39 +697,39 @@ handle_event(_, _, State, Data) ->
       </desc>
     </datatype>
     <datatype>
-      <name name="event_timeout" />
+      <name name="event_timeout"/>
       <desc>
 	<p>
-	  Generate an event of
+	  Generates an event of
 	  <seealso marker="#type-event_type"><c>event_type()</c></seealso>
 	  <c>timeout</c>
-	  after this time (in milliseconds) unless some other
-	  event arrives in which case this timeout is cancelled.
-	  Note that a retried or inserted event
-	  counts just like a new in this respect.
+	  after this time (in milliseconds) unless another
+	  event arrives in which case this time-out is cancelled.
+	  Notice that a retried or inserted event
+	  counts like a new in this respect.
 	</p>
 	<p>
-	  If the value is <c>infinity</c> no timer is started since
-	  it will never trigger anyway.
+	  If the value is <c>infinity</c>, no timer is started, as
+	  it never triggers anyway.
 	</p>
 	<p>
-	  If the value is <c>0</c> the timeout event is immediately enqueued
-	  unless there already are enqueued events since then the
-	  timeout is immediately cancelled.
-	  This is a feature ensuring that a timeout <c>0</c> event
-	  will be processed before any not yet received external event.
+	  If the value is <c>0</c>, the time-out event is immediately enqueued
+	  unless there already are enqueued events, as the
+	  time-out is then immediately cancelled.
+	  This is a feature ensuring that a time-out <c>0</c> event
+	  is processed before any not yet received external event.
 	</p>
 	<p>
-	  Note that it is not possible nor needed to cancel this timeout
-	  since it is cancelled automatically by any other event.
+	  Notice that it is not possible or needed to cancel this time-out,
+	  as it is cancelled automatically by any other event.
 	</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="action" />
+      <name name="action"/>
       <desc>
 	<p>
-	  These state transition actions may be invoked by
+	  These state transition actions can be invoked by
 	  returning them from the
 	  <seealso marker="#state_function">state function</seealso>,
 	  from <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>
@@ -708,9 +744,9 @@ handle_event(_, _, State, Data) ->
 	  <seealso marker="#type-transition_option">
 	    transition options
 	  </seealso>
-	  overrides any previous of the same type,
+	  override any previous of the same type,
 	  so the last in the containing list wins.
-	  For example the last
+	  For example, the last
 	  <seealso marker="#type-event_timeout">
 	    <c>event_timeout()</c>
 	  </seealso>
@@ -719,77 +755,87 @@ handle_event(_, _, State, Data) ->
 	<taglist>
 	  <tag><c>postpone</c></tag>
 	  <item>
-	    Set the
-	    <seealso marker="#type-transition_option">
-	      <c>transition_option()</c>
-	    </seealso>
-	    <seealso marker="#type-postpone">
-	      <c>postpone()</c>
-	    </seealso>
-	    for this state transition.
-	    This action is ignored when returned from
-	    <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>
-	    or given to
-	    <seealso marker="#enter_loop/5"><c>enter_loop/5,6</c></seealso>
-	    since there is no event to postpone in those cases.
+	    <p>
+	      Sets the
+	      <seealso marker="#type-transition_option">
+	        <c>transition_option()</c>
+	      </seealso>
+	      <seealso marker="#type-postpone">
+	        <c>postpone()</c>
+	      </seealso>
+	      for this state transition.
+	      This action is ignored when returned from
+	      <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>
+	      or given to
+	      <seealso marker="#enter_loop/5"><c>enter_loop/5,6</c></seealso>,
+	      as there is no event to postpone in those cases.
+	    </p>
 	  </item>
 	  <tag><c>hibernate</c></tag>
 	  <item>
-	    Set the
-	    <seealso marker="#type-transition_option">
-	      <c>transition_option()</c>
-	    </seealso>
-	    <seealso marker="#type-hibernate">
-	      <c>hibernate()</c>
-	    </seealso>
-	    for this state transition.
+	    <p>
+	      Sets the
+	      <seealso marker="#type-transition_option">
+	        <c>transition_option()</c>
+	      </seealso>
+	      <seealso marker="#type-hibernate">
+	        <c>hibernate()</c>
+	      </seealso>
+	      for this state transition.
+	    </p>
 	  </item>
 	  <tag><c>Timeout</c></tag>
 	  <item>
-	    Short for <c>{timeout,Timeout,Timeout}</c> that is
-	    the timeout message is the timeout time.
-	    This form exists to make the
-	    <seealso marker="#state_function">state function</seealso>
-	    return value <c>{next_state,NextState,NewData,Timeout}</c>
-	    allowed like for
-	    <seealso marker="gen_fsm#Module:StateName/2">
-	      <c>gen_fsm Module:StateName/2</c>.
-	    </seealso>
+	    <p>
+	      Short for <c>{timeout,Timeout,Timeout}</c>, that is,
+	      the time-out message is the time-out time.
+	      This form exists to make the
+	      <seealso marker="#state_function">state function</seealso>
+	      return value <c>{next_state,NextState,NewData,Timeout}</c>
+	      allowed like for
+	      <seealso marker="gen_fsm#Module:StateName/2">
+	        <c>gen_fsm:Module:StateName/2</c>
+	      </seealso>.
+	    </p>
 	  </item>
 	  <tag><c>timeout</c></tag>
 	  <item>
-	    Set the
-	    <seealso marker="#type-transition_option">
-	      <c>transition_option()</c>
-	    </seealso>
-	    <seealso marker="#type-event_timeout">
-	      <c>event_timeout()</c>
-	    </seealso>
-	    to <c><anno>Time</anno></c> with <c><anno>EventContent</anno></c>.
+	    <p>
+	      Sets the
+	      <seealso marker="#type-transition_option">
+	        <c>transition_option()</c>
+	      </seealso>
+	      <seealso marker="#type-event_timeout">
+	        <c>event_timeout()</c>
+	      </seealso>
+	      to <c><anno>Time</anno></c> with <c><anno>EventContent</anno></c>.
+	    </p>
 	  </item>
 	  <tag><c>reply_action()</c></tag>
-	  <item>Reply to a caller.</item>
+	  <item>
+	    <p>
+              Replies to a caller.
+	    </p>
+          </item>
 	  <tag><c>next_event</c></tag>
 	  <item>
-	      Store the given <c><anno>EventType</anno></c>
+	    <p>
+	      Stores the specified <c><anno>EventType</anno></c>
 	      and <c><anno>EventContent</anno></c> for insertion after all
 	      actions have been executed.
-	  </item>
-	  <item>
+	    </p>
 	    <p>
 	      The stored events are inserted in the queue as the next to process
-	      before any already queued events.  The order of these stored events
-	      is preserved so the first <c>next_event</c> in the containing list
-	      will become the first to process.
+	      before any already queued events. The order of these stored events
+	      is preserved, so the first <c>next_event</c> in the containing
+	      list becomes the first to process.
 	    </p>
-	  </item>
-	  <item>
 	    <p>
 	      An event of type
 	      <seealso marker="#type-event_type">
 		<c>internal</c>
 	      </seealso>
-	      should be used when you want to reliably distinguish
+	      is to be used when you want to reliably distinguish
 	      an event inserted this way from any external event.
 	    </p>
 	  </item>
@@ -797,294 +843,125 @@ handle_event(_, _, State, Data) ->
       </desc>
     </datatype>
     <datatype>
-      <name name="reply_action" />
+      <name name="reply_action"/>
       <desc>
 	<p>
-	  Reply to a caller waiting for a reply in
+	  Replies to a caller waiting for a reply in
 	  <seealso marker="#call/2"><c>call/2</c></seealso>.
-          <c><anno>From</anno></c> must be the term from the
+	  <c><anno>From</anno></c> must be the term from argument
 	  <seealso marker="#type-event_type">
 	    <c>{call,<anno>From</anno>}</c>
 	  </seealso>
-	  argument to the
+	  to the
 	  <seealso marker="#state_function">state function</seealso>.
 	</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="state_function_result" />
+      <name name="state_function_result"/>
       <desc>
 	<taglist>
 	  <tag><c>next_state</c></tag>
 	  <item>
-	    The <c>gen_statem</c> will do a state transition to
-	    <c><anno>NextStateName</anno></c>
-	    (which may be the same as the current state),
-	    set <c><anno>NewData</anno></c>
-	    and execute all <c><anno>Actions</anno></c>
+	    <p>
+	      The <c>gen_statem</c> does a state transition to
+	      <c><anno>NextStateName</anno></c>
+	      (which can be the same as the current state),
+	      sets <c><anno>NewData</anno></c>,
+	      and executes all <c><anno>Actions</anno></c>.
+	    </p>
 	  </item>
 	</taglist>
 	<p>
 	  All these terms are tuples or atoms and this property
-	  will hold in any future version of <c>gen_statem</c>,
-	  just in case you need such a promise.
+	  will hold in any future version of <c>gen_statem</c>.
 	</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="handle_event_result" />
+      <name name="handle_event_result"/>
       <desc>
 	<taglist>
 	  <tag><c>next_state</c></tag>
 	  <item>
-	    The <c>gen_statem</c> will do a state transition to
-	    <c><anno>NextState</anno></c>
-	    (which may be the same as the current state),
-	    set <c><anno>NewData</anno></c>
-	    and execute all <c><anno>Actions</anno></c>
+	    <p>
+	      The <c>gen_statem</c> does a state transition to
+	      <c><anno>NextState</anno></c>
+	      (which can be the same as the current state),
+	      sets <c><anno>NewData</anno></c>,
+	      and executes all <c><anno>Actions</anno></c>.
+	    </p>
 	  </item>
 	</taglist>
 	<p>
 	  All these terms are tuples or atoms and this property
-	  will hold in any future version of <c>gen_statem</c>,
-	  just in case you need such a promise.
+	  will hold in any future version of <c>gen_statem</c>.
 	</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="common_state_callback_result" />
+      <name name="common_state_callback_result"/>
       <desc>
 	<taglist>
 	  <tag><c>stop</c></tag>
 	  <item>
-	    Terminate the <c>gen_statem</c> by calling
-	    <seealso marker="#Module:terminate/3">
-	      <c>Module:terminate/3</c>
-	    </seealso>
-	    with <c>Reason</c> and
-	    <c><anno>NewData</anno></c>, if given.
+	    <p>
+	      Terminates the <c>gen_statem</c> by calling
+	      <seealso marker="#Module:terminate/3">
+	        <c>Module:terminate/3</c>
+	      </seealso>
+	      with <c>Reason</c> and
+	      <c><anno>NewData</anno></c>, if specified.
+	    </p>
 	  </item>
 	  <tag><c>stop_and_reply</c></tag>
 	  <item>
-	    Send all <c><anno>Replies</anno></c>
-	    then terminate the <c>gen_statem</c> by calling
-	    <seealso marker="#Module:terminate/3">
-	      <c>Module:terminate/3</c>
-	    </seealso>
-	    with <c>Reason</c> and
-	    <c><anno>NewData</anno></c>, if given.
+	    <p>
+	      Sends all <c><anno>Replies</anno></c>,
+	      then terminates the <c>gen_statem</c> by calling
+	      <seealso marker="#Module:terminate/3">
+	        <c>Module:terminate/3</c>
+	      </seealso>
+	      with <c>Reason</c> and
+	      <c><anno>NewData</anno></c>, if specified.
+	    </p>
 	  </item>
 	  <tag><c>keep_state</c></tag>
 	  <item>
-	    The <c>gen_statem</c> will keep the current state, or
-	    do a state transition to the current state if you like,
-	    set <c><anno>NewData</anno></c>
-	    and execute all <c><anno>Actions</anno></c>.
-	    This is the same as
-	    <c>{next_state,CurrentState,<anno>NewData</anno>,<anno>Actions</anno>}</c>.
+	    <p>
+	      The <c>gen_statem</c> keeps the current state, or
+	      does a state transition to the current state if you like,
+	      sets <c><anno>NewData</anno></c>,
+	      and executes all <c><anno>Actions</anno></c>.
+	      This is the same as
+	      <c>{next_state,CurrentState,<anno>NewData</anno>,<anno>Actions</anno>}</c>.
+	    </p>
 	  </item>
 	  <tag><c>keep_state_and_data</c></tag>
 	  <item>
-	    The <c>gen_statem</c> will keep the current state or
-	    do a state transition to the current state if you like,
-	    keep the current server data,
-	    and execute all <c><anno>Actions</anno></c>.
-	    This is the same as
-	    <c>{next_state,CurrentState,CurrentData,<anno>Actions</anno>}</c>.
+	    <p>
+	      The <c>gen_statem</c> keeps the current state or
+	      does a state transition to the current state if you like,
+	      keeps the current server data,
+	      and executes all <c><anno>Actions</anno></c>.
+	      This is the same as
+	      <c>{next_state,CurrentState,CurrentData,<anno>Actions</anno>}</c>.
+	    </p>
 	  </item>
 	</taglist>
 	<p>
 	  All these terms are tuples or atoms and this property
-	  will hold in any future version of <c>gen_statem</c>,
-	  just in case you need such a promise.
+	  will hold in any future version of <c>gen_statem</c>.
 	</p>
       </desc>
     </datatype>
   </datatypes>
 
   <funcs>
-
     <func>
-      <name name="start_link" arity="3" />
-      <name name="start_link" arity="4" />
-      <fsummary>Create a linked <c>gen_statem</c> process</fsummary>
-      <desc>
-        <p>
-	  Creates a <c>gen_statem</c> process according
-	  to OTP design principles
-	  (using
-          <seealso marker="proc_lib"><c>proc_lib</c></seealso>
-	  primitives)
-	  that is linked to the calling process.
-	  This is essential when the <c>gen_statem</c> shall be part of
-	  a supervision tree so it gets linked to its supervisor.
-	</p>
-        <p>
-	  The <c>gen_statem</c> process calls
-	  <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>
-	  to initialize the server. To ensure a synchronized start-up
-	  procedure, <c>start_link/3,4</c> does not return until
-	  <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>
-          has returned.
-	</p>
-	<p>
-	  <c><anno>ServerName</anno></c> specifies the
-	  <seealso marker="#type-server_name">
-	    <c>server_name()</c>
-	  </seealso>
-	  to register for the <c>gen_statem</c>.
-	  If the <c>gen_statem</c> is started with  <c>start_link/3</c>
-	  no <c><anno>ServerName</anno></c> is provided and
-	  the <c>gen_statem</c> is not registered.
-	</p>
-        <p><c><anno>Module</anno></c> is the name of the callback module.</p>
-        <p>
-	  <c><anno>Args</anno></c> is an arbitrary term which is passed as
-          the argument to
-	  <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>.
-	</p>
-        <p>
-	  If the option <c>{timeout,Time}</c> is present in
-	  <c><anno>Opts</anno></c>, the <c>gen_statem</c>
-	  is allowed to spend <c>Time</c> milliseconds initializing
-	  or it will be terminated and the start function will return
-	  <seealso marker="#type-start_ret"><c>{error,timeout}</c></seealso>.
-	</p>
-        <p>
-	  If the option
-	  <seealso marker="#type-debug_opt"><c>{debug,Dbgs}</c></seealso>
-	  is present in <c><anno>Opts</anno></c>, debugging through
-	  <seealso marker="sys"><c>sys</c></seealso> is activated.
-	</p>
-        <p>
-	  If the option <c>{spawn_opt,SpawnOpts}</c> is present in
-	  <c><anno>Opts</anno></c>, <c>SpawnOpts</c> will be passed
-	  as option list to
-          <seealso marker="erts:erlang#spawn_opt/2"><c>spawn_opt/2</c></seealso>
-	  which is used to spawn the <c>gen_statem</c> process.
-	</p>
-        <note>
-          <p>
-	    Using the spawn option <c>monitor</c> is currently not
-            allowed, but will cause this function to fail with reason
-            <c>badarg</c>.
-	  </p>
-        </note>
-        <p>
-	  If the <c>gen_statem</c> is successfully created
-	  and initialized this function returns
-	  <seealso marker="#type-start_ret">
-	    <c>{ok,Pid}</c>,
-	  </seealso>
-	  where <c>Pid</c> is the <c>pid()</c>
-	  of the <c>gen_statem</c>.
-	  If there already exists a process with the specified
-	  <c><anno>ServerName</anno></c> this function returns
-	  <seealso marker="#type-start_ret"><c>{error,{already_started,Pid}}</c></seealso>,
-	  where <c>Pid</c> is the <c>pid()</c> of that process.
-	</p>
-        <p>
-	  If <c>Module:init/1</c> fails with <c>Reason</c>,
-          this function returns
-	  <seealso marker="#type-start_ret"><c>{error,Reason}</c></seealso>.
-	  If <c>Module:init/1</c> returns
-	  <seealso marker="#type-start_ret">
-	    <c>{stop,Reason}</c>
-	  </seealso>
-	  or
-	  <seealso marker="#type-start_ret"><c>ignore</c></seealso>,
-	  the process is terminated and this function
-          returns
-	  <seealso marker="#type-start_ret">
-	    <c>{error,Reason}</c>
-	  </seealso>
-	  or
-	  <seealso marker="#type-start_ret"><c>ignore</c></seealso>,
-	  respectively.
-	</p>
-      </desc>
-    </func>
-
-
-    <func>
-      <name name="start" arity="3" />
-      <name name="start" arity="4" />
-      <fsummary>Create a stand-alone <c>gen_statem</c> process</fsummary>
-      <desc>
-        <p>
-	  Creates a stand-alone <c>gen_statem</c> process according to
-	  OTP design principles (using
-          <seealso marker="proc_lib"><c>proc_lib</c></seealso>
-	  primitives).
-	  Since it does not get linked to the calling process
-	  this start function can not be used by a supervisor
-	  to start a child.
-	</p>
-        <p>
-	  See <seealso marker="#start_link/3"><c>start_link/3,4</c></seealso>
-          for a description of arguments and return values.
-	</p>
-      </desc>
-    </func>
-
-    <func>
-      <name name="stop" arity="1" />
-      <fsummary>Synchronously stop a generic server</fsummary>
-      <desc>
-	<p>
-	  The same as
-	  <seealso marker="#stop/3">
-	    <c>stop(<anno>ServerRef</anno>, normal, infinity)</c>.
-	  </seealso>
-	</p>
-      </desc>
-    </func>
-    <func>
-      <name name="stop" arity="3" />
-      <fsummary>Synchronously stop a generic server</fsummary>
-      <desc>
-	<p>
-	  Orders the <c>gen_statem</c>
-	  <seealso marker="#type-server_ref">
-	    <c><anno>ServerRef</anno></c>
-	  </seealso>
-	  to exit with the given <c><anno>Reason</anno></c>
-	  and waits for it to terminate.
-	  The <c>gen_statem</c> will call
-          <seealso marker="#Module:terminate/3">
-	    <c>Module:terminate/3</c>
-	  </seealso>
-	  before exiting.
-	</p>
-	<p>
-	  This function returns <c>ok</c> if the server terminates
-	  with the expected reason. Any other reason than <c>normal</c>,
-          <c>shutdown</c>, or <c>{shutdown,Term}</c> will cause an
-          error report to be issued through
-          <seealso marker="kernel:error_logger#format/2">
-	    <c>error_logger:format/2</c>.
-	  </seealso>
-	  The default <c><anno>Reason</anno></c> is <c>normal</c>.
-	</p>
-	<p>
-	  <c><anno>Timeout</anno></c> is an integer greater than zero
-	  which specifies how many milliseconds to wait for the server to
-          terminate, or the atom <c>infinity</c> to wait indefinitely.
-	  The default value is <c>infinity</c>.
-	  If the server has not terminated within the specified time,
-	  a <c>timeout</c> exception is raised.
-	</p>
-	<p>
-	  If the process does not exist, a <c>noproc</c> exception
-	  is raised.
-	</p>
-      </desc>
-    </func>
-
-    <func>
-      <name name="call" arity="2" />
-      <name name="call" arity="3" />
-      <fsummary>Make a synchronous call to a <c>gen_statem</c></fsummary>
+      <name name="call" arity="2"/>
+      <name name="call" arity="3"/>
+      <fsummary>Make a synchronous call to a <c>gen_statem</c>.</fsummary>
       <desc>
         <p>
 	  Makes a synchronous call to the <c>gen_statem</c>
@@ -1093,7 +970,7 @@ handle_event(_, _, State, Data) ->
 	  </seealso>
 	  by sending a request
 	  and waiting until its reply arrives.
-	  The <c>gen_statem</c> will call the
+	  The <c>gen_statem</c> calls the
 	  <seealso marker="#state_function">state function</seealso> with
 	  <seealso marker="#type-event_type"><c>event_type()</c></seealso>
 	  <c>{call,From}</c> and event content
@@ -1108,33 +985,33 @@ handle_event(_, _, State, Data) ->
 	  and that <c><anno>Reply</anno></c> becomes the return value
 	  of this function.
 	</p>
-        <p>
-	  <c><anno>Timeout</anno></c> is an integer greater than zero
+	<p>
+	  <c><anno>Timeout</anno></c> is an integer &gt; 0,
 	  which specifies how many milliseconds to wait for a reply,
 	  or the atom <c>infinity</c> to wait indefinitely,
-	  which is the default.  If no reply is received within
+	  which is the default. If no reply is received within
 	  the specified time, the function call fails.
 	</p>
 	<note>
 	  <p>
 	    To avoid getting a late reply in the caller's
-	    inbox this function spawns a proxy process that
-	    does the call.  A late reply gets delivered to the
-	    dead proxy process hence gets discarded.  This is
+	    inbox, this function spawns a proxy process that
+	    does the call. A late reply gets delivered to the
+	    dead proxy process, hence gets discarded. This is
 	    less efficient than using
 	    <c><anno>Timeout</anno> =:= infinity</c>.
 	  </p>
 	</note>
-        <p>
-	  The call may fail for example if the <c>gen_statem</c> dies
+	<p>
+	  The call can fail, for example, if the <c>gen_statem</c> dies
 	  before or during this function call.
 	</p>
       </desc>
     </func>
 
     <func>
-      <name name="cast" arity="2" />
-      <fsummary>Send an asynchronous event to a <c>gen_statem</c></fsummary>
+      <name name="cast" arity="2"/>
+      <fsummary>Send an asynchronous event to a <c>gen_statem</c>.</fsummary>
       <desc>
 	<p>
 	  Sends an asynchronous event to the <c>gen_statem</c>
@@ -1144,7 +1021,7 @@ handle_event(_, _, State, Data) ->
 	  and returns <c>ok</c> immediately,
 	  ignoring if the destination node or <c>gen_statem</c>
 	  does not exist.
-	  The <c>gen_statem</c> will call the
+	  The <c>gen_statem</c> calls the
 	  <seealso marker="#state_function">state function</seealso> with
 	  <seealso marker="#type-event_type"><c>event_type()</c></seealso>
 	  <c>cast</c> and event content
@@ -1154,44 +1031,8 @@ handle_event(_, _, State, Data) ->
     </func>
 
     <func>
-      <name name="reply" arity="1" />
-      <name name="reply" arity="2" />
-      <fsummary>Reply to a caller</fsummary>
-      <desc>
-        <p>
-	  This function can be used by a <c>gen_statem</c>
-	  to explicitly send a reply to a process that waits in
-	  <seealso marker="#call/2"><c>call/2</c></seealso>
-          when the reply cannot be defined in
-          the return value of a
-	  <seealso marker="#state_function">state function</seealso>.
-	</p>
-        <p>
-	  <c><anno>From</anno></c> must be the term from the
-	  <seealso marker="#type-event_type">
-	    <c>{call,<anno>From</anno>}</c>
-	  </seealso>
-	  argument to the
-	  <seealso marker="#state_function">state function</seealso>.
-	  <c><anno>From</anno></c> and <c><anno>Reply</anno></c>
-	  can also be specified using a
-	  <seealso marker="#type-reply_action">
-	    <c>reply_action()</c>
-	  </seealso>
-	  and multiple replies with a list of them.
-	</p>
-	<note>
-	  <p>
-	    A reply sent with this function will not be visible
-	    in <seealso marker="sys"><c>sys</c></seealso> debug output.
-	  </p>
-	</note>
-      </desc>
-    </func>
-
-    <func>
-      <name name="enter_loop" arity="5" />
-      <fsummary>Enter the <c>gen_statem</c> receive loop</fsummary>
+      <name name="enter_loop" arity="5"/>
+      <fsummary>Enter the <c>gen_statem</c> receive loop.</fsummary>
       <desc>
 	<p>
 	  The same as
@@ -1204,12 +1045,13 @@ handle_event(_, _, State, Data) ->
 	</p>
       </desc>
     </func>
+
     <func>
-      <name name="enter_loop" arity="6" />
-      <fsummary>Enter the <c>gen_statem</c> receive loop</fsummary>
+      <name name="enter_loop" arity="6"/>
+      <fsummary>Enter the <c>gen_statem</c> receive loop.</fsummary>
       <desc>
 	<p>
-	  If <c><anno>Server_or_Actions</anno></c> is a <c>list()</c>
+	  If <c><anno>Server_or_Actions</anno></c> is a <c>list()</c>,
 	  the same as
 	  <seealso marker="#enter_loop/7"><c>enter_loop/7</c></seealso>
 	  except that no
@@ -1228,34 +1070,35 @@ handle_event(_, _, State, Data) ->
 	</p>
       </desc>
     </func>
+
     <func>
-      <name name="enter_loop" arity="7" />
-      <fsummary>Enter the <c>gen_statem</c> receive loop</fsummary>
+      <name name="enter_loop" arity="7"/>
+      <fsummary>Enter the <c>gen_statem</c> receive loop.</fsummary>
       <desc>
-        <p>
-	  Makes an the calling process become a <c>gen_statem</c>.
-	  Does not return, instead the calling process will enter
-	  the <c>gen_statem</c> receive loop and become
+	<p>
+	  Makes the calling process become a <c>gen_statem</c>.
+	  Does not return, instead the calling process enters
+	  the <c>gen_statem</c> receive loop and becomes
 	  a <c>gen_statem</c> server.
 	  The process <em>must</em> have been started
 	  using one of the start functions in
-          <seealso marker="proc_lib"><c>proc_lib</c></seealso>.
+	  <seealso marker="proc_lib"><c>proc_lib</c></seealso>.
 	  The user is responsible for any initialization of the process,
 	  including registering a name for it.
 	</p>
-        <p>
+	<p>
 	  This function is useful when a more complex initialization
-          procedure is needed than
-	  the <c>gen_statem</c> behaviour provides.
+	  procedure is needed than
+	  the <c>gen_statem</c> behavior provides.
 	</p>
-        <p>
-	  <c><anno>Module</anno></c>, <c><anno>Opts</anno></c> and
+	<p>
+	  <c><anno>Module</anno></c>, <c><anno>Opts</anno></c>, and
 	  <c><anno>Server</anno></c> have the same meanings
 	  as when calling
-          <seealso marker="#start_link/3">
-	    <c>gen_statem:start[_link]/3,4</c>.
-	  </seealso>
-          However, the
+	  <seealso marker="#start_link/3">
+	    <c>start[_link]/3,4</c>
+	  </seealso>.
+	  However, the
 	  <seealso marker="#type-server_name">
 	    <c>server_name()</c>
 	  </seealso>
@@ -1263,265 +1106,260 @@ handle_event(_, _, State, Data) ->
 	  <em>before</em> this function is called.</p>
         <p>
 	  <c><anno>CallbackMode</anno></c>, <c><anno>State</anno></c>,
-	  <c><anno>Data</anno></c> and <c><anno>Actions</anno></c>
+	  <c><anno>Data</anno></c>, and <c><anno>Actions</anno></c>
 	  have the same meanings as in the return value of
-          <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>.
-          Also, the callback module <c><anno>Module</anno></c>
+	  <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>.
+	  Also, the callback module <c><anno>Module</anno></c>
 	  does not need to export an <c>init/1</c> function.
 	</p>
         <p>
-	  Failure: If the calling process was not started by a
-          <seealso marker="proc_lib"><c>proc_lib</c></seealso>
+	  The function fails if the calling process was not started by a
+	  <seealso marker="proc_lib"><c>proc_lib</c></seealso>
 	  start function, or if it is not registered
-          according to
+	  according to
 	  <seealso marker="#type-server_name"><c>server_name()</c></seealso>.
 	</p>
       </desc>
     </func>
 
-  </funcs>
-
-
-
-  <section>
-    <title>CALLBACK FUNCTIONS</title>
-    <p>
-      The following functions should be exported from a
-      <c>gen_statem</c> callback module.
-    </p>
-  </section>
-  <funcs>
-
     <func>
-      <name>Module:init(Args) -> Result</name>
-      <fsummary>Initialize process and internal state</fsummary>
-      <type>
-        <v>Args = term()</v>
-        <v>Result = {CallbackMode,State,Data}</v>
-	<v>&nbsp;| {CallbackMode,State,Data,Actions}</v>
-        <v>&nbsp;| {stop,Reason} | ignore</v>
-	<v>
-	  CallbackMode =
-	  <seealso marker="#type-callback_mode">callback_mode()</seealso>
-	</v>
-	<v>State = <seealso marker="#type-state">state()</seealso></v>
-	<v>
-	  Data = <seealso marker="#type-data">data()</seealso>
-	</v>
-	<v>
-	  Actions =
-	  [<seealso marker="#type-action">action()</seealso>] |
-	  <seealso marker="#type-action">action()</seealso>
-	</v>
-	<v>Reason = term()</v>
-      </type>
+      <name name="reply" arity="1"/>
+      <name name="reply" arity="2"/>
+      <fsummary>Reply to a caller.</fsummary>
       <desc>
-	<marker id="Module:init-1" />
-        <p>
-	  Whenever a <c>gen_statem</c> is started using
-          <seealso marker="#start_link/3"><c>start_link/3,4</c></seealso>
-	  or
-          <seealso marker="#start/3"><c>start/3,4</c></seealso>,
-          this function is called by the new process to initialize
-	  the implementation state and server data.
-	</p>
         <p>
-	  <c>Args</c> is the <c>Args</c> argument provided to the start
-          function.
-	</p>
-        <p>
-	  If the initialization is successful, the function should
-          return <c>{CallbackMode,State,Data}</c> or
-	  <c>{CallbackMode,State,Data,Actions}</c>.
-	  <c>CallbackMode</c> selects the
-	  <seealso marker="#type-callback_mode"><em>callback mode</em></seealso>.
-	  of the <c>gen_statem</c>.
-	  <c>State</c> is the initial
-	  <seealso marker="#type-state"><c>state()</c></seealso>
-	  and <c>Data</c> the initial server
-	  <seealso marker="#type-data"><c>data()</c></seealso>.
+	  This function can be used by a <c>gen_statem</c>
+	  to explicitly send a reply to a process that waits in
+	  <seealso marker="#call/2"><c>call/2</c></seealso>
+	  when the reply cannot be defined in
+	  the return value of a
+	  <seealso marker="#state_function">state function</seealso>.
 	</p>
 	<p>
-	  The <seealso marker="#type-action"><c>Actions</c></seealso>
-	  are executed when entering the first
-	  <seealso marker="#type-state">state</seealso> just as for a
+	  <c><anno>From</anno></c> must be the term from argument
+	  <seealso marker="#type-event_type">
+	    <c>{call,<anno>From</anno>}</c>
+	  </seealso>
+	  to the
 	  <seealso marker="#state_function">state function</seealso>.
+	  <c><anno>From</anno></c> and <c><anno>Reply</anno></c>
+	  can also be specified using a
+	  <seealso marker="#type-reply_action">
+	    <c>reply_action()</c>
+	  </seealso>
+	  and multiple replies with a list of them.
 	</p>
+	<note>
+	  <p>
+	    A reply sent with this function is not visible
+	    in <seealso marker="sys"><c>sys</c></seealso> debug output.
+	  </p>
+	</note>
+      </desc>
+    </func>
+
+    <func>
+      <name name="start" arity="3"/>
+      <name name="start" arity="4"/>
+      <fsummary>Create a standalone <c>gen_statem</c> process.</fsummary>
+      <desc>
         <p>
-	  If something goes wrong during the initialization
-          the function should return <c>{stop,Reason}</c>
-	  or <c>ignore</c>. See
-          <seealso marker="#start_link/3"><c>start_link/3,4</c></seealso>.
+	  Creates a standalone <c>gen_statem</c> process according to
+	  OTP design principles (using
+	  <seealso marker="proc_lib"><c>proc_lib</c></seealso>
+	  primitives).
+	  As it does not get linked to the calling process,
+	  this start function cannot be used by a supervisor
+	  to start a child.
 	</p>
 	<p>
-	  This function may use
-	  <seealso marker="erts:erlang#throw/1"><c>throw/1</c></seealso>
-	  to return <c>Result</c>.
+	  For a description of arguments and return values, see
+	  <seealso marker="#start_link/3"><c>start_link/3,4</c></seealso>.
 	</p>
       </desc>
     </func>
 
     <func>
-      <name>Module:StateName(EventType, EventContent, Data) ->
-      StateFunctionResult
-      </name>
-      <name>Module:handle_event(EventType, EventContent,
-      State, Data) -> HandleEventResult
-      </name>
-      <fsummary>Handle an event</fsummary>
-      <type>
-	<v>
-	  EventType =
-	  <seealso marker="#type-event_type">event_type()</seealso>
-	</v>
-	<v>EventContent = term()</v>
-	<v>
-	  State =
-	  <seealso marker="#type-state">state()</seealso>
-	</v>
-	<v>
-	  Data = NewData =
-	  <seealso marker="#type-data">data()</seealso>
-	</v>
-	<v>
-	  StateFunctionResult =
-	  <seealso marker="#type-state_function_result">
-	    state_function_result()
-	  </seealso>
-	</v>
-	<v>
-	  HandleEventResult =
-	  <seealso marker="#type-handle_event_result">
-	    handle_event_result()
-	  </seealso>
-	</v>
-      </type>
+      <name name="start_link" arity="3"/>
+      <name name="start_link" arity="4"/>
+      <fsummary>Create a linked <c>gen_statem</c> process.</fsummary>
       <desc>
         <p>
-	  Whenever a <c>gen_statem</c> receives an event from
-          <seealso marker="#call/2"><c>call/2</c></seealso>,
-          <seealso marker="#cast/2"><c>cast/2</c></seealso> or
-	  as a normal process message one of these functions is called.  If
-	  <seealso marker="#type-callback_mode"><em>callback mode</em></seealso>
-	  is <c>state_functions</c> then <c>Module:StateName/3</c> is called,
-	  and if it is <c>handle_event_function</c>
-	  then <c>Module:handle_event/4</c> is called.
+	  Creates a <c>gen_statem</c> process according
+	  to OTP design principles
+	  (using
+	  <seealso marker="proc_lib"><c>proc_lib</c></seealso>
+	  primitives)
+	  that is linked to the calling process.
+	  This is essential when the <c>gen_statem</c> must be part of
+	  a supervision tree so it gets linked to its supervisor.
 	</p>
 	<p>
-	  If <c>EventType</c> is
-	  <seealso marker="#type-event_type"><c>{call,From}</c></seealso>
-	  the caller is waiting for a reply.  The reply can be sent
-	  from this or from any other
-	  <seealso marker="#state_function">state function</seealso>
-	  by returning with <c>{reply,From,Reply}</c> in
-	  <seealso marker="#type-action"><c>Actions</c></seealso>, in
-	  <seealso marker="#type-reply_action"><c>Replies</c></seealso>
-	  or by calling
-	  <seealso marker="#reply/2"><c>reply(From, Reply)</c></seealso>.
+	  The <c>gen_statem</c> process calls
+	  <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>
+	  to initialize the server. To ensure a synchronized startup
+	  procedure, <c>start_link/3,4</c> does not return until
+	  <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>
+	  has returned.
 	</p>
 	<p>
-	  If this function returns with a next state that
-	  does not match equal (<c>=/=</c>) to the current state
-	  all postponed events will be retried in the next state.
+	  <c><anno>ServerName</anno></c> specifies the
+	  <seealso marker="#type-server_name">
+	    <c>server_name()</c>
+	  </seealso>
+	  to register for the <c>gen_statem</c>.
+	  If the <c>gen_statem</c> is started with <c>start_link/3</c>,
+	  no <c><anno>ServerName</anno></c> is provided and
+	  the <c>gen_statem</c> is not registered.
 	</p>
-	<p>
-	  The only difference between <c>StateFunctionResult</c> and
-	  <c>HandleEventResult</c> is that for <c>StateFunctionResult</c>
-	  the next state has to be an atom but for <c>HandleEventResult</c>
-	  there is no restriction on the next state.
+        <p><c><anno>Module</anno></c> is the name of the callback module.</p>
+        <p>
+	  <c><anno>Args</anno></c> is an arbitrary term that is passed as
+	  the argument to
+	  <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>.
 	</p>
+        <list type="bulleted">
+          <item>
+	    <p>
+	      If option <c>{timeout,Time}</c> is present in
+	      <c><anno>Opts</anno></c>, the <c>gen_statem</c>
+	      is allowed to spend <c>Time</c> milliseconds initializing
+	      or it terminates and the start function returns
+	      <seealso marker="#type-start_ret">
+		<c>{error,timeout}</c></seealso>.
+            </p>
+          </item>
+          <item>
+            <p>
+              If option
+              <seealso marker="#type-debug_opt"><c>{debug,Dbgs}</c></seealso>
+              is present in <c><anno>Opts</anno></c>, debugging through
+              <seealso marker="sys"><c>sys</c></seealso> is activated.
+            </p>
+          </item>
+          <item>
+            <p>
+              If option <c>{spawn_opt,SpawnOpts}</c> is present in
+              <c><anno>Opts</anno></c>, <c>SpawnOpts</c> is passed
+              as option list to <seealso marker="erts:erlang#spawn_opt/2">
+              <c>erlang:spawn_opt/2</c></seealso>,
+              which is used to spawn the <c>gen_statem</c> process.
+            </p>
+          </item>
+        </list>
+        <note>
+	  <p>
+	    Using spawn option <c>monitor</c> is not
+            allowed, it cause this function to fail with reason
+            <c>badarg</c>.
+	  </p>
+        </note>
 	<p>
-	  See <seealso marker="#type-action"><c>action()</c></seealso>
-	  for options that can be set and actions that can be done
-	  by <c>gen_statem</c> after returning from this function.
+	  If the <c>gen_statem</c> is successfully created
+	  and initialized, this function returns
+	  <seealso marker="#type-start_ret">
+	    <c>{ok,Pid}</c>
+	  </seealso>,
+	  where <c>Pid</c> is the <c>pid()</c>
+	  of the <c>gen_statem</c>.
+	  If a process with the specified <c><anno>ServerName</anno></c>
+	  exists already, this function returns
+	  <seealso marker="#type-start_ret">
+	    <c>{error,{already_started,Pid}}</c></seealso>,
+	  where <c>Pid</c> is the <c>pid()</c> of that process.
 	</p>
 	<p>
-	  These functions may use
-	  <seealso marker="erts:erlang#throw/1"><c>throw/1</c></seealso>,
-	  to return the result.
+	  If <c>Module:init/1</c> fails with <c>Reason</c>,
+	  this function returns
+	  <seealso marker="#type-start_ret"><c>{error,Reason}</c></seealso>.
+	  If <c>Module:init/1</c> returns
+	  <seealso marker="#type-start_ret">
+	    <c>{stop,Reason}</c>
+	  </seealso>
+	  or
+	  <seealso marker="#type-start_ret"><c>ignore</c></seealso>,
+	  the process is terminated and this function
+	  returns
+	  <seealso marker="#type-start_ret">
+	    <c>{error,Reason}</c>
+	  </seealso>
+	  or
+	  <seealso marker="#type-start_ret"><c>ignore</c></seealso>,
+	  respectively.
 	</p>
       </desc>
     </func>
 
     <func>
-      <name>Module:terminate(Reason, State, Data) -> Ignored</name>
-      <fsummary>Clean up before termination</fsummary>
-      <type>
-        <v>Reason = normal | shutdown | {shutdown,term()} | term()</v>
-	<v>State = <seealso marker="#type-state">state()</seealso></v>
-	<v>Data = <seealso marker="#type-data">data()</seealso></v>
-	<v>Ignored = term()</v>
-      </type>
+      <name name="stop" arity="1"/>
+      <fsummary>Synchronously stop a generic server.</fsummary>
       <desc>
-        <p>
-	  This function is called by a <c>gen_statem</c>
-	  when it is about to terminate. It should be the opposite of
-	  <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>
-          and do any necessary cleaning up. When it returns,
-          the <c>gen_statem</c> terminates with <c>Reason</c>. The return
-          value is ignored.</p>
-        <p>
-	  <c>Reason</c> is a term denoting the stop reason and
-          <seealso marker="#type-state"><c>State</c></seealso>
-	  is the internal state of the <c>gen_statem</c>.
-	</p>
-        <p>
-	  <c>Reason</c> depends on why the <c>gen_statem</c>
-	  is terminating.
-          If it is because another callback function has returned a
-          stop tuple <c>{stop,Reason}</c> in
-	  <seealso marker="#type-action"><c>Actions</c></seealso>,
-	  <c>Reason</c> will have the value specified in that tuple.
-	  If it is due to a failure, <c>Reason</c> is the error reason.
+	<p>
+	  The same as
+	  <seealso marker="#stop/3">
+	    <c>stop(<anno>ServerRef</anno>, normal, infinity)</c>.
+	  </seealso>
 	</p>
-        <p>
-	  If the <c>gen_statem</c> is part of a supervision tree and is
-          ordered by its supervisor to terminate, this function will be
-          called with <c>Reason = shutdown</c> if the following
-          conditions apply:</p>
-        <list type="bulleted">
-          <item>
-	    the <c>gen_statem</c> has been set
-	    to trap exit signals, and
-	  </item>
-          <item>
-	    the shutdown strategy as defined in the supervisor's
-            child specification is an integer timeout value, not
-            <c>brutal_kill</c>.
-	  </item>
-        </list>
-        <p>
-	  Even if the <c>gen_statem</c> is <em>not</em>
-	  part of a supervision tree, this function will be called
-	  if it receives an <c>'EXIT'</c> message from its parent.
-	  <c>Reason</c> will be the same as
-	  in the <c>'EXIT'</c> message.
+      </desc>
+    </func>
+
+    <func>
+      <name name="stop" arity="3"/>
+      <fsummary>Synchronously stop a generic server.</fsummary>
+      <desc>
+	<p>
+	  Orders the <c>gen_statem</c>
+	  <seealso marker="#type-server_ref">
+	    <c><anno>ServerRef</anno></c>
+	  </seealso>
+	  to exit with the specified <c><anno>Reason</anno></c>
+	  and waits for it to terminate.
+	  The <c>gen_statem</c> calls
+	  <seealso marker="#Module:terminate/3">
+	    <c>Module:terminate/3</c>
+	  </seealso>
+	  before exiting.
 	</p>
-        <p>
-	  Otherwise, the <c>gen_statem</c> will be immediately terminated.
+	<p>
+	  This function returns <c>ok</c> if the server terminates
+	  with the expected reason. Any other reason than <c>normal</c>,
+	  <c>shutdown</c>, or <c>{shutdown,Term}</c> causes an
+	  error report to be issued through
+	  <seealso marker="kernel:error_logger#format/2">
+	    <c>error_logger:format/2</c>
+	  </seealso>.
+	  The default <c><anno>Reason</anno></c> is <c>normal</c>.
 	</p>
-        <p>
-	  Note that for any other reason than <c>normal</c>,
-          <c>shutdown</c>, or <c>{shutdown,Term}</c>
-	  the <c>gen_statem</c> is assumed to terminate due to an error
-	  and an error report is issued using
-          <seealso marker="kernel:error_logger#format/2">
-	    <c>error_logger:format/2</c>.
-	  </seealso>
+	<p>
+	  <c><anno>Timeout</anno></c> is an integer &gt; 0,
+	  which specifies how many milliseconds to wait for the server to
+	  terminate, or the atom <c>infinity</c> to wait indefinitely.
+	  Defaults to <c>infinity</c>.
+	  If the server does not terminate within the specified time,
+	  a <c>timeout</c> exception is raised.
 	</p>
 	<p>
-	  This function may use
-	  <seealso marker="erts:erlang#throw/1"><c>throw/1</c></seealso>
-	  to return <c>Ignored</c>, which is ignored anyway.
+	  If the process does not exist, a <c>noproc</c> exception
+	  is raised.
 	</p>
       </desc>
     </func>
+  </funcs>
 
+  <section>
+    <title>Callback Functions</title>
+    <p>
+      The following functions are to be exported from a
+      <c>gen_statem</c> callback module.
+    </p>
+  </section>
+
+  <funcs>
     <func>
       <name>Module:code_change(OldVsn, OldState, OldData, Extra) ->
         Result
       </name>
-      <fsummary>Update the internal state during upgrade/downgrade</fsummary>
+      <fsummary>Update the internal state during upgrade/downgrade.</fsummary>
       <type>
         <v>OldVsn = Vsn | {down,Vsn}</v>
         <v>&nbsp;&nbsp;Vsn = term()</v>
@@ -1544,24 +1382,23 @@ handle_event(_, _, State, Data) ->
       </type>
       <desc>
         <p>
-	  This function is called by a <c>gen_statem</c> when it should
-          update its internal state during a release upgrade/downgrade,
-          that is when the instruction <c>{update,Module,Change,...}</c>
-          where <c>Change={advanced,Extra}</c> is given in the
+	  This function is called by a <c>gen_statem</c> when it is to
+	  update its internal state during a release upgrade/downgrade,
+	  that is, when the instruction <c>{update,Module,Change,...}</c>,
+	  where <c>Change={advanced,Extra}</c>, is specified in the
 	  <seealso marker="sasl:appup"><c>appup</c></seealso>
-	  file. See
-          <seealso marker="doc/design_principles:release_handling#instr">
+	  file. For more information, see
+	  <seealso marker="doc/design_principles:release_handling#instr">
 	    OTP Design Principles
-	  </seealso>
-          for more information.
+	 </seealso>.
 	</p>
-        <p>
-	  In the case of an upgrade, <c>OldVsn</c> is <c>Vsn</c>, and
-          in the case of a downgrade, <c>OldVsn</c> is
-          <c>{down,Vsn}</c>. <c>Vsn</c> is defined by the <c>vsn</c>
-          attribute(s) of the old version of the callback module
-          <c>Module</c>. If no such attribute is defined, the version
-          is the checksum of the BEAM file.
+	<p>
+	  For an upgrade, <c>OldVsn</c> is <c>Vsn</c>, and
+	  for a downgrade, <c>OldVsn</c> is
+	  <c>{down,Vsn}</c>. <c>Vsn</c> is defined by the <c>vsn</c>
+	  attribute(s) of the old version of the callback module
+	  <c>Module</c>. If no such attribute is defined, the version
+	  is the checksum of the Beam file.
 	</p>
 	<note>
 	  <p>
@@ -1569,14 +1406,14 @@ handle_event(_, _, State, Data) ->
 	    <seealso marker="#type-callback_mode">
 	      <em>callback mode</em>
 	    </seealso>
-	    during release upgrade/downgrade, the upgrade is no problem
-	    since the new code surely knows what <em>callback mode</em>
-	    it needs, but for a downgrade this function will have to
-	    know from the <c>Extra</c> argument that comes from the
-	    <seealso marker="sasl:appup"><c>appup</c></seealso>
+	    during release upgrade/downgrade, the upgrade is no problem,
+	    as the new code surely knows what <em>callback mode</em>
+	    it needs. However, for a downgrade this function must
+	    know from argument <c>Extra</c> that comes from the
+	    <seealso marker="sasl:appup"><c>sasl:appup</c></seealso>
 	    file what <em>callback mode</em> the old code did use.
-	    It may also be possible to figure this out
-	    from the <c>{down,Vsn}</c> argument since <c>Vsn</c>
+	    It can also be possible to figure this out
+	    from argument <c>{down,Vsn}</c>, as <c>Vsn</c>
 	    in effect defines the old callback module version.
 	  </p>
 	</note>
@@ -1584,32 +1421,102 @@ handle_event(_, _, State, Data) ->
 	  <c>OldState</c> and <c>OldData</c> is the internal state
 	  of the <c>gen_statem</c>.
 	</p>
-        <p>
-	  <c>Extra</c> is passed as-is from the <c>{advanced,Extra}</c>
-          part of the update instruction.
+	<p>
+	  <c>Extra</c> is passed "as is" from the <c>{advanced,Extra}</c>
+	  part of the update instruction.
 	</p>
-        <p>
-	  If successful, the function shall return the updated
-          internal state in an
+	<p>
+	  If successful, the function must return the updated
+	  internal state in an
 	  <c>{NewCallbackMode,NewState,NewData}</c> tuple.
 	</p>
 	<p>
 	  If the function returns <c>Reason</c>, the ongoing
-	  upgrade will fail and roll back to the old release.</p>
+	  upgrade fails and rolls back to the old release.</p>
 	<p>
-	  This function may use
-	  <seealso marker="erts:erlang#throw/1"><c>throw/1</c></seealso>
+	  This function can use
+	  <seealso marker="erts:erlang#throw/1"><c>erlang:throw/1</c></seealso>
 	  to return <c>Result</c> or <c>Reason</c>.
 	</p>
       </desc>
     </func>
 
     <func>
+      <name>Module:init(Args) -> Result</name>
+      <fsummary>Initialize process and internal state.</fsummary>
+      <type>
+        <v>Args = term()</v>
+        <v>Result = {CallbackMode,State,Data}</v>
+	<v>&nbsp;| {CallbackMode,State,Data,Actions}</v>
+        <v>&nbsp;| {stop,Reason} | ignore</v>
+	<v>
+	  CallbackMode =
+	  <seealso marker="#type-callback_mode">callback_mode()</seealso>
+	</v>
+	<v>State = <seealso marker="#type-state">state()</seealso></v>
+	<v>
+	  Data = <seealso marker="#type-data">data()</seealso>
+	</v>
+	<v>
+	  Actions =
+	  [<seealso marker="#type-action">action()</seealso>] |
+	  <seealso marker="#type-action">action()</seealso>
+	</v>
+	<v>Reason = term()</v>
+      </type>
+      <desc>
+	<marker id="Module:init-1"/>
+	<p>
+	  Whenever a <c>gen_statem</c> is started using
+	  <seealso marker="#start_link/3"><c>start_link/3,4</c></seealso>
+	  or
+	  <seealso marker="#start/3"><c>start/3,4</c></seealso>,
+	  this function is called by the new process to initialize
+	  the implementation state and server data.
+	</p>
+	<p>
+	  <c>Args</c> is the <c>Args</c> argument provided to the start
+	  function.
+	</p>
+	<p>
+	  If the initialization is successful, the function is to
+	  return <c>{CallbackMode,State,Data}</c> or
+	  <c>{CallbackMode,State,Data,Actions}</c>.
+	  <c>CallbackMode</c> selects the
+	  <seealso marker="#type-callback_mode">
+	  <em>callback mode</em></seealso>
+	  of the <c>gen_statem</c>.
+	  <c>State</c> is the initial
+	  <seealso marker="#type-state"><c>state()</c></seealso>
+	  and <c>Data</c> the initial server
+	  <seealso marker="#type-data"><c>data()</c></seealso>.
+	</p>
+	<p>
+	  The <seealso marker="#type-action"><c>Actions</c></seealso>
+	  are executed when entering the first
+	  <seealso marker="#type-state">state</seealso> just as for a
+	  <seealso marker="#state_function">state function</seealso>.
+	</p>
+	<p>
+	  If the initialization fails,
+          the function is to return <c>{stop,Reason}</c>
+	  or <c>ignore</c>; see
+          <seealso marker="#start_link/3"><c>start_link/3,4</c></seealso>.
+	</p>
+	<p>
+	  This function can use
+	  <seealso marker="erts:erlang#throw/1"><c>erlang:throw/1</c></seealso>
+	  to return <c>Result</c>.
+	</p>
+      </desc>
+    </func>
+
+    <func>
       <name>Module:format_status(Opt, [PDict,State,Data]) ->
         Status
       </name>
       <fsummary>Optional function for providing a term describing the
-        current <c>gen_statem</c> status</fsummary>
+        current <c>gen_statem</c> status.</fsummary>
       <type>
         <v>Opt = normal | terminate</v>
         <v>PDict = [{Key, Value}]</v>
@@ -1627,58 +1534,59 @@ handle_event(_, _, State, Data) ->
       </type>
       <desc>
         <note>
-          <p>
-	    This callback is optional, so a callback module need not
-            export it. The <c>gen_statem</c> module provides a default
-            implementation of this function that returns
-            <c>{State,Data}</c>.  If this callback fails the default
-	    function will return <c>{State,Info}</c>
+	  <p>
+	    This callback is optional, so a callback module does not need
+	    to export it. The <c>gen_statem</c> module provides a default
+	    implementation of this function that returns
+	    <c>{State,Data}</c>. If this callback fails, the default
+	    function returns <c>{State,Info}</c>,
 	    where <c>Info</c> informs of the crash but no details,
 	    to hide possibly sensitive data.
 	  </p>
         </note>
-        <p>This function is called by a <c>gen_statem</c> process when:</p>
+        <p>This function is called by a <c>gen_statem</c> process when
+          any of the following apply:</p>
         <list type="bulleted">
-          <item>
+	  <item>
 	    One of
-            <seealso marker="sys#get_status/1">
+	    <seealso marker="sys#get_status/1">
 	      <c>sys:get_status/1,2</c>
 	    </seealso>
-            is invoked to get the <c>gen_statem</c> status. <c>Opt</c> is set
-            to the atom <c>normal</c> for this case.
+	    is invoked to get the <c>gen_statem</c> status. <c>Opt</c> is set
+	    to the atom <c>normal</c> for this case.
 	  </item>
-          <item>
+	  <item>
 	    The <c>gen_statem</c> terminates abnormally and logs an error.
 	    <c>Opt</c> is set to the atom <c>terminate</c> for this case.
 	  </item>
-        </list>
+	</list>
         <p>
-	  This function is useful for customising the form and
+	  This function is useful for changing the form and
           appearance of the <c>gen_statem</c> status for these cases. A
-          callback module wishing to customise the
+          callback module wishing to change the
           <seealso marker="sys#get_status/1">
 	    <c>sys:get_status/1,2</c>
 	  </seealso>
-	  return value as well as how
+	  return value and how
           its status appears in termination error logs exports an
-          instance of <c>format_status/2</c> that returns a term
+          instance of <c>format_status/2</c>, which returns a term
           describing the current status of the <c>gen_statem</c>.
 	</p>
-        <p>
-	  <c>PDict</c> is the current value of the <c>gen_statem</c>'s
-          process dictionary.
+	<p>
+	  <c>PDict</c> is the current value of the process dictionary
+          of the <c>gen_statem</c>.
 	</p>
-        <p>
+	<p>
 	  <seealso marker="#type-state"><c>State</c></seealso>
 	  is the internal state of the <c>gen_statem</c>.
 	</p>
-        <p>
+	<p>
 	  <seealso marker="#type-data"><c>Data</c></seealso>
 	  is the internal server data of the <c>gen_statem</c>.
 	</p>
-        <p>
-	  The function should return <c>Status</c>, a term that
-          customises the details of the current state and status of
+	<p>
+	  The function is to return <c>Status</c>, a term that
+          changes the details of the current state and status of
           the <c>gen_statem</c>. There are no restrictions on the
           form <c>Status</c> can take, but for the
           <seealso marker="sys#get_status/1">
@@ -1687,38 +1595,197 @@ handle_event(_, _, State, Data) ->
 	  case (when <c>Opt</c>
           is <c>normal</c>), the recommended form for
           the <c>Status</c> value is <c>[{data, [{"State",
-          Term}]}]</c> where <c>Term</c> provides relevant details of
-          the <c>gen_statem</c> state. Following this recommendation isn't
-          required, but doing so will make the callback module status
+          Term}]}]</c>, where <c>Term</c> provides relevant details of
+          the <c>gen_statem</c> state. Following this recommendation is not
+          required, but it makes the callback module status
           consistent with the rest of the
           <seealso marker="sys#get_status/1">
 	    <c>sys:get_status/1,2</c>
 	  </seealso>
 	  return value.
 	</p>
-        <p>
+	<p>
 	  One use for this function is to return compact alternative
           state representations to avoid having large state terms
-          printed in logfiles.  Another is to hide sensitive data from
+          printed in log files. Another use is to hide sensitive data from
 	  being written to the error log.
 	</p>
 	<p>
-	  This function may use
-	  <seealso marker="erts:erlang#throw/1"><c>throw/1</c></seealso>
+	  This function can use
+	  <seealso marker="erts:erlang#throw/1"><c>erlang:throw/1</c></seealso>
 	  to return <c>Status</c>.
 	</p>
       </desc>
     </func>
 
+    <func>
+      <name>Module:StateName(EventType, EventContent, Data) ->
+        StateFunctionResult
+      </name>
+      <name>Module:handle_event(EventType, EventContent,
+        State, Data) -> HandleEventResult
+      </name>
+      <fsummary>Handle an event.</fsummary>
+      <type>
+	<v>
+	  EventType =
+	  <seealso marker="#type-event_type">event_type()</seealso>
+	</v>
+	<v>EventContent = term()</v>
+	<v>
+	  State =
+	  <seealso marker="#type-state">state()</seealso>
+	</v>
+	<v>
+	  Data = NewData =
+	  <seealso marker="#type-data">data()</seealso>
+	</v>
+	<v>
+	  StateFunctionResult =
+	  <seealso marker="#type-state_function_result">
+	    state_function_result()
+	  </seealso>
+	</v>
+	<v>
+	  HandleEventResult =
+	  <seealso marker="#type-handle_event_result">
+	    handle_event_result()
+	  </seealso>
+	</v>
+      </type>
+      <desc>
+	<p>
+	  Whenever a <c>gen_statem</c> receives an event from
+	  <seealso marker="#call/2"><c>call/2</c></seealso>,
+	  <seealso marker="#cast/2"><c>cast/2</c></seealso>, or
+	  as a normal process message, one of these functions is called. If
+	  <seealso marker="#type-callback_mode"><em>callback mode</em></seealso>
+	  is <c>state_functions</c>, <c>Module:StateName/3</c> is called,
+	  and if it is <c>handle_event_function</c>,
+	  <c>Module:handle_event/4</c> is called.
+	</p>
+	<p>
+	  If <c>EventType</c> is
+	  <seealso marker="#type-event_type"><c>{call,From}</c></seealso>,
+	  the caller waits for a reply. The reply can be sent
+	  from this or from any other
+	  <seealso marker="#state_function">state function</seealso>
+	  by returning with <c>{reply,From,Reply}</c> in
+	  <seealso marker="#type-action"><c>Actions</c></seealso>, in
+	  <seealso marker="#type-reply_action"><c>Replies</c></seealso>,
+	  or by calling
+	  <seealso marker="#reply/2"><c>reply(From, Reply)</c></seealso>.
+	</p>
+	<p>
+	  If this function returns with a next state that
+	  does not match equal (<c>=/=</c>) to the current state,
+	  all postponed events are retried in the next state.
+	</p>
+	<p>
+	  The only difference between <c>StateFunctionResult</c> and
+	  <c>HandleEventResult</c> is that for <c>StateFunctionResult</c>
+	  the next state must be an atom, but for <c>HandleEventResult</c>
+	  there is no restriction on the next state.
+	</p>
+	<p>
+	  For options that can be set and actions that can be done
+	  by <c>gen_statem</c> after returning from this function,
+	  see <seealso marker="#type-action"><c>action()</c></seealso>.
+	</p>
+	<p>
+	  These functions can use
+	  <seealso marker="erts:erlang#throw/1"><c>erlang:throw/1</c></seealso>,
+	  to return the result.
+	</p>
+      </desc>
+    </func>
+
+    <func>
+      <name>Module:terminate(Reason, State, Data) -> Ignored</name>
+      <fsummary>Clean up before termination.</fsummary>
+      <type>
+        <v>Reason = normal | shutdown | {shutdown,term()} | term()</v>
+	<v>State = <seealso marker="#type-state">state()</seealso></v>
+	<v>Data = <seealso marker="#type-data">data()</seealso></v>
+	<v>Ignored = term()</v>
+      </type>
+      <desc>
+	<p>
+	  This function is called by a <c>gen_statem</c>
+	  when it is about to terminate. It is to be the opposite of
+	  <seealso marker="#Module:init/1"><c>Module:init/1</c></seealso>
+	  and do any necessary cleaning up. When it returns,
+	  the <c>gen_statem</c> terminates with <c>Reason</c>. The return
+	  value is ignored.</p>
+	<p>
+	  <c>Reason</c> is a term denoting the stop reason and
+	  <seealso marker="#type-state"><c>State</c></seealso>
+	  is the internal state of the <c>gen_statem</c>.
+	</p>
+	<p>
+	  <c>Reason</c> depends on why the <c>gen_statem</c>
+	  is terminating.
+	  If it is because another callback function has returned, a
+	  stop tuple <c>{stop,Reason}</c> in
+	  <seealso marker="#type-action"><c>Actions</c></seealso>,
+	  <c>Reason</c> has the value specified in that tuple.
+	  If it is because of a failure, <c>Reason</c> is the error reason.
+	</p>
+        <p>
+	  If the <c>gen_statem</c> is part of a supervision tree and is
+          ordered by its supervisor to terminate, this function is
+          called with <c>Reason = shutdown</c> if both the following
+          conditions apply:</p>
+        <list type="bulleted">
+          <item>
+            <p>
+	      The <c>gen_statem</c> has been set
+	      to trap exit signals.
+            </p>
+	  </item>
+          <item>
+            <p>
+	      The shutdown strategy as defined in the supervisor's
+              child specification is an integer time-out value, not
+              <c>brutal_kill</c>.
+            </p>
+	  </item>
+        </list>
+        <p>
+	  Even if the <c>gen_statem</c> is <em>not</em>
+	  part of a supervision tree, this function is called
+	  if it receives an <c>'EXIT'</c> message from its parent.
+	  <c>Reason</c> is the same as
+	  in the <c>'EXIT'</c> message.
+	</p>
+        <p>
+	  Otherwise, the <c>gen_statem</c> is immediately terminated.
+	</p>
+        <p>
+	  Notice that for any other reason than <c>normal</c>,
+          <c>shutdown</c>, or <c>{shutdown,Term}</c>,
+	  the <c>gen_statem</c> is assumed to terminate because of an error
+	  and an error report is issued using
+          <seealso marker="kernel:error_logger#format/2">
+	    <c>error_logger:format/2</c>.
+	  </seealso>
+	</p>
+	<p>
+	  This function can use
+	  <seealso marker="erts:erlang#throw/1"><c>erlang:throw/1</c></seealso>
+	  to return <c>Ignored</c>, which is ignored anyway.
+	</p>
+      </desc>
+    </func>
   </funcs>
 
   <section>
-    <title>SEE ALSO</title>
+    <title>See Also</title>
     <p><seealso marker="gen_event"><c>gen_event(3)</c></seealso>,
       <seealso marker="gen_fsm"><c>gen_fsm(3)</c></seealso>,
       <seealso marker="gen_server"><c>gen_server(3)</c></seealso>,
-      <seealso marker="supervisor"><c>supervisor(3)</c></seealso>,
       <seealso marker="proc_lib"><c>proc_lib(3)</c></seealso>,
+      <seealso marker="supervisor"><c>supervisor(3)</c></seealso>,
       <seealso marker="sys"><c>sys(3)</c></seealso></p>
   </section>
 </erlref>
diff --git a/system/doc/design_principles/statem.xml b/system/doc/design_principles/statem.xml
index ca0fce55e2..8b0fbed7c0 100644
--- a/system/doc/design_principles/statem.xml
+++ b/system/doc/design_principles/statem.xml
@@ -5,7 +5,7 @@
   <header>
     <copyright>
       <year>2016</year>
-      <holder>Ericsson AB.  All Rights Reserved.</holder>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
     </copyright>
     <legalnotice>
       Licensed under the Apache License, Version 2.0 (the "License");
@@ -22,7 +22,7 @@
 
     </legalnotice>
 
-    <title>gen_statem Behaviour</title>
+    <title>gen_statem Behavior</title>
     <prepared></prepared>
     <docno></docno>
     <date></date>
@@ -33,63 +33,60 @@
   <p>
     This section is to be read with the
     <seealso marker="stdlib:gen_statem"><c>gen_statem(3)</c></seealso>
-    manual page in STDLIB, where all interface functions and callback
+    manual page in <c>STDLIB</c>, where all interface functions and callback
     functions are described in detail.
   </p>
-  <p>
-    This is a new behaviour in OTP-19.0.
-    It has been thoroughly reviewed, is stable enough
-    to be used by at least two heavy OTP applications, and is here to stay.
-    But depending on user feedback, we do not expect
-    but might find it necessary to make minor
-    not backwards compatible changes into OTP-20.0,
-    so its state can be designated as "not quite experimental"...
-  </p>
+  <note>
+    <p>
+      This is a new behavior in Erlang/OTP 19.0.
+      It has been thoroughly reviewed, is stable enough
+      to be used by at least two heavy OTP applications, and is here to stay.
+      Depending on user feedback, we do not expect
+      but can find it necessary to make minor
+      not backward compatible changes into Erlang/OTP 20.0.
+    </p>
+  </note>
 
 <!-- =================================================================== -->
 
   <section>
-    <title>Event Driven State Machines</title>
+    <title>Event-Driven State Machines</title>
     <p>
       Established Automata theory does not deal much with
       how a state transition is triggered,
-      but in general assumes that the output is a function
+      but assumes that the output is a function
       of the input (and the state) and that they are
       some kind of values.
     </p>
     <p>
-      For an Event Driven State Machine the input is an event
+      For an Event-Driven State Machine, the input is an event
       that triggers a state transition and the output
       is actions executed during the state transition.
       It can analogously to the mathematical model of a
-      Finite State Machine be described as
-      a set of relations of the form:
+      Finite-State Machine be described as
+      a set of relations of the following form:
     </p>
     <pre>
 State(S) x Event(E) -> Actions(A), State(S')</pre>
-    <p>These relations are interpreted as meaning:</p>
-    <p>
-      If we are in state <c>S</c> and event <c>E</c> occurs, we
+    <p>These relations are interpreted as follows:
+      if we are in state <c>S</c> and event <c>E</c> occurs, we
       are to perform actions <c>A</c> and make a transition to
-      state <c>S'</c>.
-    </p>
-    <p>
-      Note that <c>S'</c> may be equal to <c>S</c>.
+      state <c>S'</c>. Notice that <c>S'</c> can be equal to <c>S</c>.
     </p>
     <p>
-      Since <c>A</c> and <c>S'</c> depend only on
-      <c>S</c> and <c>E</c> the kind of state machine described
-      here is a Mealy Machine.
-      (See for example the corresponding Wikipedia article)
+      As <c>A</c> and <c>S'</c> depend only on
+      <c>S</c> and <c>E</c>, the kind of state machine described
+      here is a Mealy Machine
+      (see, for example, the corresponding Wikipedia article).
     </p>
     <p>
-      Like most <c>gen_</c> behaviours, <c>gen_statem</c> keeps
-      a server <c>Data</c> besides the state.  This and the fact that
+      Like most <c>gen_</c> behaviors, <c>gen_statem</c> keeps
+      a server <c>Data</c> besides the state. Because of this, and as
       there is no restriction on the number of states
-      (assuming enough virtual machine memory)
-      or on the number of distinct input events actually makes
-      a state machine implemented with this behaviour Turing complete.
-      But it feels mostly like an Event Driven Mealy Machine.
+      (assuming that there is enough virtual machine memory)
+      or on the number of distinct input events, makes
+      a state machine implemented with this behavior Turing complete.
+      But it feels mostly like an Event-Driven Mealy Machine.
     </p>
   </section>
 
@@ -99,38 +96,40 @@ State(S) x Event(E) -> Actions(A), State(S')</pre>
     <marker id="callback_modes" />
     <title>Callback Modes</title>
     <p>
-      The <c>gen_statem</c> behaviour supports two different callback modes.
-      In the mode
-      <seealso marker="stdlib:gen_statem#type-callback_mode">
-	<c>state_functions</c>,
-      </seealso>
-      the state transition rules are written as a number of Erlang
-      functions, which conform to the following convention:
+      The <c>gen_statem</c> behavior supports two callback modes:
     </p>
-    <pre>
+    <list type="bulleted">
+      <item>
+        <p>
+          In mode <seealso marker="stdlib:gen_statem#type-callback_mode">
+          <c>state_functions</c></seealso>,
+          the state transition rules are written as some Erlang
+          functions, which conform to the following convention:
+        </p>
+        <pre>
 StateName(EventType, EventContent, Data) ->
     .. code for actions here ...
     {next_state, NewStateName, NewData}.</pre>
-    <p>
-      In the mode
-      <seealso marker="stdlib:gen_statem#type-callback_mode">
-	<c>handle_event_function</c>
-      </seealso>
-      there is only one
-      Erlang function that implements all state transition rules:
-    </p>
-    <pre>
+      </item>
+      <item>
+        <p>
+          In mode <seealso marker="stdlib:gen_statem#type-callback_mode">
+          <c>handle_event_function</c></seealso>,
+          only one Erlang function provides all state transition rules:
+        </p>
+        <pre>
 handle_event(EventType, EventContent, State, Data) ->
     .. code for actions here ...
     {next_state, State', Data'}</pre>
+      </item>
+    </list>
     <p>
-      Both these modes allow other return tuples
-      that you can find in the
+      Both these modes allow other return tuples; see
       <seealso marker="stdlib:gen_statem#Module:StateName/3">
-	reference manual.
-      </seealso>
-      These other return tuples can for example stop the machine,
-      execute state transition actions on the machine engine itself
+      <c>Module:StateName/3</c></seealso>
+      in the <c>gen_statem</c> manual page.
+      These other return tuples can, for example, stop the machine,
+      execute state transition actions on the machine engine itself,
       and send replies.
     </p>
 
@@ -139,54 +138,55 @@ handle_event(EventType, EventContent, State, Data) ->
       <p>
 	The two
 	<seealso marker="#callback_modes">callback modes</seealso>
-	gives different possibilities
+	give different possibilities
 	and restrictions, but one goal remains:
 	you want to handle all possible combinations of
 	events and states.
       </p>
       <p>
-	You can for example do this by focusing on one state at the time
-	and for every state ensure that all events are handled,
-	or the other way around focus on one event at the time
-	and ensure that it is handled in every state,
-	or mix these strategies.
+	This can be done, for example, by focusing on one state at the time
+	and for every state ensure that all events are handled.
+	Alternatively, you can focus on one event at the time
+	and ensure that it is handled in every state.
+	You can also use a mix of these strategies.
       </p>
       <p>
-	With <c>state_functions</c> you are restricted to use
-	atom only states, and the <c>gen_statem</c> engine dispatches
-	on state name for you.  This encourages the callback module
+	With <c>state_functions</c>, you are restricted to use
+	atom-only states, and the <c>gen_statem</c> engine dispatches
+	on state name for you. This encourages the callback module
 	to gather the implementation of all event actions particular
-	to one state in the same place in the code
+	to one state in the same place in the code,
 	hence to focus on one state at the time.
       </p>
       <p>
-	This mode fits well when you have a regular state diagram
-	like the ones in this chapter that describes all events and actions
+	This mode fits well when you have a regular state diagram,
+	like the ones in this chapter, which describes all events and actions
 	belonging to a state visually around that state,
 	and each state has its unique name.
       </p>
       <p>
-	With <c>handle_event_function</c> you are free to mix strategies
-	as you like because all events and states
-	are handled in the the same callback function.
+	With <c>handle_event_function</c>, you are free to mix strategies,
+	as all events and states are handled in the same callback function.
       </p>
       <p>
 	This mode works equally well when you want to focus on
-	one event at the time or when you want to focus on
-	one state at the time, but the <c>handle_event/4</c> function
+	one event at the time or on
+	one state at the time, but function
+	<seealso marker="stdlib:gen_statem#Module:handle_event/4">
+	<c>Module:handle_event/4</c></seealso>
 	quickly grows too large to handle without introducing dispatching.
       </p>
       <p>
-	The mode enables the use of non-atom states for example
-	complex states or even hiearchical states.
+	The mode enables the use of non-atom states, for example,
+	complex states or even hierarchical states.
 	If, for example, a state diagram is largely alike
-	for the client and for the server side of a protocol;
-	then you can have a state <c>{StateName,server}</c> or
-	<c>{StateName,client}</c> and since you do the dispatching
-	yourself you make <c>StateName</c> decide where in the code
+	for the client side and the server side of a protocol,
+	you can have a state <c>{StateName,server}</c> or
+	<c>{StateName,client}</c>. Also, as you do the dispatching
+	yourself, you make <c>StateName</c> decide where in the code
 	to handle most events in the state.
-	The second element of the tuple	is then used to select
-	whether to handle special client side or server side events.
+	The second element of the tuple is then used to select
+	whether to handle special client-side or server-side events.
       </p>
     </section>
   </section>
@@ -196,31 +196,28 @@ handle_event(EventType, EventContent, State, Data) ->
   <section>
     <title>Example</title>
     <p>
-      This is an example starting off as equivalent to the the example in the
-      <seealso marker="fsm"><c>gen_fsm</c> behaviour</seealso>
-      description.  In later chapters additions and tweaks are made
+      This example starts off as equivalent to the example in section
+      <seealso marker="fsm"><c>gen_fsm</c> Behavior</seealso>.
+      In later sections, additions and tweaks are made
       using features in <c>gen_statem</c> that <c>gen_fsm</c> does not have.
-      At the end of this section you can find the example again
+      The end of this chapter provides the example again
       with all the added features.
     </p>
     <p>
-      A door with a code lock can be viewed as a state machine.
-      Initially, the door is locked.  Anytime someone presses a button,
-      this generates an event.
+      A door with a code lock can be seen as a state machine.
+      Initially, the door is locked. When someone presses a button,
+      an event is generated.
       Depending on what buttons have been pressed before,
       the sequence so far can be correct, incomplete, or wrong.
-    </p>
-    <p>
-      If it is correct, the door is unlocked for 10 seconds (10000 ms).
-      If it is incomplete, we wait for another button to be pressed.  If
-      it is is wrong, we start all over,
-      waiting for a new button sequence.
+      If correct, the door is unlocked for 10 seconds (10,000 milliseconds).
+      If incomplete, we wait for another button to be pressed. If
+      wrong, we start all over, waiting for a new button sequence.
     </p>
     <image file="../design_principles/code_lock.png">
-      <icaption>Code lock state diagram</icaption>
+      <icaption>Code Lock State Diagram</icaption>
     </image>
     <p>
-      We can implement such a code lock state machine using
+      This code lock state machine can be implemented using
       <c>gen_statem</c> with the following callback module:
     </p>
     <marker id="ex"></marker>
@@ -241,7 +238,6 @@ start_link(Code) ->
 button(Digit) ->
     gen_statem:cast(?NAME, {button,Digit}).
 
-
 init(Code) ->
     do_lock(),
     Data = #{code => Code, remaining => Code},
@@ -286,7 +282,7 @@ code_change(_Vsn, State, Data, _Extra) ->
   <section>
     <title>Starting gen_statem</title>
     <p>
-      In the example in the previous section, the <c>gen_statem</c> is
+      In the example in the previous section, <c>gen_statem</c> is
       started by calling <c>code_lock:start_link(Code)</c>:
     </p>
     <code type="erl"><![CDATA[
@@ -294,63 +290,64 @@ start_link(Code) ->
     gen_statem:start_link({local,?NAME}, ?MODULE, Code, []).
     ]]></code>
     <p>
-      <c>start_link</c> calls the function
+      <c>start_link</c> calls function
       <seealso marker="stdlib:gen_statem#start_link/4">
 	<c>gen_statem:start_link/4</c>
-      </seealso>
-      which spawns and links to a new process; a <c>gen_statem</c>.
+      </seealso>,
+      which spawns and links to a new process, a <c>gen_statem</c>.
     </p>
     <list type="bulleted">
       <item>
         <p>
-	  The first argument, <c>{local,?NAME}</c>, specifies
-          the name.  In this case, the <c>gen_statem</c> is locally
-	  registered as <c>code_lock</c> through the macro <c>?NAME</c>.
-	</p>
+          The first argument, <c>{local,?NAME}</c>, specifies
+          the name. In this case, the <c>gen_statem</c> is locally
+          registered as <c>code_lock</c> through the macro <c>?NAME</c>.
+        </p>
         <p>
-	  If the name is omitted, the <c>gen_statem</c> is not registered.
-          Instead its pid must be used.  The name can also be given
-	  as <c>{global,Name}</c>, in which case the <c>gen_statem</c> is
-	  registered using
-	  <seealso marker="kernel:global#register_name/2">
-	    <c>global:register_name/2</c>.
-	  </seealso>
-	</p>
+          If the name is omitted, the <c>gen_statem</c> is not registered.
+          Instead its pid must be used. The name can also be specified
+          as <c>{global,Name}</c>, then the <c>gen_statem</c> is
+          registered using
+          <seealso marker="kernel:global#register_name/2">
+            <c>global:register_name/2</c>
+          </seealso>
+          in <c>Kernel</c>.
+        </p>
       </item>
       <item>
         <p>
-	  The second argument, <c>?MODULE</c>, is the name of
-          the callback module, that is; the module where the callback
+          The second argument, <c>?MODULE</c>, is the name of
+          the callback module, that is, the module where the callback
           functions are located, which is this module.
-	</p>
+        </p>
         <p>
-	  The interface functions (<c>start_link/1</c> and <c>button/1</c>)
-	  are located in the same module as the callback functions
-	  (<c>init/1</c>, <c>locked/3</c>, and <c>open/3</c>).
-	  It is normally good programming practice to have the client
-	  side and the server side code contained in one module.
-	</p>
+          The interface functions (<c>start_link/1</c> and <c>button/1</c>)
+          are located in the same module as the callback functions
+          (<c>init/1</c>, <c>locked/3</c>, and <c>open/3</c>).
+          It is normally good programming practice to have the client-side
+          code and the server-side code contained in one module.
+        </p>
       </item>
       <item>
         <p>
-	  The third argument, <c>Code</c>, is a list of digits that
-	  is the correct unlock code which is passsed
-	  to the callback function <c>init/1</c>.
+          The third argument, <c>Code</c>, is a list of digits, which
+          is the correct unlock code that is passed
+          to callback function <c>init/1</c>.
 	</p>
       </item>
       <item>
         <p>
-	  The fourth argument, <c>[]</c>, is a list of options.  See the
-	  <seealso marker="stdlib:gen_statem#start_link/3">
-	    <c>gen_statem:start_link/3</c>
-	  </seealso>
-	  manual page for available options.
+          The fourth argument, <c>[]</c>, is a list of options.
+          For the available options, see
+          <seealso marker="stdlib:gen_statem#start_link/3">
+            <c>gen_statem:start_link/3</c>
+          </seealso>.
 	</p>
       </item>
     </list>
     <p>
       If name registration succeeds, the new <c>gen_statem</c> process
-      calls the callback function <c>code_lock:init(Code)</c>.
+      calls callback function <c>code_lock:init(Code)</c>.
       This function is expected to return <c>{CallbackMode,State,Data}</c>,
       where
       <seealso marker="#callback_modes">
@@ -360,14 +357,14 @@ start_link(Code) ->
       <seealso marker="stdlib:gen_statem#type-callback_mode">
 	<c>state_functions</c>
       </seealso>
-      through the macro <c>?CALLBACK_MODE</c> that is; each state
+      through macro <c>?CALLBACK_MODE</c>. That is, each state
       has got its own handler function.
       <c>State</c> is the initial state of the <c>gen_statem</c>,
-      in this case <c>locked</c>; assuming the door is locked to begin with.
-      <c>Data</c> is the internal server data of the <c>gen_statem</c>.
+      in this case <c>locked</c>; assuming that the door is locked to begin
+      with. <c>Data</c> is the internal server data of the <c>gen_statem</c>.
       Here the server data is a <seealso marker="stdlib:maps">map</seealso>
-      with the key <c>code</c> that stores
-      the correct button sequence and the key <c>remaining</c>
+      with key <c>code</c> that stores
+      the correct button sequence, and key <c>remaining</c>
       that stores the remaining correct button sequence
       (the same as the <c>code</c> to begin with).
     </p>
@@ -377,24 +374,25 @@ init(Code) ->
     Data = #{code => Code, remaining => Code},
     {?CALLBACK_MODE,locked,Data}.
     ]]></code>
-    <p>
+    <p>Function
       <seealso marker="stdlib:gen_statem#start_link/3">
 	<c>gen_statem:start_link</c>
       </seealso>
-      is synchronous.  It does not return until the <c>gen_statem</c>
-      has been initialized and is ready to receive events.
+      is synchronous. It does not return until the <c>gen_statem</c>
+      is initialized and is ready to receive events.
     </p>
     <p>
+      Function
       <seealso marker="stdlib:gen_statem#start_link/3">
 	<c>gen_statem:start_link</c>
       </seealso>
       must be used if the <c>gen_statem</c>
-      is part of a supervision tree, that is; started by a supervisor.
-      There is another function;
+      is part of a supervision tree, that is, started by a supervisor.
+      Another function,
       <seealso marker="stdlib:gen_statem#start/3">
 	<c>gen_statem:start</c>
       </seealso>
-      to start a standalone <c>gen_statem</c>, that is;
+      can be used to start a standalone <c>gen_statem</c>, that is,
       a <c>gen_statem</c> that is not part of a supervision tree.
     </p>
   </section>
@@ -402,7 +400,7 @@ init(Code) ->
 <!-- =================================================================== -->
 
   <section>
-    <title>Events and Handling them</title>
+    <title>Handling Events</title>
     <p>The function notifying the code lock about a button event is
       implemented using
       <seealso marker="stdlib:gen_statem#cast/2">
@@ -415,9 +413,9 @@ button(Digit) ->
     ]]></code>
     <p>
       The first argument is the name of the <c>gen_statem</c> and must
-      agree with the name used to start it so therefore we use the
+      agree with the name used to start it. So, we use the
       same macro <c>?NAME</c> as when starting.
-      <c>{button,Digit}</c> is the actual event content.
+      <c>{button,Digit}</c> is the event content.
     </p>
     <p>
       The event is made into a message and sent to the <c>gen_statem</c>.
@@ -452,19 +450,19 @@ open(cast, {button,_}, Data) ->
     ]]></code>
     <p>
       If the door is locked and a button is pressed, the pressed
-      button is compared with the next correct button and,
-      depending on the result, the door is either unlocked
+      button is compared with the next correct button.
+      Depending on the result, the door is either unlocked
       and the <c>gen_statem</c> goes to state <c>open</c>,
       or the door remains in state <c>locked</c>.
     </p>
     <p>
-      If the pressed button is incorrect the server data
+      If the pressed button is incorrect, the server data
       restarts from the start of the code sequence.
     </p>
     <p>
-      In state <c>open</c> any button locks the door since
-      any event cancels the event timer so we will not get
-      a timeout event after a button event.
+      In state <c>open</c>, any button locks the door, as
+      any event cancels the event timer, so no
+      time-out event occurs after a button event.
     </p>
   </section>
 
@@ -478,11 +476,11 @@ open(cast, {button,_}, Data) ->
 {next_state,open,Data#{remaining := Code},10000};
     ]]></code>
     <p>
-      10000 is a time-out value in milliseconds.
-      After this time, that is; 10 seconds, a time-out occurs.
+      10,000 is a time-out value in milliseconds.
+      After this time (10 seconds), a time-out occurs.
       Then, <c>StateName(timeout, 10000, Data)</c> is called.
       The time-out occurs when the door has been in state <c>open</c>
-      for 10 seconds.  After that the door is locked again:
+      for 10 seconds. After that the door is locked again:
     </p>
     <code type="erl"><![CDATA[
 open(timeout, _,  Data) ->
@@ -496,16 +494,16 @@ open(timeout, _,  Data) ->
   <section>
     <title>All State Events</title>
     <p>
-      Sometimes an event can arrive in any state of the <c>gen_statem</c>.
+      Sometimes events can arrive in any state of the <c>gen_statem</c>.
       It is convenient to handle these in a common state handler function
       that all state functions call for events not specific to the state.
     </p>
     <p>
-      Let's introduce a <c>code_length/0</c> function that returns
+      Consider a <c>code_length/0</c> function that returns
       the length of the correct code
-      (that should not be sensitive to reveal...).
-      We'll dispatch all events that are not state specific
-      to the common function <c>handle_event/3</c>.
+      (that should not be sensitive to reveal).
+      We dispatch all events that are not state-specific
+      to the common function <c>handle_event/3</c>:
     </p>
     <code type="erl"><![CDATA[
 ...
@@ -532,7 +530,7 @@ handle_event({call,From}, code_length, #{code := Code} = Data) ->
       This example uses
       <seealso marker="stdlib:gen_statem#call/2">
 	<c>gen_statem:call/2</c>
-      </seealso>
+      </seealso>,
       which waits for a reply from the server.
       The reply is sent with a <c>{reply,From,Reply}</c> tuple
       in an action list in the <c>{keep_state,...}</c> tuple
@@ -545,9 +543,12 @@ handle_event({call,From}, code_length, #{code := Code} = Data) ->
   <section>
     <title>One Event Handler</title>
     <p>
-      If you use the mode <c>handle_event_function</c>
-      all events are handled in <c>handle_event/4</c> and we
-      may (but do not have to) use an event-centered approach
+      If mode <c>handle_event_function</c> is used,
+      all events are handled in
+      <seealso marker="stdlib:gen_statem#Module:handle_event/4">
+        <c>Module:handle_event/4</c>
+      </seealso>
+      and we can (but do not have to) use an event-centered approach
       where we dispatch on event first and then state:
     </p>
     <code type="erl"><![CDATA[
@@ -596,19 +597,18 @@ handle_event(timeout, _, open, Data) ->
 	The <c>gen_statem</c> is automatically terminated by its supervisor.
 	Exactly how this is done is defined by a
 	<seealso marker="sup_princ#shutdown">shutdown strategy</seealso>
-        set in the supervisor.
+	set in the supervisor.
       </p>
       <p>
 	If it is necessary to clean up before termination, the shutdown
-        strategy must be a time-out value and the <c>gen_statem</c> must
-	in the <c>init/1</c> function set itself to trap exit signals
+	strategy must be a time-out value and the <c>gen_statem</c> must
+	in function <c>init/1</c> set itself to trap exit signals
 	by calling
 	<seealso marker="erts:erlang#process_flag/2">
-	  <c>process_flag(trap_exit, true)</c>.
-	</seealso>
-	When ordered to shutdown, the <c>gen_statem</c> then calls
-	the callback function
-	<c>terminate(shutdown, State, Data)</c>:
+	  <c>process_flag(trap_exit, true)</c>
+	</seealso>.
+	When ordered to shut down, the <c>gen_statem</c> then calls
+	callback function <c>terminate(shutdown, State, Data)</c>:
       </p>
       <code type="erl"><![CDATA[
 init(Args) ->
@@ -617,9 +617,9 @@ init(Args) ->
     ...
       ]]></code>
       <p>
-	In this example we let the <c>terminate/3</c> function
-	lock the door if it is open so we do not accidentally leave the door
-	open when the supervision tree terminates.
+	In the following example, function <c>terminate/3</c>
+	locks the door if it is open, so we do not accidentally leave the door
+	open when the supervision tree terminates:
       </p>
       <code type="erl"><![CDATA[
 terminate(_Reason, State, _Data) ->
@@ -634,8 +634,8 @@ terminate(_Reason, State, _Data) ->
 	If the <c>gen_statem</c> is not part of a supervision tree,
 	it can be stopped using
 	<seealso marker="stdlib:gen_statem#stop/1">
-	  <c>gen_statem:stop</c>,
-	</seealso>
+	  <c>gen_statem:stop</c>
+	</seealso>,
 	preferably through an API function:
       </p>
       <code type="erl"><![CDATA[
@@ -647,8 +647,8 @@ stop() ->
     gen_statem:stop(?NAME).
       ]]></code>
       <p>
-	This makes the <c>gen_statem</c> call the <c>terminate/3</c>
-	callback function just like for a supervised server
+	This makes the <c>gen_statem</c> call callback function
+	<c>terminate/3</c> just like for a supervised server
 	and waits for the process to terminate.
       </p>
     </section>
@@ -659,15 +659,15 @@ stop() ->
   <section>
     <title>Actions</title>
     <p>
-      In the first chapters we mentioned actions as a part of
-      the general state machine model, and these actions
-      are implemented with the code the <c>gen_statem</c>
-      callback module executes in an event handling
+      In the first sections actions were mentioned as a part of
+      the general state machine model. These actions
+      are implemented with the code that callback module
+      <c>gen_statem</c> executes in an event-handling
       callback function before returning
       to the <c>gen_statem</c> engine.
     </p>
     <p>
-      There are more specific state transition actions
+      There are more specific state-transition actions
       that a callback function can order the <c>gen_statem</c>
       engine to do after the callback function return.
       These are ordered by returning a list of
@@ -680,27 +680,28 @@ stop() ->
       </seealso>
       from the
       <seealso marker="stdlib:gen_statem#Module:StateName/3">
-	callback function.
-      </seealso>
+	callback function
+      </seealso>.
       These state transition actions affect the <c>gen_statem</c>
-      engine itself.  They can:
+      engine itself and can do the following:
     </p>
     <list type="bulleted">
-      <item>Postpone the current event.</item>
-      <item>Hibernate the <c>gen_statem</c>.</item>
-      <item>Start an event timeout.</item>
-      <item>Reply to a caller.</item>
-      <item>Generate the next event to handle.</item>
+      <item>Postpone the current event</item>
+      <item>Hibernate the <c>gen_statem</c></item>
+      <item>Start an event time-out</item>
+      <item>Reply to a caller</item>
+      <item>Generate the next event to handle</item>
     </list>
     <p>
-      We have mentioned the event timeout
-      and replying to a caller in the example above.
-      An example of event postponing comes in later in this chapter.
-      See the
+      In the example earlier was mentioned the event time-out
+      and replying to a caller.
+      An example of event postponing is included later in this chapter.
+      For details, see the
       <seealso marker="stdlib:gen_statem#type-action">
-	reference manual
+	<c>gen_statem(3)</c>
       </seealso>
-      for details.  You can for example actually reply to several callers
+      manual page.
+      You can, for example, reply to many callers
       and generate multiple next events to handle.
     </p>
   </section>
@@ -710,16 +711,16 @@ stop() ->
   <section>
     <title>Event Types</title>
     <p>
-      So far we have mentioned a few
+      The previous sections mentioned a few
       <seealso marker="stdlib:gen_statem#type-event_type">
-	event types.
-      </seealso>
+	event types
+      </seealso>.
       Events of all types are handled in the same callback function,
       for a given state, and the function gets
       <c>EventType</c> and <c>EventContent</c> as arguments.
     </p>
     <p>
-      Here is the complete list of event types and where
+      The following is a complete list of event types and where
       they come from:
     </p>
     <taglist>
@@ -735,13 +736,13 @@ stop() ->
 	Generated by
 	<seealso marker="stdlib:gen_statem#call/2">
 	  <c>gen_statem:call</c>
-	</seealso>
+	</seealso>,
 	where <c>From</c> is the reply address to use
 	when replying either through the state transition action
 	<c>{reply,From,Msg}</c> or by calling
 	<seealso marker="stdlib:gen_statem#reply/1">
-	  <c>gen_statem:reply</c>.
-	</seealso>
+	  <c>gen_statem:reply</c>
+	</seealso>.
       </item>
       <tag><c>info</c></tag>
       <item>
@@ -750,15 +751,15 @@ stop() ->
       </item>
       <tag><c>timeout</c></tag>
       <item>
-	Generated by the state transition action
+	Generated by state transition action
 	<c>{timeout,Time,EventContent}</c> (or its short form <c>Time</c>)
 	timer timing out.
       </item>
       <tag><c>internal</c></tag>
       <item>
-	Generated by the state transition action
+	Generated by state transition action
 	<c>{next_event,internal,EventContent}</c>.
-	In fact all event types above can be generated using
+	All event types above can be generated using
 	<c>{next_event,EventType,EventContent}</c>.
       </item>
     </taglist>
@@ -767,34 +768,34 @@ stop() ->
 <!-- =================================================================== -->
 
   <section>
-    <title>State Timeouts</title>
+    <title>State Time-Outs</title>
     <p>
-      The timeout event generated by the state transition action
-      <c>{timeout,Time,EventContent}</c> is an event timeout,
-      that is; if an event arrives the timer is cancelled.
-      You get either an event or a timeout but not both.
+      The time-out event generated by state transition action
+      <c>{timeout,Time,EventContent}</c> is an event time-out,
+      that is, if an event arrives the timer is cancelled.
+      You get either an event or a time-out, but not both.
     </p>
     <p>
-      Often you want a timer to not be cancelled by any event
+      Often you want a timer not to be cancelled by any event
       or you want to start a timer in one state and respond
-      to the timeout in another.  This can be accomplished
-      with a regular erlang timer:
+      to the time-out in another. This can be accomplished
+      with a regular Erlang timer:
       <seealso marker="erts:erlang#start_timer/4">
 	<c>erlang:start_timer</c>.
       </seealso>
     </p>
     <p>
-      Looking at the example in this chapter so far; using the
+      For the example so far in this chapter: using the
       <c>gen_statem</c> event timer has the consequence that
       if a button event is generated while in the <c>open</c> state,
-      the timeout is cancelled and the button event is delivered.
-      Therefore we chose to lock the door if this happended.
+      the time-out is cancelled and the button event is delivered.
+      So, we choose to lock the door if this occurred.
     </p>
     <p>
-      Suppose we do not want a button to lock the door,
+      Suppose that we do not want a button to lock the door,
       instead we want to ignore button events in the <c>open</c> state.
       Then we start a timer when entering the <c>open</c> state
-      and wait for it to expire while ignoring button events:
+      and waits for it to expire while ignoring button events:
     </p>
     <code type="erl"><![CDATA[
 ...
@@ -816,17 +817,17 @@ open(cast, {button,_}, Data) ->
 ...
     ]]></code>
     <p>
-      If you need to cancel a timer due to some other event you can use
+      If you need to cancel a timer because of some other event, you can use
       <seealso marker="erts:erlang#cancel_timer/2">
-	<c>erlang:cancel_timer(Tref)</c>.
-      </seealso>
-      Note that a timeout message can not arrive after this,
+	<c>erlang:cancel_timer(Tref)</c>
+      </seealso>.
+      Notice that a time-out message cannot arrive after this,
       unless you have postponed it (see the next section) before,
-      so make sure you do not accidentally postpone such messages.
+      so ensure that you do not accidentally postpone such messages.
     </p>
     <p>
-      Another way to cancel a timer is to not cancel it,
-      but instead to ignore it if it arrives in a state
+      Another way to cancel a timer is not to cancel it,
+      but to ignore it if it arrives in a state
       where it is known to be late.
     </p>
   </section>
@@ -839,7 +840,7 @@ open(cast, {button,_}, Data) ->
       If you want to ignore a particular event in the current state
       and handle it in a future state, you can postpone the event.
       A postponed event is retried after the state has
-      changed i.e <c>OldState =/= NewState</c>.
+      changed, that is, <c>OldState =/= NewState</c>.
     </p>
     <p>
       Postponing is ordered by the state transition
@@ -850,8 +851,8 @@ open(cast, {button,_}, Data) ->
     </p>
     <p>
       In this example, instead of ignoring button events
-      while in the <c>open</c> state we can postpone them
-      and they will be queued and later handled in the <c>locked</c> state:
+      while in the <c>open</c> state, we can postpone them
+      and they are queued and later handled in the <c>locked</c> state:
     </p>
     <code type="erl"><![CDATA[
 ...
@@ -860,17 +861,17 @@ open(cast, {button,_}, Data) ->
 ...
     ]]></code>
     <p>
-      The fact that a postponed event is only retried after a state change
-      translates into a requirement on the event and state space:
-      if you have a choice between storing a state data item
-      in the <c>State</c> or in the <c>Data</c>;
-      should a change in the item value affect which events that
-      are handled, then this item ought to be part of the state.
+      A postponed event is only retried after a state change
+      translates into a requirement on the event and state space.
+      If you have a choice between storing a state data item
+      in the <c>State</c> or in the <c>Data</c>:
+      if a change in the item value affects which events that
+      are handled, then this item is to be part of the state.
     </p>
     <p>
-      What you want to avoid is that you maybe much later decide
-      to postpone an event in one state and by misfortune it is never retried
-      because the code only changes the <c>Data</c> but not the <c>State</c>.
+      You want to avoid that you maybe much later decide
+      to postpone an event in one state and by misfortune it is never retried,
+      as the code only changes the <c>Data</c> but not the <c>State</c>.
     </p>
 
     <section>
@@ -883,7 +884,7 @@ open(cast, {button,_}, Data) ->
 	or from the context.
       </p>
       <p>
-	Possible actions may be; ignore as in drop the event
+	Possible actions: ignore as in drop the event
 	(maybe log it) or deal with the event in some other state
 	as in postpone it.
       </p>
@@ -892,10 +893,10 @@ open(cast, {button,_}, Data) ->
     <section>
       <title>Selective Receive</title>
       <p>
-	Erlang's selective receive statement is often used to
-	describe simple state machine examples in straightforward
-	Erlang code.  Here is a possible implementation of
-	the first example:
+        Erlang's selective receive statement is often used to
+        describe simple state machine examples in straightforward
+        Erlang code. The following is a possible implementation of
+        the first example:
       </p>
     <code type="erl"><![CDATA[
 -module(code_lock).
@@ -937,16 +938,16 @@ do_unlock() ->
     io:format("Open~n", []).
     ]]></code>
     <p>
-      The selective receive in this case causes <c>open</c>
-      to implicitly postpone any events to the <c>locked</c> state.
+      The selective receive in this case causes implicitly <c>open</c>
+      to postpone any events to the <c>locked</c> state.
     </p>
     <p>
-      A selective receive can not be used from a <c>gen_statem</c>
-      behaviour just as for any <c>gen_*</c> behavior
-      since the receive statement is within the <c>gen_*</c> engine itself.
-      It has to be there because all
+      A selective receive cannot be used from a <c>gen_statem</c>
+      behavior as for any <c>gen_*</c> behavior,
+      as the receive statement is within the <c>gen_*</c> engine itself.
+      It must be there because all
       <seealso marker="stdlib:sys"><c>sys</c></seealso>
-      compatible behaviours must respond to system messages and therefore
+      compatible behaviors must respond to system messages and therefore
       do that in their engine receive loop,
       passing non-system messages to the callback module.
     </p>
@@ -955,15 +956,15 @@ do_unlock() ->
       <seealso marker="stdlib:gen_statem#type-action">
 	action
       </seealso>
-      <c>postpone</c> is designed to be able to model
-      selective receives.  A selective receive implicitly postpones
+      <c>postpone</c> is designed to model
+      selective receives. A selective receive implicitly postpones
       any not received events, but the <c>postpone</c>
       state transition action explicitly postpones one received event.
     </p>
     <p>
-      Other than that both mechanisms have got the same theoretical
+      Both mechanisms have the same theoretical
       time and memory complexity, while the selective receive
-      language construct has got smaller constant factors.
+      language construct has smaller constant factors.
     </p>
     </section>
   </section>
@@ -971,9 +972,9 @@ do_unlock() ->
 <!-- =================================================================== -->
 
   <section>
-    <title>Self Generated Events</title>
+    <title>Self-Generated Events</title>
     <p>
-      It may be beneficial in some cases to be able to generate events
+      It can sometimes be beneficial to be able to generate events
       to your own state machine.
       This can be done with the state transition
       <seealso marker="stdlib:gen_statem#type-action">
@@ -984,30 +985,30 @@ do_unlock() ->
     <p>
       You can generate events of any existing
       <seealso marker="stdlib:gen_statem#type-action">
-	type,
-      </seealso>
-      but the <c>internal</c> type can only be generated through the
-      <c>next_event</c> action and hence can not come from an external source,
+	type
+      </seealso>,
+      but the <c>internal</c> type can only be generated through action
+      <c>next_event</c>. Hence, it cannot come from an external source,
       so you can be certain that an <c>internal</c> event is an event
       from your state machine to itself.
     </p>
     <p>
-      One example of using self generated events may be when you have
+      One example of using self-generated events can be when you have
       a state machine specification that uses state entry actions.
-      That you could code using a dedicated function
-      to do the state transition.  But if you want that code to be
-      visible besides the other state logic you can insert
+      You can code that using a dedicated function
+      to do the state transition. But if you want that code to be
+      visible besides the other state logic, you can insert
       an <c>internal</c> event that does the entry actions.
       This has the same unfortunate consequence as using
-      state transition functions that everywhere you go to
-      the state in question you will have to explicitly
+      state transition functions: everywhere you go to
+      the state, you must explicitly
       insert the <c>internal</c> event
-      or use state transition function.
+      or use a state transition function.
     </p>
     <p>
-      Here is an implementation of entry actions
+      The following is an implementation of entry actions
       using <c>internal</c> events with content <c>enter</c>
-      utilizing a helper function <c>enter/3</c> for state entry:
+      using a helper function <c>enter/3</c> for state entry:
     </p>
     <code type="erl"><![CDATA[
 ...
@@ -1051,20 +1052,20 @@ enter(Tag, State, Data) ->
   <section>
     <title>Example Revisited</title>
     <p>
-      Here is the example after all mentioned modifications
-      and some more utilizing the entry actions,
+      This section includes the example after all mentioned modifications
+      and some more using the entry actions,
       which deserves a new state diagram:
     </p>
     <image file="../design_principles/code_lock_2.png">
-      <icaption>Code lock state diagram revisited</icaption>
+      <icaption>Code Lock State Diagram Revisited</icaption>
     </image>
     <p>
-      Note that this state diagram does not specify how to handle
-      a button event in the state <c>open</c>, so you will have to
-      read some other place that is here that unspecified events
-      shall be ignored as in not consumed but handled in some other state.
-      Nor does it show that the <c>code_length/0</c> call shall be
-      handled in every state.
+      Notice that this state diagram does not specify how to handle
+      a button event in the state <c>open</c>. So, you need to
+      read somewhere else that unspecified events
+      must be ignored as in not consumed but handled in some other state.
+      Also, the state diagram does not show that the <c>code_length/0</c>
+      call must be handled in every state.
     </p>
 
     <section>
@@ -1147,10 +1148,11 @@ code_change(_Vsn, State, Data, _Extra) ->
     <section>
       <title>Callback Mode: handle_event_function</title>
       <p>
-	What to change to use one <c>handle_event/4</c> function.
-	Here a clean first-dispatch-on-event approach
-	does not work that well due to the generated
-	entry actions:
+        This section describes what to change in the example
+        to use one <c>handle_event/4</c> function.
+        The following clean first-dispatch-on-event approach
+        does not work that well because of the generated
+        entry actions:
       </p>
       <code type="erl"><![CDATA[
 ...
@@ -1195,7 +1197,7 @@ handle_event({call,From}, code_length, _State, #{code := Code}) ->
       ]]></code>
     </section>
     <p>
-      Note that postponing buttons from the <c>locked</c> state
+      Notice that postponing buttons from the <c>locked</c> state
       to the <c>open</c> state feels like the wrong thing to do
       for a code lock, but it at least illustrates event postponing.
     </p>
@@ -1206,33 +1208,33 @@ handle_event({call,From}, code_length, _State, #{code := Code}) ->
   <section>
     <title>Filter the State</title>
     <p>
-      The example servers so far in this chapter will for example
-      when killed by an exit signal or due to an internal error
-      print out the full internal state in the error log.
+      The example servers so far in this chapter
+      print the full internal state in the error log, for example,
+      when killed by an exit signal or because of an internal error.
       This state contains both the code lock code
-      and which digits that remains to unlock.
+      and which digits that remain to unlock.
     </p>
     <p>
       This state data can be regarded as sensitive,
       and maybe not what you want in the error log
-      because of something unpredictable happening.
+      because of some unpredictable event.
     </p>
     <p>
       Another reason to filter the state can be
-      that the state is too big to print out since it fills
+      that the state is too large to print, as it fills
       the error log with uninteresting details.
     </p>
     <p>
-      To avoid this you can format the internal state
+      To avoid this, you can format the internal state
       that gets in the error log and gets returned from
       <seealso marker="stdlib:sys#get_status/1">
 	<c>sys:get_status/1,2</c>
       </seealso>
-      by implementing the
+      by implementing function
       <seealso marker="stdlib:gen_statem#Module:format_status/2">
 	<c>Module:format_status/2</c>
-      </seealso>
-      function, for example like this:
+      </seealso>,
+      for example like this:
     </p>
     <code type="erl"><![CDATA[
 ...
@@ -1260,9 +1262,9 @@ format_status(Opt, [_PDict,State,Data]) ->
       <seealso marker="stdlib:gen_statem#Module:format_status/2">
 	<c>Module:format_status/2</c>
       </seealso>
-      function.  If you do not a default implementation is used that
+      function. If you do not, a default implementation is used that
       does the same as this example function without filtering
-      the <c>Data</c> term that is: <c>StateData = {State,Data}</c>.
+      the <c>Data</c> term, that is, <c>StateData = {State,Data}</c>.
     </p>
   </section>
 
@@ -1275,54 +1277,56 @@ format_status(Opt, [_PDict,State,Data]) ->
       <seealso marker="stdlib:gen_statem#type-callback_mode">
 	<c>handle_event_function</c>
       </seealso>
-      enables using a non-atom state as described in
+      enables using a non-atom state as described in section
       <seealso marker="#callback_modes">
-	Callback Modes,
-      </seealso>
-      for example a complex state term like a tuple.
+	Callback Modes
+      </seealso>,
+      for example, a complex state term like a tuple.
     </p>
     <p>
       One reason to use this is when you have
-      a state item that affects the event handling
-      in particular when combining that with postponing events.
-      Let us complicate the previous example
+      a state item that affects the event handling,
+      in particular in combination with postponing events.
+      We complicate the previous example
       by introducing a configurable lock button
-      (this is the state item in question)
-      that in the <c>open</c> state immediately locks the door,
+      (this is the state item in question),
+      which in the <c>open</c> state immediately locks the door,
       and an API function <c>set_lock_button/1</c> to set the lock button.
     </p>
     <p>
       Suppose now that we call <c>set_lock_button</c>
       while the door is open,
       and have already postponed a button event
-      that up until now was not the lock button;
-      the sensible thing might be to say that
-      the button was pressed too early so it should
-      not be recognized as the lock button,
-      but then it might be surprising that a button event
+      that until now was not the lock button.
+      The sensible thing can be to say that
+      the button was pressed too early so it is
+      not to be recognized as the lock button.
+      However, then it can be surprising that a button event
       that now is the lock button event arrives (as retried postponed)
       immediately after the state transits to <c>locked</c>.
     </p>
     <p>
-      So let us make the <c>button/1</c> function synchronous
-      by using <c>gen_statem:call</c>,
+      So we make the <c>button/1</c> function synchronous
+      by using
+      <seealso marker="stdlib:gen_statem#call/2">
+        <c>gen_statem:call</c></seealso>
       and still postpone its events in the <c>open</c> state.
       Then a call to <c>button/1</c> during the <c>open</c>
-      state will not return until the state transits to <c>locked</c>
-      since it is there the event is handled and the reply is sent.
+      state does not return until the state transits to <c>locked</c>,
+      as it is there the event is handled and the reply is sent.
     </p>
     <p>
-      If now one process calls <c>set_lock_button/1</c>
-      to change the lock button while some other process
-      hangs in <c>button/1</c> with the new lock button
-      it could be expected that the hanging lock button call
+      If a process now calls <c>set_lock_button/1</c>
+      to change the lock button while another process
+      hangs in <c>button/1</c> with the new lock button,
+      it can be expected that the hanging lock button call
       immediately takes effect and locks the lock.
-      Therefore we make the current lock button a part of the state
-      so when we change the lock button the state will change
-      and all postponed events will be retried.
+      Therefore, we make the current lock button a part of the state,
+      so that when we change the lock button, the state changes
+      and all postponed events are retried.
     </p>
     <p>
-      We define the state as <c>{StateName,LockButton}</c>
+      We define the state as <c>{StateName,LockButton}</c>,
       where <c>StateName</c> is as before
       and <c>LockButton</c> is the current lock button:
     </p>
@@ -1441,10 +1445,9 @@ format_status(Opt, [_PDict,State,Data]) ->
     end.
     ]]></code>
     <p>
-      It may be an ill-fitting model for a physical code lock
-      that the <c>button/1</c> call might hang until the lock
-      is locked.  But for an API in general it is really not
-      that strange.
+      It can be an ill-fitting model for a physical code lock
+      that the <c>button/1</c> call can hang until the lock
+      is locked. But for an API in general it is not that strange.
     </p>
   </section>
 
@@ -1457,26 +1460,25 @@ format_status(Opt, [_PDict,State,Data]) ->
       and they have some state(s) in their lifetime in which
       the servers can be expected to idle for a while,
       and the amount of heap memory all these servers need
-      is a problem; then it is possible to minimize
-      the memory footprint of a server by hibernating it through
+      is a problem, then the memory footprint of a server
+      can be mimimized by hibernating it through
       <seealso marker="stdlib:proc_lib#hibernate/3">
 	<c>proc_lib:hibernate/3</c>.
       </seealso>
     </p>
     <note>
       <p>
-	To hibernate a process is rather costly. See
-	<seealso marker="erts:erlang#hibernate/3">
-	  <c>erlang:hibernate/3</c>.
-	</seealso>
-	It is in general not something you want to do
-	after every event.
+        It is rather costly to hibernate a process; see
+        <seealso marker="erts:erlang#hibernate/3">
+          <c>erlang:hibernate/3</c>
+        </seealso>.
+        It is not something you want to do after every event.
       </p>
     </note>
     <p>
-      We can in this example hibernate in the <c>{open,_}</c> state
-      since what normally happens in that state is that
-      the state timeout after a while
+      We can in this example hibernate in the <c>{open,_}</c> state,
+      because what normally occurs in that state is that
+      the state time-out after a while
       triggers a transition to <c>{locked,_}</c>:
     </p>
     <code type="erl"><![CDATA[
@@ -1498,24 +1500,24 @@ handle_event(
       </seealso>
       action list on the last line
       when entering the <c>{open,_}</c> state is the only change.
-      If any event arrives in the <c>{open,_},</c> state we
-      do not bother to re-hibernate, so the server stays
+      If any event arrives in the <c>{open,_},</c> state, we
+      do not bother to rehibernate, so the server stays
       awake after any event.
     </p>
     <p>
       To change that we would need to insert
-      the <c>hibernate</c> action in more places,
-      for example for the state independent <c>set_lock_button</c>
+      action <c>hibernate</c> in more places.
+      For example, for the state-independent <c>set_lock_button</c>
       and <c>code_length</c> operations that then would have to
       be aware of using <c>hibernate</c> while in the
-      <c>{open,_}</c> state which would clutter the code.
+      <c>{open,_}</c> state, which would clutter the code.
     </p>
     <p>
-      This server probably does not use an amount of
+      This server probably does not use
       heap memory worth hibernating for.
-      To gain anything from hibernation your server would
-      have to actually produce some garbage during callback execution,
-      for which this example server may serve as a bad example.
+      To gain anything from hibernation, your server would
+      have to produce some garbage during callback execution,
+      for which this example server can serve as a bad example.
     </p>
   </section>