Update terminology to data(), transition_op(), etc

3 files changed, 338 insertions, 310 deletions

diff --git a/lib/stdlib/doc/src/gen_statem.xml b/lib/stdlib/doc/src/gen_statem.xml
index c685d24b78..15e9584360 100644
--- a/lib/stdlib/doc/src/gen_statem.xml
+++ b/lib/stdlib/doc/src/gen_statem.xml
@@ -94,7 +94,7 @@ erlang:'!'            -----> Module:StateName/5
       <seealso marker="#Module:StateName/5">
         <c>Module:StateName/5</c>
       </seealso>.
-      This naturally collects all code for a specific state
+      This gathers all code for a specific state
       in one function and hence dispatches on state first.
     </p>
     <p>When
@@ -135,8 +135,8 @@ erlang:'!'            -----> Module:StateName/5
     <p>The
       <seealso marker="#state_function">state function</seealso>
       can insert events using the
-      <seealso marker="#type-state_operation">
-	<c>state_operation()</c> <c>next_event</c>
+      <seealso marker="#type-transition_action">
+	<c>transition_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
@@ -176,8 +176,8 @@ erlang:'!'            -----> Module:StateName/5
       <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-state_op"><c>StateOps</c></seealso> list.
-      This might be useful if the server is expected to be idle
+      <seealso marker="#type-transition_op"><c>Ops</c></seealso>
+      list. This might be useful if the server is expected to be idle
       for a long time. However use this feature with care
       since hibernation implies at least two garbage collections
       (when hibernating and shortly after waking up) and that is not
@@ -273,8 +273,8 @@ erlang:'!'            -----> Module:StateName/5
       <name name="client" />
       <desc>
 	<p>Client address to use when replying through for example the
-	  <seealso marker="#type-state_op">
-	    state_op() {reply,Client,Reply}
+	  <seealso marker="#type-transition_op">
+	    transition_op() {reply,Client,Reply}
 	  </seealso>
 	  to a client that has called the <c>gen_statem</c> server using
 	  <seealso marker="#call/2">call/2</seealso>.
@@ -296,19 +296,21 @@ erlang:'!'            -----> Module:StateName/5
 	  <seealso marker="#type-callback_mode">
 	    callback_mode
 	  </seealso> is <c>state_functions</c>, which is the default,
-	  the state has to be of this type i.e an <c>atom()</c>.
+	  the state has to be of this type.
 	</p>
       </desc>
     </datatype>
     <datatype>
-      <name name="state_data" />
+      <name name="data" />
       <desc>
-	<p>A <c>term()</c> in which the state machine implementation
-	  should store any state data it needs.  The difference between
-	  this data and the
-	  <seealso marker="#type-state">state()</seealso>
+	<p>A term in which the state machine implementation
+	  should store any server data it needs.  The difference between
+	  this and the <seealso marker="#type-state">state()</seealso>
 	  itself is that a change in this data does not cause
-	  postponed events to be retried.
+	  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
+	  a part of the state.
 	</p>
       </desc>
     </datatype>
@@ -334,8 +336,8 @@ erlang:'!'            -----> Module:StateName/5
       <desc>
 	<p>A <c>fun()</c> of arity 2 that takes an event
 	  and returns a boolean.
-	  When used in <c>{remove_event,RemoveEventPredicate}</c>
-	  from <seealso marker="#type-state_op">state_op()</seealso>.
+	  When used in <c>{remove_event,RemoveEventPredicate}</c> from
+	  <seealso marker="#type-transition_op">transition_op()</seealso>.
 	  The event for which the predicate returns <c>true</c> will
 	  be removed.
 	</p>
@@ -378,17 +380,16 @@ erlang:'!'            -----> Module:StateName/5
       </desc>
     </datatype>
     <datatype>
-      <name name="state_op" />
+      <name name="transition_op" />
       <desc>
 	<p>Either a
-	  <seealso marker="#type-state_option">
-	    <c>state_option()</c>
+	  <seealso marker="#type-transition_option">
+	    <c>transition_option()</c>
 	  </seealso> of which the last occurence
 	  in the containing list takes precedence, or a
-	  <seealso marker="#type-state_operation">
-	    <c>state_operation()</c>
-	  </seealso> that are performed in order of
-	  the containing list.
+	  <seealso marker="#type-transition_action">
+	    <c>transition_action()</c>
+	  </seealso> performed in the order of the containing list.
 	</p>
 	<p>These may be returned from the
 	  <seealso marker="#state_function">state function</seealso>,
@@ -404,7 +405,7 @@ erlang:'!'            -----> Module:StateName/5
 	  <item>If the state changes the queue of incoming events
 	    is reset to start with the oldest postponed.
 	  </item>
-	  <item>All operations are processed in order of appearance.
+	  <item>All actions are processed in order of appearance.
 	  </item>
 	  <item>The <c>timeout</c> option is processed if present,
 	    so a state timer may be started or a timeout zero event
@@ -424,9 +425,9 @@ erlang:'!'            -----> Module:StateName/5
       </desc>
     </datatype>
     <datatype>
-      <name name="state_option" />
+      <name name="transition_option" />
       <desc>
-	<p>If multiple state options of the same type are present
+	<p>If multiple state options of the same kind are present
 	  in the containing list these are set in the list order
 	  and the last value is kept.
 	</p>
@@ -448,7 +449,7 @@ erlang:'!'            -----> Module:StateName/5
 	    <seealso marker="proc_lib#hibernate/3">
 	      <c>proc_lib:hibernate/3</c>
 	    </seealso> before <c>receive</c> to wait for a new event.
-	    If there are enqueued events the <c>hibernate</c> operation
+	    If there are enqueued events the <c>hibernate</c> action
 	    is ignored as if an event just arrived and awakened
 	    the <c>gen_statem</c>.
 	  </item>
@@ -464,8 +465,8 @@ erlang:'!'            -----> Module:StateName/5
 	    is immediately enqueued as the newest received.
 	    Also note that it is not possible nor needed
 	    to cancel this timeout using the
-	    <seealso marker="#type-state_operation">
-	      <c>state_operation()</c>
+	    <seealso marker="#type-transition_action">
+	      <c>transition_action()</c>
 	    </seealso> <c>cancel_timer</c>.
 	    This timeout is cancelled automatically by any event.
 	  </item>
@@ -473,17 +474,20 @@ erlang:'!'            -----> Module:StateName/5
       </desc>
     </datatype>
     <datatype>
-      <name name="state_operation" />
+      <name name="transition_action" />
       <desc>
-	<p>The state operations are executed in the containing
-	 list order.  This matters for <c>next_event</c> where
-	 the last one in the list will become the next event to present
-	 to the state functions.  Regarding the other operations
-	 it is only for <c>remove_event</c> with
-	 <c><anno>EventPredicate</anno></c>
-	 and for <c>reply_operation()</c> that the order may matter.
+	<p>The state transition actions are executed
+	  in the containing list order.  This matters
+	  for <c>next_event</c> where the last one in the list
+	  will become the next event to present
+	  to the state functions.  Regarding the other actions
+	  it is only for <c>remove_event</c> with
+	  <c><anno>EventPredicate</anno></c>
+	  and for <c>reply_action()</c> that the order may matter.
 	</p>
 	<taglist>
+	  <tag><c>reply_action()</c></tag>
+	  <item>Reply to a calling client.</item>
 	  <tag><c>next_event</c></tag>
 	  <item>Insert the given <c><anno>EventType</anno></c>
 	    and <c><anno>EventContent</anno></c> the next to process.
@@ -518,7 +522,7 @@ erlang:'!'            -----> Module:StateName/5
 	      <c>demonitor/2</c>
 	    </seealso> with <c><anno>MonitorRef</anno></c>.
 	  </item>
-	  <tag><c>{unlink,<anno>Id</anno>}</c></tag>
+	  <tag><c>unlink</c></tag>
 	  <item>Like <c>{cancel_timer,_}</c> above but for
 	    <seealso marker="erts:erlang#unlink/1">
 	      <c>unlink/1</c>
@@ -528,7 +532,7 @@ erlang:'!'            -----> Module:StateName/5
       </desc>
     </datatype>
     <datatype>
-      <name name="reply_operation" />
+      <name name="reply_action" />
       <desc>
 	<p>Reply to a client that called
 	  <seealso marker="#call/2"><c>call/2</c></seealso>.
@@ -550,26 +554,26 @@ erlang:'!'            -----> Module:StateName/5
 	    <seealso marker="#Module:terminate/3">
 	      <c>Module:terminate/3</c>
 	    </seealso> with <c>Reason</c> and
-	    <c><anno>NewStateData</anno></c>, if given.
+	    <c><anno>NewData</anno></c>, if given.
 	  </item>
 	  <tag><c>next_state</c></tag>
 	  <item>The <c>gen_statem</c> will do a state transition to
 	    <c><anno>NewState</anno></c>
 	    (which may be the same as the current state),
-	    set <c><anno>NewStateData</anno></c>
-	    and execute all <c><anno>StateOps</anno></c>
+	    set <c><anno>NewData</anno></c>
+	    and execute all <c><anno>Ops</anno></c>
 	  </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>NewStateData</anno></c>
-	    and execute all <c><anno>StateOps</anno></c>
+	    set <c><anno>NewData</anno></c>
+	    and execute all <c><anno>Ops</anno></c>
 	  </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 state data,
-	    and execute all <c><anno>StateOps</anno></c>
+	    keep the current server data,
+	    and execute all <c><anno>Ops</anno></c>
 	  </item>
 	</taglist>
       </desc>
@@ -614,7 +618,7 @@ erlang:'!'            -----> Module:StateName/5
 	  </seealso>.
 	</p>
         <p>If the option <c>{timeout,Time}</c> is present in
-	  <c><anno>Options</anno></c>, the <c>gen_statem</c>
+	  <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">
@@ -623,15 +627,14 @@ erlang:'!'            -----> Module:StateName/5
 	</p>
         <p>If the option
 	  <seealso marker="#type-debug_opt"><c>{debug,Dbgs}</c></seealso>
-	  is present in <c><anno>Options</anno></c>, debugging through
+	  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,SOpts}</c> is present in
-	  <c><anno>Options</anno></c>, <c>SOpts</c> will be passed
-	  as option list to the <c>spawn_opt</c> BIF
-	  which is used to
-          <seealso marker="erts:erlang#spawn_opt/2">spawn</seealso>
-	  the <c>gen_statem</c>.
+        <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">spawn_opt/2</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
@@ -760,7 +763,9 @@ erlang:'!'            -----> Module:StateName/5
 	  <seealso marker="#state_function">state function</seealso>
 	  returns with
 	  <c>{reply,Client,<anno>Reply</anno>}</c> as one
-	  <seealso marker="#type-state_op"><c>state_op()</c></seealso>,
+	  <seealso marker="#type-transition_op">
+	    <c>transition_op()</c>
+	  </seealso>,
 	  and that <c><anno>Reply</anno></c> becomes the return value
 	  of this function.
 	</p>
@@ -823,8 +828,8 @@ erlang:'!'            -----> Module:StateName/5
 	  <seealso marker="#state_function">state function</seealso>.
 	  <c><anno>Client</anno></c> and <c><anno>Reply</anno></c>
 	  can also be specified using a
-	  <seealso marker="#type-reply_operation">
-	    <c>reply_operation()</c>
+	  <seealso marker="#type-reply_action">
+	    <c>reply_action()</c>
 	  </seealso> and multiple replies with a list of them.
 	</p>
 	<note>
@@ -852,20 +857,20 @@ erlang:'!'            -----> Module:StateName/5
       <name name="enter_loop" arity="5" />
       <fsummary>Enter the <c>gen_statem</c> receive loop</fsummary>
       <desc>
-	<p>If <c><anno>Server_or_StateOps</anno></c> is a <c>list()</c>
+	<p>If <c><anno>Server_or_Ops</anno></c> is a <c>list()</c>
 	  the same as
 	  <seealso marker="#enter_loop/6"><c>enter_loop/6</c></seealso>
 	  except that no
 	  <seealso marker="#type-server_name">
 	    <c>server_name()</c>
 	  </seealso> must have been registered and
-	  <c>StateOps = <anno>Server_or_StateOps</anno></c>.
+	  <c>Ops = <anno>Server_or_Ops</anno></c>.
 	</p>
 	<p>Otherwise the same as
 	  <seealso marker="#enter_loop/6"><c>enter_loop/6</c></seealso>
 	  with
-	  <c>Server = <anno>Server_or_StateOps</anno></c> and
-	  <c>StateOps = []</c>.
+	  <c>Server = <anno>Server_or_Ops</anno></c> and
+	  <c>Ops = []</c>.
 	</p>
       </desc>
     </func>
@@ -887,7 +892,7 @@ erlang:'!'            -----> Module:StateName/5
           procedure is needed than
 	  the <c>gen_statem</c> behaviour provides.
 	</p>
-        <p><c><anno>Module</anno></c>, <c><anno>Options</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">
@@ -898,8 +903,8 @@ erlang:'!'            -----> Module:StateName/5
 	    <c>server_name()</c>
 	  </seealso> name must have been registered accordingly
 	  <em>before</em> this function is called.</p>
-        <p><c><anno>State</anno></c>, <c><anno>StateData</anno></c>
-	  and <c><anno>StateOps</anno></c>
+        <p><c><anno>State</anno></c>, <c><anno>Data</anno></c>
+	  and <c><anno>Ops</anno></c>
 	  have the same meanings as in the return value of
           <seealso marker="#Module:init/1">Module:init/1</seealso>.
           Also, the callback module <c><anno>Module</anno></c>
@@ -933,15 +938,14 @@ erlang:'!'            -----> Module:StateName/5
       <fsummary>Initialize process and internal state</fsummary>
       <type>
         <v>Args = term()</v>
-        <v>Result = {ok,State,StateData}</v>
-	<v>&nbsp;| {ok,State,StateData,StateOps}</v>
+        <v>Result = {ok,State,Data}</v>
+	<v>&nbsp;| {ok,State,Data,Ops}</v>
         <v>&nbsp;| {stop,Reason} | ignore</v>
 	<v>State = <seealso marker="#type-state">state()</seealso></v>
-	<v>StateData =
-	  <seealso marker="#type-state_data">state_data()</seealso>
+	<v>Data = <seealso marker="#type-data">data()</seealso>
 	</v>
-	<v>StateOps =
-	  [<seealso marker="#type-state_op">state_op()</seealso>
+	<v>Ops =
+	  [<seealso marker="#type-transition_op">transition_op()</seealso>
 	   | <seealso marker="#type-init_option">init_option()</seealso>]
 	</v>
 	<v>Reason = term()</v>
@@ -953,17 +957,17 @@ erlang:'!'            -----> Module:StateName/5
 	  or
           <seealso marker="#start/3">start/3,4</seealso>,
           this function is called by the new process to initialize
-	  the implementation loop data.
+	  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>{ok,State,StateData}</c> or
-	  <c>{ok,State,StateData,StateOps}</c>.
+          return <c>{ok,State,Data}</c> or
+	  <c>{ok,State,Data,Ops}</c>.
 	  <c>State</c> is the <seealso marker="#type-state">state</seealso>
 	  of the <c>gen_statem</c>.
 	</p>
-	<p>The <seealso marker="#type-state_op"><c>StateOps</c></seealso>
+	<p>The <seealso marker="#type-transition_op"><c>Ops</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>.
@@ -978,15 +982,19 @@ erlang:'!'            -----> Module:StateName/5
 	  or <c>ignore</c>. See
           <seealso marker="#start_link/3">start_link/3,4</seealso>.
 	</p>
+	<p>This function may use
+	  <seealso marker="erts:erlang#throw/1"><c>throw</c></seealso>,
+	  to return its value.
+	</p>
       </desc>
     </func>
 
     <func>
       <name>Module:StateName(EventType, EventContent,
-        PrevStateName, StateName, StateData) -> Result
+        PrevStateName, StateName, Data) -> Result
       </name>
       <name>Module:handle_event(EventType, EventContent,
-        PrevState, State, StateData) -> Result
+        PrevState, State, Data) -> Result
       </name>
       <fsummary>Handle an event</fsummary>
       <type>
@@ -1003,8 +1011,8 @@ erlang:'!'            -----> Module:StateName/5
 	<v>PrevState = State =
 	  <seealso marker="#type-state">state()</seealso>
 	</v>
-	<v>StateData = NewStateData =
-	  <seealso marker="#type-state_data">state_data()</seealso>
+	<v>Data = NewData =
+	  <seealso marker="#type-data">data()</seealso>
 	</v>
 	<v>Result =
 	  <seealso marker="#type-state_callback_result">
@@ -1029,8 +1037,8 @@ erlang:'!'            -----> Module:StateName/5
 	  from this or from any other
 	  <seealso marker="#state_function">state function</seealso>
 	  by returning with <c>{reply,Client,Reply}</c> in
-	  <seealso marker="#type-state_op">StateOps</seealso>, in
-	  <seealso marker="#type-reply_operation">Replies</seealso>
+	  <seealso marker="#type-transition_op">Ops</seealso>, in
+	  <seealso marker="#type-reply_action">Replies</seealso>
 	  or by calling
 	  <seealso marker="#reply/2">
 	    <c>reply(Client, Reply)</c>
@@ -1050,23 +1058,25 @@ erlang:'!'            -----> Module:StateName/5
 	  does not match equal (<c>=/=</c>) to the current state
 	  all postponed events will be retried in the new state.
 	</p>
-	<p>See <seealso marker="#type-state_op">state_op()</seealso>
-	  for options that can be set and operations that can be done
+	<p>See
+	  <seealso marker="#type-transition_op">transition_op()</seealso>
+	  for options that can be set and actions that can be done
 	  by <c>gen_statem</c> after returning from this function.
 	</p>
+	<p>These functions may use
+	  <seealso marker="erts:erlang#throw/1"><c>throw</c></seealso>,
+	  to return its value.
+	</p>
       </desc>
     </func>
 
     <func>
-      <name>Module:terminate(Reason, State, StateData) -> Ignored</name>
+      <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>StateData =
-	  <seealso marker="#type-state_data">
-	    state_data()
-	  </seealso>
+	<v>Data = <seealso marker="#type-data">data()</seealso>
 	</v>
 	<v>Ignored = term()</v>
       </type>
@@ -1085,7 +1095,7 @@ erlang:'!'            -----> Module:StateName/5
 	  is terminating.
           If it is because another callback function has returned a
           stop tuple <c>{stop,Reason}</c> in
-	  <seealso marker="#type-state_op">StateOps</seealso>,
+	  <seealso marker="#type-transition_op">Ops</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>
@@ -1118,11 +1128,15 @@ erlang:'!'            -----> Module:StateName/5
 	    error_logger:format/2
 	  </seealso>.
 	</p>
+	<p>This function may use
+	  <seealso marker="erts:erlang#throw/1"><c>throw</c></seealso>,
+	  to return its value.
+	</p>
       </desc>
     </func>
 
     <func>
-      <name>Module:code_change(OldVsn, OldState, OldStateData, Extra) ->
+      <name>Module:code_change(OldVsn, OldState, OldData, Extra) ->
         Result
       </name>
       <fsummary>Update the internal state during upgrade/downgrade</fsummary>
@@ -1131,12 +1145,12 @@ erlang:'!'            -----> Module:StateName/5
         <v>&nbsp;&nbsp;Vsn = term()</v>
         <v>OldState = NewState = term()</v>
         <v>Extra = term()</v>
-	<v>Result = {ok,{NewState,NewStateData}} | Reason</v>
+	<v>Result = {ok,{NewState,NewData}} | Reason</v>
 	<v>OldState = NewState =
 	  <seealso marker="#type-state">state()</seealso>
 	</v>
-	<v>OldStateData = NewStateData =
-	  <seealso marker="#type-state_data">state_data()</seealso>
+	<v>OldData = NewData =
+	  <seealso marker="#type-data">data()</seealso>
 	</v>
 	<v>Reason = term()</v>
       </type>
@@ -1158,7 +1172,7 @@ erlang:'!'            -----> Module:StateName/5
           <c>Module</c>. If no such attribute is defined, the version
           is the checksum of the BEAM file.
 	</p>
-        <p><c>OldState</c> and <c>OldStateData</c> is the internal state
+        <p><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>
@@ -1166,15 +1180,19 @@ erlang:'!'            -----> Module:StateName/5
 	</p>
         <p>If successful, the function shall return the updated
           internal state in an
-	  <c>{ok,{NewState,NewStateData}}</c> tuple.
+	  <c>{ok,{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>
       </desc>
+	<p>This function may use
+	  <seealso marker="erts:erlang#throw/1"><c>throw</c></seealso>,
+	  to return its value.
+	</p>
     </func>
 
     <func>
-      <name>Module:format_status(Opt, [PDict,State,StateData]) ->
+      <name>Module:format_status(Opt, [PDict,State,Data]) ->
         Status
       </name>
       <fsummary>Optional function for providing a term describing the
@@ -1185,8 +1203,8 @@ erlang:'!'            -----> Module:StateName/5
 	<v>State =
 	  <seealso marker="#type-state">state()</seealso>
 	</v>
-	<v>StateData =
-	  <seealso marker="#type-state_data">state_data()</seealso>
+	<v>Data =
+	  <seealso marker="#type-data">data()</seealso>
 	</v>
 	<v>Key = term()</v>
 	<v>Value = term()</v>
@@ -1197,7 +1215,8 @@ erlang:'!'            -----> Module:StateName/5
           <p>This callback is optional, so callback modules need not
             export it. The <c>gen_statem</c> module provides a default
             implementation of this function that returns the callback
-            module state.
+            module state and data.  The default function will also
+	    be used if this callback fails.
 	  </p>
         </note>
         <p>This function is called by a <c>gen_statem</c> process when:</p>
@@ -1229,6 +1248,9 @@ erlang:'!'            -----> Module:StateName/5
         <p><seealso marker="#type-state"><c>State</c></seealso>
 	  is the internal state of the <c>gen_statem</c>.
 	</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
           the <c>gen_statem</c>. There are no restrictions on the
@@ -1250,6 +1272,10 @@ erlang:'!'            -----> Module:StateName/5
           state representations to avoid having large state terms
           printed in logfiles.
 	</p>
+	<p>This function may use
+	  <seealso marker="erts:erlang#throw/1"><c>throw</c></seealso>,
+	  to return its value.
+	</p>
       </desc>
     </func>
 
diff --git a/lib/stdlib/src/gen_statem.erl b/lib/stdlib/src/gen_statem.erl
index 8aa8afd091..1ca2e1009c 100644
--- a/lib/stdlib/src/gen_statem.erl
+++ b/lib/stdlib/src/gen_statem.erl
@@ -57,7 +57,7 @@
 	state_name() | % For state callback function StateName/5
 	term(). % For state callback function handle_event/5
 -type state_name() :: atom().
--type state_data() :: term().
+-type data() :: term().
 -type event_type() ::
 	{'call',Client :: client()} | 'cast' |
 	'info' | 'timeout' | 'internal'.
@@ -66,17 +66,18 @@
 -type init_option() ::
 	{'callback_mode', callback_mode()}.
 -type callback_mode() :: 'state_functions' | 'handle_event_function'.
--type state_op() ::
-	%% First NewState and NewStateData are set,
-	%% then all state_operations() are executed in order of
+-type transition_op() ::
+	%% First NewState and NewData are set,
+	%% then all transition_action()s are executed in order of
 	%% apperance. Postponing the current event is performed
-	%% (iff state_option() 'postpone' is 'true').
+	%% (iff transition_option() 'postpone' is 'true').
 	%% Lastly pending events are processed or if there are
 	%% no pending events the server goes into receive
-	%% or hibernate (iff state_option() 'hibernate' is 'true')
-	state_option() | state_operation().
--type state_option() ::
-	%% The first of each kind in the state_op() list takes precedence
+	%% or hibernate (iff transition_option() 'hibernate' is 'true')
+	transition_option() | transition_action().
+-type transition_option() ::
+	%% The last of each kind in the transition_op()
+	%% list takes precedence
 	'postpone' |  % Postpone the current event to a different (=/=) state
 	{'postpone', Postpone :: boolean()} |
 	'hibernate' | % Hibernate the server instead of going into receive
@@ -84,10 +85,10 @@
 	(Timeout :: timeout()) | % {timeout,Timeout}
 	{'timeout', % Generate a ('timeout', Msg, ...) event after Time
 	 Time :: timeout(), Msg :: term()}.
--type state_operation() ::
+-type transition_action() ::
 	%% These can occur multiple times and are executed in order
-	%% of appearence in the state_op() list
-	reply_operation() |
+	%% of appearence in the transition_op() list
+	reply_action() |
 	{'next_event', % Insert event as the next to handle
 	 EventType :: event_type(),
 	 EventContent :: term()} |
@@ -101,7 +102,7 @@
 	 MonitorRef :: reference()} |
 	{'unlink', % Unlink and clean up mess(ages)
 	 Id :: pid() | port()}.
--type reply_operation() ::
+-type reply_action() ::
 	{'reply', % Reply to a client
 	 Client :: client(), Reply :: term()}.
 -type state_callback_result() ::
@@ -109,34 +110,34 @@
      Reason :: term()} |
     {'stop', % Stop the server
      Reason :: term(),
-     NewStateData :: state_data()} |
+     NewData :: data()} |
     {'stop', % Stop the server
      Reason :: term(),
-     Replies :: [reply_operation()] | reply_operation(),
-     NewStateData :: state_data()} |
-    {'next_state', % {next_state,NewState,NewStateData,[]}
+     Replies :: [reply_action()] | reply_action(),
+     NewData :: data()} |
+    {'next_state', % {next_state,NewState,NewData,[]}
      NewState :: state(),
-     NewStateData :: state_data()} |
+     NewData :: data()} |
     {'next_state', % State transition, maybe to the same state
      NewState :: state(),
-     NewStateData :: state_data(),
-     StateOps :: [state_op()] | state_op()} |
-    {'keep_state', % {keep_state,NewStateData,[]}
-     NewStateData :: state_data()} |
+     NewData :: data(),
+     Ops :: [transition_op()] | transition_op()} |
+    {'keep_state', % {keep_state,NewData,[]}
+     NewData :: data()} |
     {'keep_state',
-     NewStateData :: state_data(),
-     StateOps :: [state_op()] | state_op()} |
+     NewData :: data(),
+     Ops :: [transition_op()] | transition_op()} |
     {'keep_state_and_data'} | % {keep_state_and_data,[]}
     {'keep_state_and_data',
-     StateOps :: [state_op()] | state_op()}.
+     Ops :: [transition_op()] | transition_op()}.
 
 %% The state machine init function.  It is called only once and
 %% the server is not running until this function has returned
 %% an {ok, ...} tuple.  Thereafter the state callbacks are called
 %% for all events to this server.
 -callback init(Args :: term()) ->
-    {'ok', state(), state_data()} |
-    {'ok', state(), state_data(), [state_op()|init_option()]} |
+    {'ok', state(), data()} |
+    {'ok', state(), data(), [transition_op()|init_option()]} |
     'ignore' |
     {'stop', Reason :: term()}.
 
@@ -152,7 +153,7 @@
 	    EventContent :: term(),
 	    PrevStateName :: state_name() | reference(),
 	    StateName :: state_name(), % Current state
-	    StateData :: state_data()) ->
+	    Data :: data()) ->
     state_callback_result().
 %%
 %% Callback for callback_mode =:= handle_event_function.
@@ -164,7 +165,7 @@
 	    EventContent :: term(),
 	    PrevState :: state(),
 	    State :: state(), % Current state
-	    StateData :: state_data()) ->
+	    Data :: data()) ->
     state_callback_result().
 
 %% Clean up before the server terminates.
@@ -172,7 +173,7 @@
 	    Reason :: 'normal' | 'shutdown' | {'shutdown', term()}
 		    | term(),
 	    State :: state(),
-	    StateData :: state_data()) ->
+	    Data :: data()) ->
     any().
 
 %% Note that the new code can expect to get an OldState from
@@ -181,9 +182,9 @@
 -callback code_change(
 	    OldVsn :: term() | {'down', term()},
 	    OldState :: state(),
-	    OldStateData :: state_data(),
+	    OldData :: data(),
 	    Extra :: term()) ->
-    {ok, {NewState :: state(), NewStateData :: state_data()}}.
+    {ok, {NewState :: state(), NewData :: data()}}.
 
 %% Format the callback module state in some sensible that is
 %% often condensed way.  For StatusOption =:= 'normal' the perferred
@@ -193,7 +194,7 @@
 	    StatusOption,
 	    [ [{Key :: term(), Value :: term()}] |
 	      state() |
-	      state_data()]) ->
+	      data()]) ->
     Status :: term() when
       StatusOption :: 'normal' | 'terminate'.
 
@@ -264,38 +265,38 @@ event_type(Type) ->
 -type start_opt() ::
 	debug_opt()
       | {'timeout', Time :: timeout()}
-      | {'spawn_opt', SOpts :: [proc_lib:spawn_option()]}.
+      | {'spawn_opt', [proc_lib:spawn_option()]}.
 -type start_ret() ::  {'ok', pid()} | 'ignore' | {'error', term()}.
 
 
 
 %% Start a state machine
 -spec start(
-	Module :: module(), Args :: term(), Options :: [start_opt()]) ->
+	Module :: module(), Args :: term(), Opts :: [start_opt()]) ->
 		   start_ret().
-start(Module, Args, Options) ->
-    gen:start(?MODULE, nolink, Module, Args, Options).
+start(Module, Args, Opts) ->
+    gen:start(?MODULE, nolink, Module, Args, Opts).
 %%
 -spec start(
 	ServerName :: server_name(),
-	Module :: module(), Args :: term(), Options :: [start_opt()]) ->
+	Module :: module(), Args :: term(), Opts :: [start_opt()]) ->
 		   start_ret().
-start(ServerName, Module, Args, Options) ->
-    gen:start(?MODULE, nolink, ServerName, Module, Args, Options).
+start(ServerName, Module, Args, Opts) ->
+    gen:start(?MODULE, nolink, ServerName, Module, Args, Opts).
 
 %% Start and link to a state machine
 -spec start_link(
-	Module :: module(), Args :: term(), Options :: [start_opt()]) ->
+	Module :: module(), Args :: term(), Opts :: [start_opt()]) ->
 		   start_ret().
-start_link(Module, Args, Options) ->
-    gen:start(?MODULE, link, Module, Args, Options).
+start_link(Module, Args, Opts) ->
+    gen:start(?MODULE, link, Module, Args, Opts).
 %%
 -spec start_link(
 	ServerName :: server_name(),
-	Module :: module(), Args :: term(), Options :: [start_opt()]) ->
+	Module :: module(), Args :: term(), Opts :: [start_opt()]) ->
 		   start_ret().
-start_link(ServerName, Module, Args, Options) ->
-    gen:start(?MODULE, link, ServerName, Module, Args, Options).
+start_link(ServerName, Module, Args, Opts) ->
+    gen:start(?MODULE, link, ServerName, Module, Args, Opts).
 
 %% Stop a state machine
 -spec stop(ServerRef :: server_ref()) -> ok.
@@ -389,7 +390,7 @@ call(ServerRef, Request, Timeout) ->
     end.
 
 %% Reply from a state machine callback to whom awaits in call/2
--spec reply([reply_operation()] | reply_operation()) -> ok.
+-spec reply([reply_action()] | reply_action()) -> ok.
 reply({reply,{_To,_Tag}=Client,Reply}) ->
     reply(Client, Reply);
 reply(Replies) when is_list(Replies) ->
@@ -411,39 +412,39 @@ reply({To,Tag}, Reply) ->
 %% started by proc_lib into a state machine using
 %% the same arguments as you would have returned from init/1
 -spec enter_loop(
-	Module :: module(), Options :: [debug_opt()],
-	State :: state(), StateData :: state_data()) ->
+	Module :: module(), Opts :: [debug_opt()],
+	State :: state(), Data :: data()) ->
 			no_return().
-enter_loop(Module, Options, State, StateData) ->
-    enter_loop(Module, Options, State, StateData, self()).
+enter_loop(Module, Opts, State, Data) ->
+    enter_loop(Module, Opts, State, Data, self()).
 %%
 -spec enter_loop(
-	Module :: module(), Options :: [debug_opt()],
-	State :: state(), StateData :: state_data(),
-	Server_or_StateOps ::
-	  server_name() | pid() | [state_op()|init_option()]) ->
+	Module :: module(), Opts :: [debug_opt()],
+	State :: state(), Data :: data(),
+	Server_or_Ops ::
+	  server_name() | pid() | [transition_op()|init_option()]) ->
 			no_return().
-enter_loop(Module, Options, State, StateData, Server_or_StateOps) ->
+enter_loop(Module, Opts, State, Data, Server_or_Ops) ->
     if
-	is_list(Server_or_StateOps) ->
+	is_list(Server_or_Ops) ->
 	    enter_loop(
-	      Module, Options, State, StateData,
-	      self(), Server_or_StateOps);
+	      Module, Opts, State, Data,
+	      self(), Server_or_Ops);
 	true ->
 	    enter_loop(
-	      Module, Options, State, StateData,
-	      Server_or_StateOps, [])
+	      Module, Opts, State, Data,
+	      Server_or_Ops, [])
     end.
 %%
 -spec enter_loop(
-	Module :: module(), Options :: [debug_opt()],
-	State :: state(), StateData :: state_data(),
+	Module :: module(), Opts :: [debug_opt()],
+	State :: state(), Data :: data(),
 	Server :: server_name() | pid(),
-	StateOps :: [state_op()|init_option()]) ->
+	Ops :: [transition_op()|init_option()]) ->
 			no_return().
-enter_loop(Module, Options, State, StateData, Server, StateOps) ->
+enter_loop(Module, Opts, State, Data, Server, Ops) ->
     Parent = gen:get_parent(),
-    enter(Module, Options, State, StateData, Server, StateOps, Parent).
+    enter(Module, Opts, State, Data, Server, Ops, Parent).
 
 %%---------------------------------------------------------------------------
 %% API helpers
@@ -465,29 +466,29 @@ do_send(Proc, Msg) ->
     end.
 
 %% Here init_it and all enter_loop functions converge
-enter(Module, Options, State, StateData, Server, InitOps, Parent) ->
+enter(Module, Opts, State, Data, Server, InitOps, Parent) ->
     Name = gen:get_proc_name(Server),
-    Debug = gen:debug_options(Name, Options),
+    Debug = gen:debug_options(Name, Opts),
     PrevState = undefined,
     S = #{
       callback_mode => state_functions,
       module => Module,
       name => Name,
       prev_state => PrevState,
-      state => PrevState, % Will be discarded by loop_event_state_ops
-      state_data => StateData,
+      state => PrevState, % Will be discarded by loop_event_transition_ops
+      data => Data,
       timer => undefined,
       postponed => [],
       hibernate => false},
     case collect_init_options(InitOps) of
-	{CallbackMode,StateOps} ->
-	    loop_event_state_ops(
+	{CallbackMode,Ops} ->
+	    loop_event_transition_ops(
 	      Parent, Debug,
 	      S#{callback_mode := CallbackMode},
 	      [],
 	      {event,undefined}, % Will be discarded by {postpone,false}
-	      PrevState, State, StateData,
-	      StateOps++[{postpone,false}]);
+	      PrevState, State, Data,
+	      Ops++[{postpone,false}]);
 	[Reason] ->
 	    ?TERMINATE(Reason, Debug, S, [])
     end.
@@ -495,13 +496,13 @@ enter(Module, Options, State, StateData, Server, InitOps, Parent) ->
 %%%==========================================================================
 %%%  gen callbacks
 
-init_it(Starter, Parent, ServerRef, Module, Args, Options) ->
+init_it(Starter, Parent, ServerRef, Module, Args, Opts) ->
     try Module:init(Args) of
 	Result ->
-	    init_result(Starter, Parent, ServerRef, Module, Result, Options)
+	    init_result(Starter, Parent, ServerRef, Module, Result, Opts)
     catch
 	Result ->
-	    init_result(Starter, Parent, ServerRef, Module, Result, Options);
+	    init_result(Starter, Parent, ServerRef, Module, Result, Opts);
 	Class:Reason ->
 	    gen:unregister_name(ServerRef),
 	    proc_lib:init_ack(Starter, {error,Reason}),
@@ -511,18 +512,14 @@ init_it(Starter, Parent, ServerRef, Module, Args, Options) ->
 %%---------------------------------------------------------------------------
 %% gen callbacks helpers
 
-init_result(Starter, Parent, ServerRef, Module, Result, Options) ->
+init_result(Starter, Parent, ServerRef, Module, Result, Opts) ->
     case Result of
-	{ok,State,StateData} ->
+	{ok,State,Data} ->
 	    proc_lib:init_ack(Starter, {ok,self()}),
-	    enter(
-	      Module, Options, State, StateData, ServerRef,
-	      [], Parent);
-	{ok,State,StateData,StateOps} ->
+	    enter(Module, Opts, State, Data, ServerRef, [], Parent);
+	{ok,State,Data,Ops} ->
 	    proc_lib:init_ack(Starter, {ok,self()}),
-	    enter(
-	      Module, Options, State, StateData, ServerRef,
-	      StateOps, Parent);
+	    enter(Module, Opts, State, Data, ServerRef, Ops, Parent);
 	{stop,Reason} ->
 	    gen:unregister_name(ServerRef),
 	    proc_lib:init_ack(Starter, {error,Reason}),
@@ -549,32 +546,32 @@ system_terminate(Reason, _Parent, Debug, S) ->
 system_code_change(
   #{module := Module,
     state := State,
-    state_data := StateData} = S,
+    data := Data} = S,
   _Mod, OldVsn, Extra) ->
     case
-	try Module:code_change(OldVsn, State, StateData, Extra)
+	try Module:code_change(OldVsn, State, Data, Extra)
 	catch
 	    Result -> Result
 	end
     of
-	{ok,{NewState,NewStateData}} ->
+	{ok,{NewState,NewData}} ->
 	    {ok,
 	     S#{
 	       state := NewState,
-	       state_data := NewStateData}};
+	       data := NewData}};
 	Error ->
 	    Error
     end.
 
-system_get_state(#{state := State, state_data := StateData}) ->
-    {ok,{State,StateData}}.
+system_get_state(#{state := State, data := Data}) ->
+    {ok,{State,Data}}.
 
 system_replace_state(
   StateFun,
   #{state := State,
-    state_data := StateData} = S) ->
-    {NewState,NewStateData} = Result = StateFun({State,StateData}),
-    {ok,Result,S#{state := NewState, state_data := NewStateData}}.
+    data := Data} = S) ->
+    {NewState,NewData} = Result = StateFun({State,Data}),
+    {ok,Result,S#{state := NewState, data := NewData}}.
 
 format_status(
   Opt,
@@ -642,7 +639,7 @@ wakeup_from_hibernate(Parent, Debug, S) ->
     loop_receive(Parent, Debug, S).
 
 %%%==========================================================================
-%%% STate Machine engine implementation of proc_lib/gen server
+%%% State Machine engine implementation of proc_lib/gen server
 
 %% Server loop, consists of all loop* functions
 %% and some detours through sys and proc_lib
@@ -717,7 +714,7 @@ loop_events(
     module := Module,
     prev_state := PrevState,
     state := State,
-    state_data := StateData} = S,
+    data := Data} = S,
   [{Type,Content} = Event|Events] = Q, Timer) ->
     _ = (Timer =/= undefined) andalso
 	cancel_timer(Timer),
@@ -728,7 +725,7 @@ loop_events(
 	    state_functions ->
 		State
 	end,
-    try Module:Func(Type, Content, PrevState, State, StateData) of
+    try Module:Func(Type, Content, PrevState, State, Data) of
 	Result ->
 	    loop_event_result(
 	      Parent, Debug, S, Events, Event, Result)
@@ -741,7 +738,7 @@ loop_events(
 	    %% of calling a nonexistent state function
 	    case erlang:get_stacktrace() of
 		[{Module,Func,
-		  [Type,Content,PrevState,State,StateData]=Args,
+		  [Type,Content,PrevState,State,Data]=Args,
 		  _}
 		 |Stacktrace] ->
 		    terminate(
@@ -760,18 +757,18 @@ loop_events(
 %% Interpret all callback return value variants
 loop_event_result(
   Parent, Debug,
-  #{state := State, state_data := StateData} = S,
+  #{state := State, data := Data} = S,
   Events, Event, Result) ->
     case Result of
 	{stop,Reason} ->
 	    ?TERMINATE(Reason, Debug, S, [Event|Events]);
-	{stop,Reason,NewStateData} ->
+	{stop,Reason,NewData} ->
 	    ?TERMINATE(
 	      Reason, Debug,
-	      S#{state_data := NewStateData},
+	      S#{data := NewData},
 	      [Event|Events]);
-	{stop,Reason,Reply,NewStateData} ->
-	    NewS = S#{state_data := NewStateData},
+	{stop,Reason,Reply,NewData} ->
+	    NewS = S#{data := NewData},
 	    Q = [Event|Events],
 	    Replies =
 		if
@@ -785,43 +782,43 @@ loop_event_result(
 		  exit, Reason, ?STACKTRACE(), Debug, NewS, Q, Replies),
 	    %% Since we got back here Replies was bad
 	    ?TERMINATE(
-	      {bad_return_value,{stop,Reason,BadReplies,NewStateData}},
+	      {bad_return_value,{stop,Reason,BadReplies,NewData}},
 	      Debug, NewS, Q);
-	{next_state,NewState,NewStateData} ->
-	    loop_event_state_ops(
+	{next_state,NewState,NewData} ->
+	    loop_event_transition_ops(
 	      Parent, Debug, S, Events, Event,
-	      State, NewState, NewStateData, []);
-	{next_state,NewState,NewStateData,StateOps}
-	  when is_list(StateOps) ->
-	    loop_event_state_ops(
+	      State, NewState, NewData, []);
+	{next_state,NewState,NewData,Ops}
+	  when is_list(Ops) ->
+	    loop_event_transition_ops(
 	      Parent, Debug, S, Events, Event,
-	      State, NewState, NewStateData, StateOps);
-	{keep_state,NewStateData} ->
-	    loop_event_state_ops(
+	      State, NewState, NewData, Ops);
+	{keep_state,NewData} ->
+	    loop_event_transition_ops(
 	      Parent, Debug, S, Events, Event,
-	      State, State, NewStateData, []);
-	{keep_state,NewStateData,StateOps} ->
-	    loop_event_state_ops(
+	      State, State, NewData, []);
+	{keep_state,NewData,Ops} ->
+	    loop_event_transition_ops(
 	      Parent, Debug, S, Events, Event,
-	      State, State, NewStateData, StateOps);
+	      State, State, NewData, Ops);
 	{keep_state_and_data} ->
-	    loop_event_state_ops(
+	    loop_event_transition_ops(
 	      Parent, Debug, S, Events, Event,
-	      State, State, StateData, []);
-	{keep_state_and_data,StateOps} ->
-	    loop_event_state_ops(
+	      State, State, Data, []);
+	{keep_state_and_data,Ops} ->
+	    loop_event_transition_ops(
 	      Parent, Debug, S, Events, Event,
-	      State, State, StateData, StateOps);
+	      State, State, Data, Ops);
 	_ ->
 	    ?TERMINATE(
 	      {bad_return_value,Result}, Debug, S, [Event|Events])
     end.
 
-loop_event_state_ops(
+loop_event_transition_ops(
   Parent, Debug0, #{postponed := P0} = S, Events, Event,
-  State, NewState, NewStateData, StateOps) ->
-    case collect_state_options(StateOps) of
-	{Postpone,Hibernate,Timeout,Operations} ->
+  State, NewState, NewData, Ops) ->
+    case collect_transition_options(Ops) of
+	{Postpone,Hibernate,Timeout,Actions} ->
 	    P1 = % Move current event to postponed if Postpone
 		case Postpone of
 		    true ->
@@ -837,8 +834,8 @@ loop_event_state_ops(
 			{lists:reverse(P1, Events),[]}
 		end,
 	    %%
-	    case process_state_operations(
-		   Operations, Debug0, S, Q2, P2) of
+	    case process_transition_actions(
+		   Actions, Debug0, S, Q2, P2) of
 		{Debug,Q3,P} ->
 		    NewDebug =
 			sys_debug(
@@ -865,7 +862,7 @@ loop_event_state_ops(
 		      S#{
 			prev_state := State,
 			state := NewState,
-			state_data := NewStateData,
+			data := NewData,
 			timer := Timer,
 			hibernate := Hibernate,
 			postponed := P},
@@ -892,92 +889,96 @@ collect_init_options(InitOps) ->
 	    collect_init_options([InitOps], state_functions, [])
     end.
 %% Keep the last of each kind
-collect_init_options([], CallbackMode, StateOps) ->
-    {CallbackMode,lists:reverse(StateOps)};
-collect_init_options([InitOp|InitOps] = IOIOs, CallbackMode, StateOps) ->
+collect_init_options([], CallbackMode, Ops) ->
+    {CallbackMode,lists:reverse(Ops)};
+collect_init_options(
+  [InitOp|InitOps] = AllInitOps, CallbackMode, Ops) ->
     case InitOp of
 	{callback_mode,Mode}
 	  when Mode =:= state_functions;
 	       Mode =:= handle_event_function ->
-	    collect_init_options(InitOps, Mode, StateOps);
+	    collect_init_options(InitOps, Mode, Ops);
 	{callback_mode,_} ->
-	    [{bad_init_ops,IOIOs}];
-	_ -> % Collect others as StateOps
+	    [{bad_init_ops,AllInitOps}];
+	_ -> % Collect others as Ops
 	    collect_init_options(
-	      InitOps, CallbackMode, [InitOp|StateOps])
+	      InitOps, CallbackMode, [InitOp|Ops])
     end.
 
-collect_state_options(StateOps) ->
+collect_transition_options(Ops) ->
     if
-	is_list(StateOps) ->
-	    collect_state_options(StateOps, false, false, undefined, []);
+	is_list(Ops) ->
+	    collect_transition_options(
+	      Ops, false, false, undefined, []);
 	true ->
-	    collect_state_options([StateOps], false, false, undefined, [])
+	    collect_transition_options(
+	      [Ops], false, false, undefined, [])
     end.
 %% Keep the last of each kind
-collect_state_options(
-  [], Postpone, Hibernate, Timeout, Operations) ->
-    {Postpone,Hibernate,Timeout,lists:reverse(Operations)};
-collect_state_options(
-  [StateOp|StateOps] = SOSOs, Postpone, Hibernate, Timeout, Operations) ->
-    case StateOp of
+collect_transition_options(
+  [], Postpone, Hibernate, Timeout, Actions) ->
+    {Postpone,Hibernate,Timeout,lists:reverse(Actions)};
+collect_transition_options(
+  [Op|Ops] = AllOps, Postpone, Hibernate, Timeout, Actions) ->
+    case Op of
 	postpone ->
-	    collect_state_options(
-	      StateOps, true, Hibernate, Timeout, Operations);
+	    collect_transition_options(
+	      Ops, true, Hibernate, Timeout, Actions);
 	{postpone,NewPostpone} when is_boolean(NewPostpone) ->
-	    collect_state_options(
-	      StateOps, NewPostpone, Hibernate, Timeout, Operations);
+	    collect_transition_options(
+	      Ops, NewPostpone, Hibernate, Timeout, Actions);
 	{postpone,_} ->
-	    [{bad_state_ops,SOSOs}];
+	    [{bad_ops,AllOps}];
 	hibernate ->
-	    collect_state_options(
-	      StateOps, Postpone, true, Timeout, Operations);
+	    collect_transition_options(
+	      Ops, Postpone, true, Timeout, Actions);
 	{hibernate,NewHibernate} when is_boolean(NewHibernate) ->
-	    collect_state_options(
-	      StateOps, Postpone, NewHibernate, Timeout, Operations);
+	    collect_transition_options(
+	      Ops, Postpone, NewHibernate, Timeout, Actions);
 	{hibernate,_} ->
-	    [{bad_state_ops,SOSOs}];
+	    [{bad_ops,AllOps}];
 	{timeout,infinity,_} -> % Ignore since it will never time out
-	    collect_state_options(
-	      StateOps, Postpone, Hibernate, undefined, Operations);
+	    collect_transition_options(
+	      Ops, Postpone, Hibernate, undefined, Actions);
 	{timeout,Time,_} = NewTimeout when is_integer(Time), Time >= 0 ->
-	    collect_state_options(
-	      StateOps, Postpone, Hibernate, NewTimeout, Operations);
+	    collect_transition_options(
+	      Ops, Postpone, Hibernate, NewTimeout, Actions);
 	{timeout,_,_} ->
-	    [{bad_state_ops,SOSOs}];
-	_ -> % Collect others as operations
-	    collect_state_options(
-	      StateOps, Postpone, Hibernate, Timeout, [StateOp|Operations])
+	    [{bad_ops,AllOps}];
+	_ -> % Collect others as actions
+	    collect_transition_options(
+	      Ops, Postpone, Hibernate, Timeout, [Op|Actions])
     end.
 
-process_state_operations([], Debug, _S, Q, P) ->
+process_transition_actions([], Debug, _S, Q, P) ->
     {Debug,Q,P};
-process_state_operations([Operation|Operations] = OOs, Debug, S, Q, P) ->
-    case Operation of
+process_transition_actions(
+  [Action|Actions] = AllActions, Debug, S, Q, P) ->
+    case Action of
 	{reply,{_To,_Tag}=Client,Reply} ->
 	    NewDebug = do_reply(Debug, S, Client, Reply),
-	    process_state_operations(Operations, NewDebug, S, Q, P);
+	    process_transition_actions(Actions, NewDebug, S, Q, P);
 	{next_event,Type,Content} ->
 	    case event_type(Type) of
 		true ->
-		    process_state_operations(
-		      Operations, Debug, S, [{Type,Content}|Q], P);
+		    process_transition_actions(
+		      Actions, Debug, S, [{Type,Content}|Q], P);
 		false ->
-		    [{bad_state_ops,OOs},Debug]
+		    [{bad_ops,AllActions},Debug]
 	    end;
 	_ ->
-	    %% All others are remove operations
-	    case remove_fun(Operation) of
+	    %% All others are remove actions
+	    case remove_fun(Action) of
 		false ->
-		    process_state_operations(
-		      Operations, Debug, S, Q, P);
+		    process_transition_actions(
+		      Actions, Debug, S, Q, P);
 		undefined ->
-		    [{bad_state_ops,OOs},Debug];
+		    [{bad_ops,AllActions},Debug];
 		RemoveFun when is_function(RemoveFun, 2) ->
 		    case remove_event(RemoveFun, Q, P) of
 			{NewQ,NewP} ->
-			    process_state_operations(
-			      Operations, Debug, S, NewQ, NewP);
+			    process_transition_actions(
+			      Actions, Debug, S, NewQ, NewP);
 			Error ->
 			    Error ++ [Debug]
 		    end;
@@ -1023,7 +1024,8 @@ remove_event(RemoveFun, Q, P) ->
 	    [Class,Reason,erlang:get_stacktrace()]
     end.
 
-%% Do the given state operation and create an event removal predicate fun()
+%% Do the given transition action and create
+%% an event removal predicate fun()
 remove_fun({remove_event,Type,Content}) ->
     fun (T, C) when T =:= Type, C =:= Content -> true;
 	(_, _) -> false
@@ -1104,9 +1106,9 @@ cancel_timer(TimerRef) ->
 terminate(
   Class, Reason, Stacktrace, Debug,
   #{module := Module,
-    state := State, state_data := StateData} = S,
+    state := State, data := Data} = S,
   Q) ->
-    try Module:terminate(Reason, State, StateData) of
+    try Module:terminate(Reason, State, Data) of
 	_ -> ok
     catch
 	_ -> ok;
@@ -1137,7 +1139,7 @@ error_info(
   Class, Reason, Stacktrace, Debug,
   #{name := Name, callback_mode := CallbackMode,
     state := State, postponed := P},
-  Q, FmtStateData) ->
+  Q, FmtData) ->
     {FixedReason,FixedStacktrace} =
 	case Stacktrace of
 	    [{M,F,Args,_}|ST]
@@ -1190,7 +1192,7 @@ error_info(
 	   [Event|_] ->
 	       [Event]
        end] ++
-	  [FmtStateData,Class,FixedReason,
+	  [FmtData,Class,FixedReason,
 	   State,CallbackMode,length(Q),length(P)] ++
 	  case FixedStacktrace of
 	      [] ->
@@ -1205,22 +1207,22 @@ error_info(
 %% Call Module:format_status/2 or return a default value
 format_status(
   Opt, PDict,
-  #{module := Module, state := State, state_data := StateData}) ->
+  #{module := Module, state := State, data := Data}) ->
     case erlang:function_exported(Module, format_status, 2) of
 	true ->
-	    try Module:format_status(Opt, [PDict,State,StateData])
+	    try Module:format_status(Opt, [PDict,State,Data])
 	    catch
 		Result -> Result;
 		_:_ ->
-		    format_status_default(Opt, State, StateData)
+		    format_status_default(Opt, State, Data)
 	    end;
 	false ->
-	    format_status_default(Opt, State, StateData)
+	    format_status_default(Opt, State, Data)
     end.
 
 %% The default Module:format_status/2
-format_status_default(Opt, State, StateData) ->
-    SSD = {State,StateData},
+format_status_default(Opt, State, Data) ->
+    SSD = {State,Data},
     case Opt of
 	terminate ->
 	    SSD;
diff --git a/lib/stdlib/test/gen_statem_SUITE.erl b/lib/stdlib/test/gen_statem_SUITE.erl
index 4ac4acd189..65a8d35645 100644
--- a/lib/stdlib/test/gen_statem_SUITE.erl
+++ b/lib/stdlib/test/gen_statem_SUITE.erl
@@ -573,10 +573,10 @@ call_format_status(Config) when is_list(Config) ->
 error_format_status(Config) when is_list(Config) ->
     error_logger_forwarder:register(),
     OldFl = process_flag(trap_exit, true),
-    StateData = "called format_status",
+    Data = "called format_status",
     {ok,Pid} =
 	gen_statem:start(
-	  ?MODULE, start_arg(Config, {state_data,StateData}), []),
+	  ?MODULE, start_arg(Config, {data,Data}), []),
     %% bad return value in the gen_statem loop
     {{bad_return_value,badreturn},_} =
 	?EXPECT_FAILURE(gen_statem:call(Pid, badreturn), Reason),
@@ -585,7 +585,7 @@ error_format_status(Config) when is_list(Config) ->
 	 {Pid,
 	  "** State machine"++_,
 	  [Pid,{{call,_},badreturn},
-	   {formatted,idle,StateData},
+	   {formatted,idle,Data},
 	   exit,{bad_return_value,badreturn}|_]}} ->
 	    ok;
 	Other when is_tuple(Other), element(1, Other) =:= error ->
@@ -609,10 +609,10 @@ error_format_status(Config) when is_list(Config) ->
 terminate_crash_format(Config) when is_list(Config) ->
     error_logger_forwarder:register(),
     OldFl = process_flag(trap_exit, true),
-    StateData = crash_terminate,
+    Data = crash_terminate,
     {ok,Pid} =
 	gen_statem:start(
-	  ?MODULE, start_arg(Config, {state_data,StateData}), []),
+	  ?MODULE, start_arg(Config, {data,Data}), []),
     stop_it(Pid),
     Self = self(),
     receive
@@ -621,7 +621,7 @@ terminate_crash_format(Config) when is_list(Config) ->
 	  "** State machine"++_,
 	  [Pid,
 	   {{call,{Self,_}},stop},
-	   {formatted,idle,StateData},
+	   {formatted,idle,Data},
 	   exit,{crash,terminate}|_]}} ->
 	    ok;
 	Other when is_tuple(Other), element(1, Other) =:= error ->
@@ -647,7 +647,7 @@ get_state(Config) when is_list(Config) ->
     State = self(),
     {ok,Pid} =
 	gen_statem:start(
-	  ?MODULE, start_arg(Config, {state_data,State}), []),
+	  ?MODULE, start_arg(Config, {data,State}), []),
     {idle,State} = sys:get_state(Pid),
     {idle,State} = sys:get_state(Pid, 5000),
     stop_it(Pid),
@@ -656,7 +656,7 @@ get_state(Config) when is_list(Config) ->
     %% already checked by the previous test)
     {ok,Pid2} =
 	gen_statem:start(
-	  {local,gstm}, ?MODULE, start_arg(Config, {state_data,State}), []),
+	  {local,gstm}, ?MODULE, start_arg(Config, {data,State}), []),
     {idle,State} = sys:get_state(gstm),
     {idle,State} = sys:get_state(gstm, 5000),
     stop_it(Pid2),
@@ -664,7 +664,7 @@ get_state(Config) when is_list(Config) ->
     %% check that get_state works when pid is sys suspended
     {ok,Pid3} =
 	gen_statem:start(
-	  ?MODULE, start_arg(Config, {state_data,State}), []),
+	  ?MODULE, start_arg(Config, {data,State}), []),
     {idle,State} = sys:get_state(Pid3),
     ok = sys:suspend(Pid3),
     {idle,State} = sys:get_state(Pid3, 5000),
@@ -676,7 +676,7 @@ replace_state(Config) when is_list(Config) ->
     State = self(),
     {ok, Pid} =
 	gen_statem:start(
-	  ?MODULE, start_arg(Config, {state_data,State}), []),
+	  ?MODULE, start_arg(Config, {data,State}), []),
     {idle,State} = sys:get_state(Pid),
     NState1 = "replaced",
     Replace1 = fun({StateName, _}) -> {StateName,NState1} end,
@@ -1124,8 +1124,8 @@ init(hiber) ->
     {ok,hiber_idle,[]};
 init(hiber_now) ->
     {ok,hiber_idle,[],[hibernate]};
-init({state_data, StateData}) ->
-    {ok,idle,StateData};
+init({data, Data}) ->
+    {ok,idle,Data};
 init({init_ops,Arg,InitOps}) ->
     case init(Arg) of
 	{ok,State,Data,Ops} ->
@@ -1136,7 +1136,7 @@ init({init_ops,Arg,InitOps}) ->
 	    Other
     end;
 init([]) ->
-    {ok,idle,state_data}.
+    {ok,idle,data}.
 
 terminate(_, _State, crash_terminate) ->
     exit({crash,terminate});
@@ -1362,20 +1362,20 @@ unwrap_state(State) ->
 
 wrap_result(Result) ->
     case Result of
-	{next_state,NewState,NewStateData} ->
-	    {next_state,[NewState],NewStateData};
-	{next_state,NewState,NewStateData,StateOps} ->
-	    {next_state,[NewState],NewStateData,StateOps};
+	{next_state,NewState,NewData} ->
+	    {next_state,[NewState],NewData};
+	{next_state,NewState,NewData,StateOps} ->
+	    {next_state,[NewState],NewData,StateOps};
 	Other ->
 	    Other
     end.
 
 
 
-code_change(_OldVsn, State, StateData, _Extra) ->
-    {ok,State,StateData}.
+code_change(_OldVsn, State, Data, _Extra) ->
+    {ok,State,Data}.
 
-format_status(terminate, [_Pdict,State,StateData]) ->
-    {formatted,State,StateData};
-format_status(normal, [_Pdict,_State,_StateData]) ->
+format_status(terminate, [_Pdict,State,Data]) ->
+    {formatted,State,Data};
+format_status(normal, [_Pdict,_State,_Data]) ->
     [format_status_called].