-type action() ::
          postpone |
          {postpone, Postpone :: postpone()} |
          {next_event, EventType :: event_type(), EventContent :: event_content()} |
          {change_callback_module, NewModule :: module()} |
          {push_callback_module, NewModule :: module()} |
          pop_callback_module |
          enter_action().

用於狀態轉換或啟動伺服器的動作。

這些轉換動作可以透過在呼叫 狀態回呼 時，從 Module:init/1 返回它們，或將它們傳遞給 enter_loop/4,5,6 來呼叫。它們在狀態進入呼叫中不允許使用。

動作會依容器列表的順序執行。

設定 轉換選項 的動作會覆蓋任何先前相同類型的選項，因此容器列表中的最後一個會生效。例如，最後一個 postpone/0 會覆蓋列表中任何先前的 postpone/0。

• {postpone, Value} - 為此狀態轉換設定 transition_option() postpone/0。當從 Module:init/1 返回或傳遞給 enter_loop/4,5,6 時，此動作會被忽略，因為在這些情況下沒有要延遲的事件。

  postpone 等同於 {postpone, true}。

• {next_event, EventType, EventContent} - 此動作不會設定任何 transition_option()，而是儲存指定的 EventType 和 EventContent，以便在所有動作執行後插入。

  儲存的事件會插入佇列中，作為在任何已排隊的事件之前要處理的下一個事件。這些儲存的事件的順序會被保留，因此容器列表中的第一個 next_event 會成為第一個要處理的事件。

  當您想要可靠地將以這種方式插入的事件與任何外部事件區分開來時，應該使用 internal 類型的事件。

• {change_callback_module, NewModule} - 將回呼模組變更為 NewModule，在呼叫所有後續的狀態回呼時將會使用該模組。
  自 OTP 22.3 起。

  gen_statem 引擎將透過在下一個狀態回呼之前呼叫 NewModule:callback_mode/0 來找出 NewModule 的 回呼模式。

  變更回呼模組不會以任何方式影響狀態轉換，它只會變更處理事件的模組。請注意，NewModule 中的所有相關回呼函數（例如狀態回呼、NewModule:code_change/4、NewModule:format_status/1 和 NewModule:terminate/3）都必須能夠處理舊模組的狀態和資料。

• {push_callback_module, NewModule} - 將目前的回呼模組推送到回呼模組的內部堆疊頂部，並將回呼模組變更為 NewModule。否則，就像上面的 {change_callback_module, NewModule} 一樣。
  自 OTP 22.3 起。

• pop_callback_module - 從回呼模組的內部堆疊中彈出頂部模組，並將回呼模組變更為彈出的模組。如果堆疊為空，伺服器會失敗。否則，就像上面的 {change_callback_module, NewModule} 一樣。
  自 OTP 22.3 起。

-type callback_mode() :: state_functions | handle_event_function.

每個狀態一個函式或一個通用的事件處理常式。

回呼模式是使用 Module:callback_mode/0 的回傳值選取的。

• state_functions - 狀態必須是 state_name/0 類型，且每個狀態有一個回呼函數，也就是 Module:StateName/3。

• handle_event_function - 狀態可以是任何項，而回呼函數 Module:handle_event/4 用於所有狀態。

函數 Module:callback_mode/0 會在啟動 gen_statem 時、程式碼變更後以及在使用任何動作 change_callback_module、push_callback_module 或 pop_callback_module 變更回呼模組後呼叫。結果會快取以供後續呼叫 狀態回呼。

-type callback_mode_result() :: callback_mode() | [callback_mode() | state_enter()].

來自 Module:callback_mode/0 的回傳值。

這是從 Module:callback_mode/0 返回的類型，它會選取回呼模式以及是否執行 狀態進入呼叫。

-type data() :: term().

伺服器的通用狀態資料。

狀態機實作在其中儲存所需任何伺服器資料的詞彙。這與 state/0 本身的不同之處在於，此資料的變更不會導致延遲的事件重試。因此，如果此資料的變更會變更處理的事件集，則該資料項目應為 state/0 的一部分。

-type enter_action() ::
          hibernate | {hibernate, Hibernate :: hibernate()} | timeout_action() | reply_action().

用於任何回呼的動作：休眠、逾時或回覆。

當允許 action/0 時，也允許這些轉換動作，且可以從狀態進入呼叫中呼叫，並且可以透過從 狀態回呼、從 Module:init/1 返回它們，或將它們傳遞給 enter_loop/4,5,6 來呼叫。

動作會依容器列表的順序執行。

設定 轉換選項 的動作會覆蓋任何先前相同類型的選項，因此容器列表中的最後一個會生效。例如，最後一個 event_timeout/0 會覆蓋列表中任何先前的 event_timeout/0。

• {hibernate, Value} - 為此狀態轉換設定 transition_option/0 hibernate/0。

  hibernate 等同於 {hibernate, true}。

-type enter_loop_opt() ::
          {hibernate_after, HibernateAfterTimeout :: timeout()} | {debug, Dbgs :: [sys:debug_option()]}.

用於 enter_loop/4,5,6、start/3,4、start_link/3,4 和 start_monitor/3,4 函式的伺服器啟動選項。

請參閱 start_link/4。

-type event_content() :: term().

來自事件來源的事件酬載，傳遞至狀態回呼。

請參閱 event_type，其中描述了不同事件類型的來源，這也是事件內容的來源。

-type event_handler_result(StateType, DataType) ::
          {next_state, NextState :: StateType, NewData :: DataType} |
          {next_state, NextState :: StateType, NewData :: DataType, Actions :: [action()] | action()} |
          state_callback_result(action(), DataType).

處理事件後，來自狀態回呼的回傳值。

如果 回呼模式 是 state_functions，則 StateType 是 state_name/0，如果 回呼模式 是 handle_event_function，則 StateType 是 state/0。

• {next_state, NextState, NewData [, Actions]} - gen_statem 執行狀態轉換到 NextState （可能與目前狀態相同），將 NewData 設定為目前的伺服器 data/0，並執行所有 Actions。如果 NextState =/= CurrentState，則狀態轉換是狀態變更。

-type event_timeout() :: Time :: timeout() | integer().

等待事件的時間長度。

啟動由 timeout_action/0 設定的計時器 Time，或 {timeout, Time, EventContent [, Options]}。

當計時器到期時，會產生一個 event_type/0 timeout 的事件。關於 Time 和 Options 如何解讀，請參閱 erlang:start_timer/4。未來不一定會支援 erlang:start_timer/4 的 Options。

任何到達的事件都會取消此逾時。請注意，重試或插入的事件都算作已到達。如果狀態逾時零事件在此逾時請求之前產生，也算作已到達。

如果 Time 為 infinity，則不會啟動計時器，因為它永遠不會到期。

如果 Time 是相對時間且為 0，則實際上不會啟動計時器，而是將逾時事件排入佇列，以確保它在任何尚未接收到的外部事件之前處理，但在已排隊的事件之後處理。

請注意，不需要也不可能取消此逾時，因為它會被任何其他事件自動取消，這表示每當調用一個可能想要取消此逾時的回調函式時，計時器已經被取消或已到期。

可以使用 {timeout, update, NewEventContent} 動作更新計時器 EventContent，而不會影響到期時間。

-type event_type() :: external_event_type() | timeout_event_type() | internal.

所有事件類型：外部、逾時 或 internal。

internal 事件只能由狀態機本身透過 *轉換動作* next_event 產生。

-type external_event_type() :: {call, From :: from()} | cast | info.

來自 call、cast 或一般程序訊息的事件；「info」。

類型 {call, From} 源自 API 函式 call/2,3 或 send_request/2。該事件包含 From，這是要透過 reply_action/0 或 reply/2,3 呼叫回覆的對象。

類型 cast 源自 API 函式 cast/2。

類型 info 源自傳送到 gen_statem 程序的一般程序訊息。

-type format_status() ::
          #{state => state(),
            data => data(),
            reason => term(),
            queue => [{event_type(), event_content()}],
            postponed => [{event_type(), event_content()}],
            timeouts => [{timeout_event_type(), event_content()}],
            log => [sys:system_event()]}.

描述伺服器狀態的對應。

鍵如下：

• state - 目前的狀態。
• data - 狀態資料。
• reason - 導致程序終止的原因。
• queue - 事件佇列。
• postponed - 延後事件的佇列。
• timeouts - 活動中的 逾時。
• log - 伺服器的 sys log。

新的關聯可能會新增到狀態映射中，恕不另行通知。

-type from() :: {To :: pid(), Tag :: reply_tag()}.

call 事件的回覆目的地。

使用例如 {reply, From, Reply} 動作回覆已使用 call/2,3 呼叫 gen_statem 伺服器的程序時使用的目的地。

-type generic_timeout() :: Time :: timeout() | integer().

等待具名逾時事件的時間長度。

啟動由 timeout_action/0 設定的計時器 {{timeout, Name}, Time, EventContent [, Options]}。

當計時器到期時，會產生一個 event_type/0 {timeout, Name} 的事件。關於 Time 和 Options 如何解讀，請參閱 erlang:start_timer/4。未來不一定會支援 erlang:start_timer/4 的 Options。

如果 Time 為 infinity，則不會啟動計時器，因為它永遠不會到期。

如果 Time 是相對時間且為 0，則實際上不會啟動計時器，而是將逾時事件排入佇列，以確保它在任何尚未接收到的外部事件之前處理。

當計時器正在執行時，使用相同的 Name 設定計時器會使用新的逾時值重新啟動它。因此，可以透過將其設定為 infinity 來取消特定的逾時。也可以使用 {{timeout, Name}, cancel} 動作更明確地取消它。

可以使用 {{timeout, Name}, update, NewEventContent} 動作更新計時器 EventContent，而不會影響到期時間。

-type hibernate() :: boolean().

讓伺服器程序休眠。

如果為 true，則會在進入 receive 以等待新的外部事件之前，呼叫 proc_lib:hibernate/3 來休眠 gen_statem。

還有一個伺服器啟動選項 {hibernate_after, Timeout}，用於自動休眠。

注意

如果請求休眠時有排隊的事件要處理，則會進行最佳化，方法是不休眠，而是呼叫 erlang:garbage_collect/0，以更有效的方式模擬 gen_statem 進入休眠狀態並立即被排隊的事件喚醒。

-type init_result(StateType, DataType) ::
          {ok, State :: StateType, Data :: DataType} |
          {ok, State :: StateType, Data :: DataType, Actions :: [action()] | action()} |
          ignore |
          {stop, Reason :: term()} |
          {error, Reason :: term()}.

來自 Module:init/1 的回傳值。

對於成功的初始化，State 是初始 state/0，而 Data 是 gen_statem 的初始伺服器 data/0。

當進入第一個 狀態時，會執行 Actions，就像執行 狀態回調一樣，只是動作 postpone 會強制設為 false，因為沒有事件可以延後。

對於不成功的初始化，應使用 {stop, Reason}、{error, Reason} 或 ignore；請參閱 start_link/3,4。

自 OTP 26.0 起 已允許 {error, Reason}。

{ok, ...} 元組自 OTP 19.1 起存在，在此之前它們沒有 ok 標籤。這是因為在 OTP 20.0 中 gen_statem 取代 gen_fsm 之前。

-type postpone() :: boolean().

延後事件，以便稍後處理。

如果為 true，則會延後目前的事件。在 *狀態變更*（NextState =/= State）之後，會重試。

-type reply_action() :: {reply, From :: from(), Reply :: term()}.

回覆 call/2,3。

可以透過從 狀態回調、從 Module:init/1 或透過將其傳遞到 enter_loop/4,5,6 來調用此 *轉換動作*。

它不會設定任何 transition_option()，而是回覆在 call/3 中等待回覆的呼叫者。From 必須是來自呼叫 狀態回調 時的 {call, From} 參數中的術語。

請注意，從 Module:init/1 或 enter_loop/4,5,6 使用此動作將會很奇怪，簡直是巫術邊緣，因為在此伺服器中沒有先前對 狀態回調 的呼叫。

-opaque reply_tag()

將回覆與對應請求關聯的句柄。

-opaque request_id()

不透明的請求識別碼。詳情請參閱 send_request/2。

-opaque request_id_collection()

不透明的請求識別碼集合（request_id/0）。

每個請求識別碼都可以與使用者選擇的標籤相關聯。如需更多資訊，請參閱 reqids_new/0。

-type response_timeout() :: timeout() | {abs, integer()}.

非同步呼叫的回應逾時。

用來設定等待回應的時間限制，適用於 receive_response/2、receive_response/3、wait_response/2 或 wait_response/3。時間單位為 millisecond (毫秒)。

目前可用的值：

• 0..4294967295 - 相對於目前時間的逾時時間，以毫秒為單位。

• infinity - 無限逾時。也就是說，操作永遠不會逾時。

• {abs, Timeout} - 以毫秒為單位的絕對 Erlang 單調時間逾時。也就是說，當 erlang:monotonic_time(millisecond) 返回的值大於或等於 Timeout 時，操作將會逾時。Timeout 不得指定超過未來 4294967295 毫秒的時間。當您有一組請求的完整集合 ( request_id_collection/0) 的回應期限時，使用絕對值指定逾時時間特別方便，因為您不必重複重新計算直到期限的相對時間。

-type server_name() ::
          {local, atom()} | {global, GlobalName :: term()} | {via, RegMod :: module(), Name :: term()}.

伺服器名稱規範：local、global 或已註冊的 via。

啟動 gen_statem 伺服器時使用的名稱規格。請參閱下方的 start_link/3 和 server_ref/0。

-type server_ref() ::
          pid() |
          (LocalName :: atom()) |
          {Name :: atom(), Node :: atom()} |
          {global, GlobalName :: term()} |
          {via, RegMod :: module(), ViaName :: term()}.

伺服器規範：pid/0 或已註冊的 server_name/0。

用於 call/2,3 中以指定伺服器。

它可以是：

• pid() | LocalName - gen_statem 已在本機註冊。

• {Name, Node} - gen_statem 已在另一個節點上在本機註冊。

• {global, GlobalName} - gen_statem 已在 global 中全域註冊。

• {via, RegMod, ViaName} - gen_statem 已在替代程序註冊表中註冊。註冊回呼模組 RegMod 應匯出函式 register_name/2、unregister_name/1、whereis_name/1 和 send/2，這些函式的行為應與 global 中的對應函式相同。因此，{via, global, GlobalName} 與 {global, GlobalName} 相同。

-type start_mon_ret() :: {ok, {pid(), reference()}} | ignore | {error, term()}.

來自 start_monitor/3,4 函式的回傳值。

與 start_link/4 相同，但成功回傳會將程序 ID 和 監控參考 包裝在 {ok, {pid(),reference()}} 元組中。

-type start_opt() ::
          {timeout, Time :: timeout()} | {spawn_opt, [proc_lib:start_spawn_option()]} | enter_loop_opt().

用於 start/3,4、start_link/3,4 和 start_monitor/3,4 函式的伺服器啟動選項。

請參閱 start_link/4。

-type start_ret() :: {ok, pid()} | ignore | {error, term()}.

來自 start/3,4 和 start_link/3,4 函式的回傳值。

請參閱 start_link/4。

-type state() :: state_name() | term().

狀態名稱或狀態詞彙。

如果 回呼模式 為 handle_event_function，則狀態可以是任何項目。在狀態變更 ( NextState =/= State ) 之後，所有延遲的事件都會重試。

假設比較兩個狀態的嚴格相等性是一個快速的操作，因為對於每個狀態轉換，gen_statem 引擎都必須推斷它是否為狀態變更。

注意

通常，狀態項目越小，比較速度就越快。

請注意，如果為狀態轉換回傳「相同」的狀態項目 (或使用不帶 NextState 欄位的回傳動作)，則相等性的比較始終很快，因為可以從項目處理常式中看到這一點。

但是，如果回傳新建立的狀態項目，則必須遍歷舊的和新的狀態項目，直到找到不相等之處，或直到兩個項目都已完全遍歷為止。

因此，可以使用比較速度很快的大型狀態項目，但很容易意外弄糟。使用小型狀態項目是安全選擇。

-type state_callback_result(ActionType, DataType) ::
          {keep_state, NewData :: DataType} |
          {keep_state, NewData :: DataType, Actions :: [ActionType] | ActionType} |
          keep_state_and_data |
          {keep_state_and_data, Actions :: [ActionType] | ActionType} |
          {repeat_state, NewData :: DataType} |
          {repeat_state, NewData :: DataType, Actions :: [ActionType] | ActionType} |
          repeat_state_and_data |
          {repeat_state_and_data, Actions :: [ActionType] | ActionType} |
          stop |
          {stop, Reason :: term()} |
          {stop, Reason :: term(), NewData :: DataType} |
          {stop_and_reply, Reason :: term(), Replies :: [reply_action()] | reply_action()} |
          {stop_and_reply,
           Reason :: term(),
           Replies :: [reply_action()] | reply_action(),
           NewData :: DataType}.

來自任何狀態回呼的回傳值。

如果狀態回呼是使用 狀態進入呼叫 呼叫的，則 ActionType 為 enter_action/0；如果狀態回呼是使用事件呼叫的，則為 action/0。

• {keep_state, NewData [, Actions]} - 與 {next_state, CurrentState, NewData [, Actions]} 相同。

• keep_state_and_data | {keep_state_and_data, Actions} - 與 {keep_state, CurrentData [, Actions]} 相同。

• {repeat_state, NewData [, Actions]} - 如果 gen_statem 使用 狀態進入呼叫 執行，則會重複狀態進入呼叫，請參閱類型 transition_option/0。除此之外，{repeat_state, NewData [, Actions]} 與 {keep_state, NewData [, Actions]} 相同。

• repeat_state_and_data | {repeat_state_and_data, Actions} - 與 {repeat_state, CurrentData [, Actions]} 相同。

• {stop, Reason [, NewData]} - 透過使用 Reason 和 NewData (如果指定) 呼叫 Module:terminate/3 來終止 gen_statem。包含此原因的退出訊號會傳送至連結的程序和連接埠。

• stop - 與 {stop, normal} 相同。

• {stop_and_reply, Reason, Replies [, NewData]} - 傳送所有 Replies，然後像使用 {stop, Reason [, NewData]} 一樣終止 gen_statem。

所有這些項目都是元組或原子，並且在 gen_statem 的所有未來版本中都將如此。

-type state_enter() :: state_enter.

用於狀態進入呼叫的回呼模式修飾符：原子 state_enter。

兩種回呼模式都可以使用狀態進入呼叫，這可以透過將 state_enter 旗標新增至 回呼模式 從 Module:callback_mode/0 回傳的值中來選取。

如果 Module:callback_mode/0 回傳一個包含 state_enter 的清單，則 gen_statem 引擎會在每次狀態變更時 (也就是 NextState =/= CurrentState)，使用引數 (enter, OldState, Data) 或 (enter, OldState, State, Data) 呼叫 狀態回呼，具體取決於 回呼模式。

這看起來像一個事件，但實際上是在先前的 狀態回呼 回傳之後，以及在任何事件傳遞至新的 狀態回呼 之前執行的呼叫。請參閱 Module:StateName/3 和 Module:handle_event/4。透過從狀態回呼回傳 repeat_state 或 repeat_state_and_data 動作，可以在不進行狀態變更的情況下重複狀態進入呼叫。

如果 Module:callback_mode/0 未回傳包含 state_enter 的清單，則不會執行狀態進入呼叫。

如果 Module:code_change/4 應轉換狀態，則將其視為狀態重新命名，而不是狀態變更，這不會導致狀態進入呼叫。

請注意，在進入初始狀態之前將會執行狀態進入呼叫，這可以視為從無狀態到初始狀態的狀態變更。在這種情況下，OldState =:= State，這不會在後續的狀態變更中發生，但會在重複狀態進入呼叫時發生。

-type state_enter_result(State, DataType) ::
          {next_state, State, NewData :: DataType} |
          {next_state, State, NewData :: DataType, Actions :: [enter_action()] | enter_action()} |
          state_callback_result(enter_action(), DataType).

在狀態進入呼叫之後，來自狀態回呼的回傳值。

State 是目前的狀態，由於使用 狀態進入呼叫 呼叫狀態回呼，因此無法變更。

• {next_state, State, NewData [, Actions]} - gen_statem 會執行到 State 的狀態轉換，該狀態必須等於目前的狀態，設定 NewData，並執行所有 Actions。

-type state_name() :: atom().

在回呼模式 state_functions 中的狀態名稱。

如果 回呼模式 為 state_functions，則狀態必須為原子。在狀態變更 ( NextState =/= State ) 之後，所有延遲的事件都會重試。請注意，狀態 terminate 無法使用，因為它會與選用的回呼函式 Module:terminate/3 衝突。

-type state_timeout() :: Time :: timeout() | integer().

在目前狀態中等待的時間長度。

啟動由 timeout_action/0 或 {state_timeout, Time, EventContent [, Options]} 設定的計時器。

當計時器逾時時，會產生一個 event_type/0 的 state_timeout 事件。關於如何解釋 Time 和 Options，請參閱 erlang:start_timer/4。未來不一定會支援 erlang:start_timer/4 的 Options。

如果計時器正在執行，狀態變更會取消這個計時器。也就是說，如果啟動此計時器的 timeout_action/0 是 狀態變更 的 action/0 列表的一部分，NextState =/= CurrentState，則計時器會在 NextState 中執行。

如果狀態機停留在新的狀態（現在是目前狀態），計時器將會執行直到逾時，並產生逾時事件。如果狀態機從現在的目前狀態變更狀態，則會取消計時器。在從現在的目前狀態變更狀態期間，可能會為下一個 NextState 啟動新的狀態逾時。

如果啟動此計時器的 timeout_action/0 是非狀態變更的狀態轉換的 action/0 列表的一部分，則計時器會在目前狀態中執行。

如果 Time 為 infinity，則不會啟動計時器，因為它永遠不會到期。

如果 Time 是相對時間且為 0，則實際上不會啟動計時器，而是將逾時事件加入佇列，以確保它在任何尚未收到的外部事件之前被處理。

如果在計時器執行時設定此計時器，則會使用新的逾時值重新啟動它。因此，可以透過將其設定為 infinity 來取消此逾時。也可以使用 {state_timeout, cancel} 更明確地取消它。

計時器的 EventContent 可以使用 {state_timeout, update, NewEventContent} 動作來更新，而不會影響逾時時間。

-type timeout_action() ::
          (Time :: event_timeout()) |
          {timeout, Time :: event_timeout(), EventContent :: event_content()} |
          {timeout,
           Time :: event_timeout(),
           EventContent :: event_content(),
           Options :: timeout_option() | [timeout_option()]} |
          {{timeout, Name :: term()}, Time :: generic_timeout(), EventContent :: event_content()} |
          {{timeout, Name :: term()},
           Time :: generic_timeout(),
           EventContent :: event_content(),
           Options :: timeout_option() | [timeout_option()]} |
          {state_timeout, Time :: state_timeout(), EventContent :: event_content()} |
          {state_timeout,
           Time :: state_timeout(),
           EventContent :: event_content(),
           Options :: timeout_option() | [timeout_option()]} |
          timeout_cancel_action() |
          timeout_update_action().

事件逾時、通用逾時或狀態逾時。

這些轉換動作可以透過從 狀態回呼、從 Module:init/1 或將它們傳遞給 enter_loop/4,5,6 來調用。

這些逾時動作會設定逾時 轉換選項。

• Time - {timeout, Time, Time} 的縮寫，也就是說，逾時訊息是逾時時間。此形式的存在是為了允許 狀態回呼 傳回值 {next_state, NextState, NewData, Time}，就像在 gen_fsm 中一樣。

• {timeout, Time, EventContent [, Options]} - 將 transition_option/0 event_timeout/0 設定為 Time，並帶有 EventContent 和逾時選項 Options。

• {{timeout,Name}, Time, EventContent [, Options]} - 將 transition_option/0 generic_timeout/0 設定為逾時 Name 的 Time，並帶有 EventContent 和逾時選項 Options。
  自 OTP 20.0 起.

• {state_timeout, Time, EventContent [, Options]} - 將 transition_option/0 state_timeout/0 設定為 Time，並帶有 EventContent 和逾時選項 Options。
  自 OTP 19.3 起.

-type timeout_cancel_action() ::
          {timeout, cancel} | {{timeout, Name :: term()}, cancel} | {state_timeout, cancel}.

比原始設定為「無限」更明確的取消逾時方式。

一直以來，都可以使用 timeout_action/0 和 Time = infinity 來取消逾時，因為設定新的逾時時間會覆蓋正在執行的計時器，而且將時間設定為 infinity 會被最佳化為不設定計時器（永遠不會逾時）。使用此動作可以更清楚地顯示意圖。

-type timeout_event_type() :: timeout | {timeout, Name :: term()} | state_timeout.

事件逾時、通用逾時 或 狀態逾時。

狀態機可以使用對應的 timeout_action/0 為自己產生的逾時事件類型

簡而言之；設定具有 EventType 的逾時的動作是 {EventType, Time, ...}。

-type timeout_option() :: {abs, Abs :: boolean()}.

逾時計時器啟動選項，可選擇絕對的到期時間。

如果 Abs 為 true，則會啟動絕對計時器；如果為 false，則會啟動相對計時器，這是預設值。有關詳細資訊，請參閱 erlang:start_timer/4。

-type timeout_update_action() ::
          {timeout, update, EventContent :: event_content()} |
          {{timeout, Name :: term()}, update, EventContent :: event_content()} |
          {state_timeout, update, EventContent :: event_content()}.

更新 EventContent，而不影響到期時間。

為正在執行的逾時計時器設定新的 EventContent。關於如何啟動逾時，請參閱 timeout_action()。

如果沒有此類型的逾時處於活動狀態，則會像使用相對 Time = 0 啟動逾時一樣，插入逾時事件。這是一個具有立即逾時的逾時自動啟動，因此，如果例如通用逾時名稱拼寫錯誤，則會產生雜訊。

-type transition_option() ::
          postpone() | hibernate() | event_timeout() | generic_timeout() | state_timeout().

由動作設定的狀態轉換選項。

這些決定在狀態轉換期間會發生什麼。當 狀態回呼 處理完事件並傳回時，就會發生狀態轉換。以下是狀態轉換的步驟順序

1. 所有傳回的 動作 都會按照出現順序處理。在此步驟中，會傳送由任何 reply_action/0 產生的所有回覆。其他動作會設定 transition_option/0，這些選項會在後續步驟中生效。

2. 如果使用 狀態進入呼叫，則會使用初始狀態或其中一個回呼結果 repeat_state 或 repeat_state_and_data，則 gen_statem 引擎會使用引數 (enter, State, Data) 或 (enter, State, State, Data)（取決於 回呼模式）呼叫目前的狀態回呼，當它傳回時，會再次從此序列的頂端開始。

   如果使用 狀態進入呼叫，並且狀態變更，則 gen_statem 引擎會使用引數 (enter, OldState, Data) 或 (enter, OldState, State, Data)（取決於 回呼模式）呼叫新的狀態回呼，當它傳回時，會再次從此序列的頂端開始。

3. 如果 postpone/0 為 true，則會延後目前的事件。

4. 如果這是狀態變更，則會重設傳入事件的佇列，從最舊的延後事件開始。

5. 所有透過 action/0 next_event 儲存的事件都會插入，以便在先前加入佇列的事件之前處理。

6. 會處理逾時計時器 event_timeout/0、generic_timeout/0 和 state_timeout/0。保證會將零時間逾時傳遞給狀態機，在任何尚未收到的外部事件之前，因此，如果請求了此類逾時，則會將對應的逾時零事件加入佇列作為最新的已接收事件；也就是說，在已加入佇列的事件（例如插入和延後的事件）之後。

   任何事件都會取消 event_timeout/0，因此只有在事件佇列為空時，才會產生零時間事件逾時。

   狀態變更會取消 state_timeout/0，並且此類型的任何新的轉換選項都屬於新狀態，也就是說，state_timeout/0 適用於狀態機進入的狀態。

7. 如果有已加入佇列的事件，則會使用最舊的已加入佇列事件呼叫可能的新狀態的 狀態回呼，並且我們會再次從此序列的頂端開始。

8. 否則，gen_statem 會進入 receive 或休眠狀態（如果 hibernate/0 為 true），以等待下一個訊息。在休眠狀態下，下一個非系統事件會喚醒 gen_statem，或者更確切地說，下一個傳入訊息會喚醒 gen_statem，但如果它是系統事件，則會立即返回休眠狀態。當新的訊息到達時，會使用對應的事件呼叫 狀態回呼，並且我們會再次從此序列的頂端開始。

注意

零時間逾時（時間為 0 的逾時）的行為與 Erlang 的 receive ... after 0 ... end 略有不同。

後者若有訊息則接收一個訊息，而使用 timeout_action/0 {timeout, 0} 則不會接收任何外部事件。

gen_server 的逾時機制如同 Erlang 的 receive ... after 0 ... end，與 gen_statem 的機制相反。