Statig

https://docs.rs/statig/latest/statig
Admin
Statig is a Rust library for designing event-driven systems using hierarchical state machines,...
Tokens:22,074
Snippets:115
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Statig Blinky State Machine Example

Source: https://docs.rs/statig/latest/statig/index

Demonstrates a simple blinky state machine using the statig crate's macro. It defines states (LedOn, LedOff, NotBlinking) and a superstate (Blinking), handling events like TimerElapsed and ButtonPressed to transition between states. The example includes the state machine definition and a basic main function to run it.

```Rust
#[derive(Default)]
pub struct Blinky;

pub enum Event {
    TimerElapsed,
    ButtonPressed
}

#[state_machine(initial = "State::led_on()")
]
impl Blinky {
    #[state(superstate = "blinking")]
    fn led_on(event: &Event) -> Outcome<State> {
        match event {
            Event::TimerElapsed => Transition(State::led_off()),
            _ => Super
        }
    }

    #[state(superstate = "blinking")]
    fn led_off(event: &Event) -> Outcome<State> {
        match event {
            Event::TimerElapsed => Transition(State::led_on()),
            _ => Super
        }
    }

    #[superstate]
    fn blinking(event: &Event) -> Outcome<State> {
        match event {
            Event::ButtonPressed => Transition(State::not_blinking()),
            _ => Super
        }
    }

    #[state]
    fn not_blinking(event: &Event) -> Outcome<State> {
        match event {
            Event::ButtonPressed => Transition(State::led_on()),
            _ => Super
        }
    }
}

fn main() {
    let mut state_machine = Blinky::default().state_machine();

    state_machine.handle(&Event::TimerElapsed);
    state_machine.handle(&Event::ButtonPressed);
}
```

--------------------------------

### Rust State Actions

Source: https://docs.rs/statig/latest/statig/index

Defines actions that run when entering or leaving states during a transition in a Rust Statig state machine. Includes example entry and exit actions.

```Rust
#[state(entry_action = "enter_led_on", exit_action = "exit_led_on")]
fn led_on(event: &Event) -> Outcome<State> {
    Transition(State::led_off())
}

#[action]
fn enter_led_on() {
    println!("Entered on");
}

#[action]
fn exit_led_on() {
    println!("Exited on");
}
```

--------------------------------

### Rust Introspection Callbacks

Source: https://docs.rs/statig/latest/statig/index

Defines introspection callbacks for logging state machine execution points in Rust Statig. Includes examples for before/after dispatch and before/after transition.

```Rust
#[state_machine(
    initial = "State::on()",
    before_dispatch = "Self::before_dispatch",
    after_dispatch = "Self::after_dispatch",
    before_transition = "Self::before_transition",
    after_transition = "Self::after_transition",
    state(derive(Debug)),
    superstate(derive(Debug))
)]
impl Blinky {
    ...
}

impl Blinky {
    fn before_dispatch(&mut self, state: StateOrSuperstate<Blinky>, event: &Event, _context: &mut ()) {
        println!("before dispatched `{:?}` to `{:?}`", event, state);
    }

    fn after_dispatch(&mut self, state: StateOrSuperstate<Blinky>, event: &Event, _context: &mut ()) {
        println!("after dispatched `{:?}` to `{:?}`", event, state);
    }

    fn before_transition(&mut self, source: &State, target: &State, _context: &mut ()) {
        println!("before transitioned from `{:?}` to `{:?}`", source, target);
    }

    fn after_transition(&mut self, source: &State, target: &State, _context: &mut ()) {
        println!("after transitioned from `{:?}` to `{:?}`", source, target);
    }
}
```

--------------------------------

### Define Leaf States with State-Local Storage

Source: https://docs.rs/statig/latest/statig/index

Defines leaf states for a state machine using Rust enums. This example demonstrates 'state-local storage' where data like a counter is owned by specific states.

```Rust
enum State {
    LedOn { counter: usize },
    LedOff { counter: usize },
    NotBlinking
}
```

--------------------------------

### Get Mutable State Reference

Source: https://docs.rs/statig/latest/statig/blocking/struct

Provides mutable access to the current state of the StateMachine. Users must ensure that mutations do not violate state machine invariants.

```Rust
let mut uninitialized_state_machine = Blinky::default().uninitialized_state_machine();

*uninitialized_state_machine.state_mut() = State::on();
```

--------------------------------

### Get Inner State Machine Reference

Source: https://docs.rs/statig/latest/statig/blocking/struct

Retrieves an immutable reference to the underlying type of the UninitializedStateMachine.

```Rust
let uninitialized_state_machine = Blinky::default().uninitialized_state_machine();

assert_eq!(uninitialized_state_machine.inner().led, false);
```

--------------------------------

### Initialize State Machine with Context

Source: https://docs.rs/statig/latest/statig/blocking/struct

Initializes the state machine with a provided context, executing entry actions to the initial state. The uninitialized state machine is consumed.

```Rust
let uninitialized_state_machine = Blinky::default().uninitialized_state_machine();

// The uninitialized state machine is consumed to create the initialized
// state machine.
let initialized_state_machine = uninitialized_state_machine.init();
```

--------------------------------

### Get Mutable Inner State Machine Reference

Source: https://docs.rs/statig/latest/statig/blocking/struct

Retrieves a mutable reference to the underlying type of the UninitializedStateMachine, allowing modifications.

```Rust
let mut uninitialized_state_machine = Blinky::default().uninitialized_state_machine();

uninitialized_state_machine.inner_mut().led = true;
```

--------------------------------

### Initialize UninitializedStateMachine with Context

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Initializes the state machine with a provided context, executing entry actions towards the initial state. This method consumes the UninitializedStateMachine and returns an InitializedStateMachine. It requires the `async` feature to be enabled.

```Rust
let uninitialized_state_machine = Blinky::default().uninitialized_state_machine();

// The uninitialized state machine is consumed to create the initialized
// state machine.
let initialized_state_machine = uninitialized_state_machine.init_with_context(context).await;
```

--------------------------------

### Statig Prelude Re-exports

Source: https://docs.rs/statig/latest/statig/prelude/index

This snippet shows the re-exports from the statig prelude module, including extensions for state machines and outcomes, for both async and blocking contexts.

```Rust
pub use crate::awaitable::IntoStateMachineExt as _;
async 

pub use crate::awaitable::StateExt as _;
async 

pub use crate::blocking::IntoStateMachineExt as _;

pub use crate::blocking::StateExt as _;

pub use crate::Outcome;

pub use crate::StateOrSuperstate;

pub use crate::awaitable::*;
async 

pub use crate::blocking::*;

pub use crate::Outcome::*;
```

--------------------------------

### Get Mutable Inner Reference of UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Retrieves a mutable reference to the underlying data of the UninitializedStateMachine. This allows modification of the state machine's internal data.

```Rust
let mut uninitialized_state_machine = Blinky::default().uninitialized_state_machine();

uninitialized_state_machine.inner_mut().led = true;
```

--------------------------------

### Get Mutable State Reference of UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Retrieves a mutable reference to the current state of the UninitializedStateMachine. This allows direct modification of the state, but the user is responsible for maintaining any invariants.

```Rust
let mut uninitialized_state_machine = Blinky::default().uninitialized_state_machine();

*uninitialized_state_machine.state_mut() = State::on();
```

--------------------------------

### Initialize State Machine

Source: https://docs.rs/statig/latest/statig/blocking/struct

Initializes the state machine by executing entry actions to the initial state. The uninitialized state machine is consumed in this process.

```Rust
let uninitialized_state_machine = Blinky::default().uninitialized_state_machine();

// The uninitialized state machine is consumed to create the initialized
// state machine.
let initialized_state_machine = uninitialized_state_machine.init();
```

--------------------------------

### Get Inner Reference of UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Retrieves an immutable reference to the underlying data of the UninitializedStateMachine. This allows access to the state machine's internal data without modifying it.

```Rust
let uninitialized_state_machine = Blinky::default().uninitialized_state_machine();

assert_eq!(uninitialized_state_machine.inner().led, false);
```

--------------------------------

### Initialize UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Initializes the state machine by executing entry actions towards the initial state. This method consumes the UninitializedStateMachine and returns an InitializedStateMachine. It requires the `async` feature to be enabled.

```Rust
let uninitialized_state_machine = Blinky::default().uninitialized_state_machine();

// The uninitialized state machine is consumed to create the initialized
// state machine.
let initialized_state_machine = uninitialized_state_machine.init().await;
```

--------------------------------

### Rust Context Management

Source: https://docs.rs/statig/latest/statig/index

Shows how to pass and use an external mutable context within Rust Statig state machines. Demonstrates accessing and modifying context in state handlers.

```Rust
#[state]
fn led_on(context: &mut Context, event: &Event) -> Outcome<State> {
    match event {
        Event::TimerElapsed => {
            context.do_something();
            Handled
        }
        _ => Super
    }
}
```

```Rust
state_machine.handle_with_context(&Event::TimerElapsed, &mut context);
```

--------------------------------

### Implement TransitionHook with AsyncFnOnce (Simplified Signature)

Source: https://docs.rs/statig/latest/statig/awaitable/trait

This implementation allows types F implementing AsyncFnOnce with a simplified signature (omitting the context) to serve as a TransitionHook. It depends on the 'async' feature.

```Rust
impl<T, F> TransitionHook<T, ((),)> for F
where T: IntoStateMachine,
      F: AsyncFnOnce(&mut T, &T::State, &T::State),
{
```

--------------------------------

### CloneToUninit Implementation for Blanket CloneToUninit

Source: https://docs.rs/statig/latest/statig/blocking/struct

Provides an experimental, nightly-only `CloneToUninit` implementation for types that implement `Clone`. This allows cloning a value into uninitialized memory, potentially for performance optimizations.

```Rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
where
    T: Clone,
{
    // Implementation of cloning to uninitialized memory
}
```

--------------------------------

### Rust State-Local Storage

Source: https://docs.rs/statig/latest/statig/index

Illustrates state-local storage in Rust Statig, where data is passed as input to state handlers. Shows managing a 'counter' specific to the 'led_on' state.

```Rust
#[state]
fn led_on(counter: &mut u32, event: &Event) -> Outcome<State> {
    match event {
        Event::TimerElapsed => {
            *counter -= 1;
            if *counter == 0 {
                Transition(State::led_off())
            } else {
                Handled
            }
        }
        Event::ButtonPressed => Transition(State::led_on(10))
    }
}
```

--------------------------------

### Rust Shared Storage Access

Source: https://docs.rs/statig/latest/statig/index

Demonstrates accessing shared storage fields within states and actions of a Rust Statig state machine. Shows how to modify shared data like 'led'.

```Rust
#[state]
fn led_on(&mut self, event: &Event) -> Outcome<State> {
    match event {
        Event::TimerElapsed => {
            self.led = false;
            Transition(State::led_off())
        }
        _ => Super
    }
}
```

--------------------------------

### Statig Attribute Macro: state_machine

Source: https://docs.rs/statig/latest/statig/prelude/index

Demonstrates the usage of the 'state_machine' attribute macro provided by the statig crate.

```Rust
`state_machine`
```

--------------------------------

### Format State Machine for Debugging

Source: https://docs.rs/statig/latest/statig/blocking/struct

Formats the UninitializedStateMachine for debugging output. Requires the underlying type `M` and its `State` to implement `Debug`.

```Rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

--------------------------------

### Implement CloneToUninit for Blanket (Nightly)

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Provides an unsafe `clone_to_uninit` method for types implementing `Clone`, enabling copy-assignment to uninitialized memory. This is an experimental, nightly-only API.

```Rust
impl<T> CloneToUninit for T
where T: Clone,
{
    unsafe fn clone_to_uninit(&self, dest: *mut u8) {
        // ... implementation details ...
    }
}
```

--------------------------------

### Implement From for UninitializedStateMachine to StateMachine

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Provides a conversion from `UninitializedStateMachine` to `StateMachine` by consuming the `UninitializedStateMachine`.

```Rust
impl<M> From<UninitializedStateMachine<M>> for StateMachine<M>
where
    M: IntoStateMachine,
{
    fn from(value: UninitializedStateMachine<M>) -> Self {
        // ... implementation details ...
    }
}
```

--------------------------------

### Deserialize Implementation for UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/blocking/struct

Provides a `Deserialize` implementation for `UninitializedStateMachine<M>` when the `serde` feature is enabled. This allows serialized state machine data to be deserialized into an uninitialized state machine, which can later be initialized.

```Rust
impl<'de, M>
Deserialize<'de> for UninitializedStateMachine<M>
where
    M: IntoStateMachine + Deserialize<'de>,
    M::State: Deserialize<'de>,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        // Deserialization logic would go here
    }
}
```

--------------------------------

### Rust Async State Machine

Source: https://docs.rs/statig/latest/statig/index

Shows how to implement asynchronous state handlers and actions in Rust Statig. The `#[state_machine]` macro automatically detects and generates an async state machine.

```Rust
#[state_machine(initial = "State::led_on()")Показать
impl Blinky {
    #[state]
    async fn led_on(event: &Event) -> Outcome<State> {
        match event {
            Event::TimerElapsed => Transition(State::led_off()),
            _ => Super
        }
    }
}
```

```Rust
async fn main() {
    let mut state_machine = Blinky::default().state_machine();

    state_machine.handle(&Event::TimerElapsed).await;
    state_machine.handle(&Event::ButtonPressed).await;
}
```

--------------------------------

### Equivalent Implementation for Blanket Equivalent

Source: https://docs.rs/statig/latest/statig/blocking/struct

Provides `Equivalent<K>` implementations for types `Q` that implement `Eq` and can be borrowed by `K`. This is useful for collections where keys might be borrowed.

```Rust
fn equivalent(&self, key: &K) -> bool where Q: Eq + ?Sized, K: Borrow<Q> + ?Sized;
```

--------------------------------

### Implement TransitionHook with AsyncFnOnce

Source: https://docs.rs/statig/latest/statig/awaitable/trait

This implementation allows any type F that implements AsyncFnOnce with the specified signature to act as a TransitionHook. It requires the 'async' feature flag.

```Rust
impl<T, F> TransitionHook<T, ((), ())> for F
where T: IntoStateMachine,
      F: AsyncFnOnce(&mut T, &T::State, &T::State, &mut T::Context<'_>),
{
```

--------------------------------

### Serialize Implementation for UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/blocking/struct

Provides a `Serialize` implementation for `UninitializedStateMachine<M>` when the `serde` feature is enabled. This allows uninitialized state machines to be serialized, typically for storage or transmission.

```Rust
impl<M> Serialize for UninitializedStateMachine<M>
where
    M: IntoStateMachine + Serialize,
    M::State: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // Serialization logic would go here
    }
}
```

--------------------------------

### Implement DynEq for Blanket

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Provides methods for dynamic equality comparison (`dyn_eq`) and casting to `dyn Any` for types that implement `Any` and `Eq`.

```Rust
impl<T> DynEq for T
where T: Any + Eq,
{
    fn as_any(&self) -> &(dyn Any + 'static) {
        // ... implementation details ...
    }
    fn dyn_eq(&self, other: &(dyn DynEq + 'static)) -> bool {
        // ... implementation details ...
    }
}
```

--------------------------------

### Implement PartialEq for UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Allows for equality comparison between two `UninitializedStateMachine` instances. Both the state machine and its state must implement `PartialEq`.

```Rust
impl<M> PartialEq for UninitializedStateMachine<M>
where
    M: IntoStateMachine + PartialEq,
    M::State: PartialEq,
{
    fn eq(&self, other: &Self) -> bool {
        // ... implementation details ...
    }
    fn ne(&self, other: &Self) -> bool {
        // ... implementation details ...
    }
}
```

--------------------------------

### PartialEq Implementation for UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/blocking/struct

Implements the `PartialEq` trait for `UninitializedStateMachine<M>`, enabling equality comparisons between two uninitialized state machines. This requires the state machine's state and the machine itself to implement `PartialEq`.

```Rust
impl<M> PartialEq for UninitializedStateMachine<M>
where
    M: IntoStateMachine + PartialEq,
    M::State: PartialEq,
{
    fn eq(&self, other: &Self) -> bool {
        // Equality comparison logic would go here
    }

    fn ne(&self, other: &Self) -> bool {
        // Inequality comparison logic would go here
    }
}
```

--------------------------------

### Implement Serialize for UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Enables serialization of an `UninitializedStateMachine`. This feature requires the `serde` crate feature and the state machine's state to also implement `Serialize`.

```Rust
impl<M> Serialize for UninitializedStateMachine<M>
where
    M: IntoStateMachine + Serialize,
    M::State: Serialize,
{
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        // ... implementation details ...
    }
}
```

--------------------------------

### Clone From State Machine

Source: https://docs.rs/statig/latest/statig/blocking/struct

Performs copy-assignment from a source UninitializedStateMachine to the current one.

```Rust
fn clone_from(&mut self, source: &Self)
```

--------------------------------

### From Implementation for UninitializedStateMachine to StateMachine

Source: https://docs.rs/statig/latest/statig/blocking/struct

Implements the `From` trait to convert an `UninitializedStateMachine<M>` into a `StateMachine<M>`. This conversion typically occurs after the state machine has been initialized.

```Rust
impl<M> From<UninitializedStateMachine<M>> for StateMachine<M>
where
    M: IntoStateMachine,
{
    fn from(value: UninitializedStateMachine<M>) -> Self {
        // Conversion logic would go here
    }
}
```

--------------------------------

### Implement State Entry and Exit Actions

Source: https://docs.rs/statig/latest/statig/index

Implements the `call_entry_action` and `call_exit_action` methods for the `State` trait. This allows defining logic that executes when entering or exiting a specific state.

```Rust
impl statig::State<Blinky> for State {

    ... 

    fn call_entry_action(&mut self, blinky: &mut Blinky, context: &mut ()) {
        match self {
            State::LedOn { counter } => blinky.enter_led_on(counter),
            State::LedOff { counter } => blinky.enter_led_off(counter),
            State::NotBlinking => blinky.enter_not_blinking()
        }
    }

    fn call_exit_action(&mut self, blinky: &mut Blinky, context: &mut ()) {
        match self {
            State::LedOn { counter } => blinky.exit_led_on(counter),
            State::LedOff { counter } => blinky.exit_led_off(counter),
            State::NotBlinking => blinky.exit_not_blinking()
        }
    }
}
```

--------------------------------

### Clone State Machine

Source: https://docs.rs/statig/latest/statig/blocking/struct

Creates a duplicate of the UninitializedStateMachine. Requires the underlying type `M` and its `State` to implement `Clone`.

```Rust
fn clone(&self) -> Self
```

--------------------------------

### statig: Attribute Macro state_machine

Source: https://docs.rs/statig/latest/statig/prelude/attr

The `state_machine` attribute macro from the `statig::prelude` module. This macro is available only when the 'macro' feature is enabled for the crate.

```Rust
#[state_machine]
```

--------------------------------

### Implement Deserialize for UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Enables deserialization of a serialized state machine into an `UninitializedStateMachine`. This feature requires the `serde` crate feature and the state machine's state to also implement `Deserialize`.

```Rust
impl<'de, M>
Deserialize<'de> for UninitializedStateMachine<M>
where
    M: IntoStateMachine + Deserialize<'de>,
    M::State: Deserialize<'de>,
{
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        // ... implementation details ...
    }
}
```

--------------------------------

### Implement StateMachine Trait for Blinky

Source: https://docs.rs/statig/latest/statig/index

This Rust code implements the `IntoStateMachine` trait for the `Blinky` type, defining the associated types for states, superstates, events, and context. It also specifies the initial state of the state machine.

```Rust
impl IntoStateMachine for Blinky {
    type State = State;

    type Superstate<'sub> = Superstate<'sub>;

    type Event<'evt> = Event;

    type Context<'ctx> = Context;

    fn initial() -> Self::State {
        State::off(10)
    }
}
```

--------------------------------

### Implement Superstate Entry and Exit Actions

Source: https://docs.rs/statig/latest/statig/index

Implements the `call_entry_action` and `call_exit_action` methods for the `Superstate` trait. This defines logic executed upon entering or exiting a superstate, affecting its child states.

```Rust
impl statig::Superstate<Blinky> for Superstate {

    ... 

    fn call_entry_action(&mut self, blinky: &mut Blinky, context: &mut ()) {
        match self {
            Superstate::Blinking { counter } => blinky.enter_blinking(counter)
        }
    }

    fn call_exit_action(&mut self, blinky: &mut Blinky, context: &mut ()) {
        match self {
            Superstate::Blinking { counter } => blinky.exit_blinking(counter)
        }
    }
}
```

--------------------------------

### Format UninitializedStateMachine for Debug

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Formats the UninitializedStateMachine for debugging purposes using the provided formatter. This implementation requires that the underlying state machine type `M` and its state also implement `Debug`.

```Rust
fn fmt(&self, f: &mut Formatter<'_>) -> Result
```

--------------------------------

### Statig Attribute Macros

Source: https://docs.rs/statig/latest/statig/all

This snippet lists the attribute macros provided by the statig crate, which are used for defining state machines and states within Rust code. These macros simplify the process of creating stateful logic.

```Rust
/// Macro for defining actions within a state machine.
#[proc_macro_attribute]
pub fn action(_attr: TokenStream, item: TokenStream) -> TokenStream {
    // Implementation details for the action macro
    item
}

/// Macro for defining a state machine.
#[proc_macro_attribute]
pub fn state_machine(_attr: TokenStream, item: TokenStream) -> TokenStream {
    // Implementation details for the state_machine macro
    item
}

/// Macro for defining a state.
#[proc_macro_attribute]
pub fn state(_attr: TokenStream, item: TokenStream) -> TokenStream {
    // Implementation details for the state macro
    item
}

/// Macro for defining a superstate.
#[proc_macro_attribute]
pub fn superstate(_attr: TokenStream, item: TokenStream) -> TokenStream {
    // Implementation details for the superstate macro
    item
}

// Re-exporting the state_machine macro under prelude for convenience
pub mod prelude {
    pub use super::state_machine;
}
```

--------------------------------

### DynEq Implementations for Blanket DynEq

Source: https://docs.rs/statig/latest/statig/blocking/struct

Implements `DynEq` for types that are `Any` and `Eq`. This allows for dynamic equality comparisons between trait objects.

```Rust
fn as_any(&self) -> &(dyn Any + 'static) where T: Any + Eq;
fn dyn_eq(&self, other: &(dyn DynEq + 'static)) -> bool where T: Any + Eq;
```

--------------------------------

### Statig Superstate Definition

Source: https://docs.rs/statig/latest/statig/index

Shows the implementation of a superstate in statig. The `#[superstate]` attribute designates a method as a superstate, which can handle events deferred from its child states. It returns an `Outcome` to either transition to another state or defer the event further up the hierarchy.

```Rust
#[state(superstate = "blinking")]
fn led_on(event: &Event) -> Outcome<State> {
    match event {
        Event::TimerElapsed => Transition(State::led_off()),
        Event::ButtonPressed => Super
    }
}

#[superstate]
fn blinking(event: &Event) -> Outcome<State> {
    match event {
        Event::ButtonPressed => Transition(State::not_blinking()),
        _ => Super
    }
}
```

--------------------------------

### Auto Trait Implementations for UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/blocking/struct

Details the automatic trait implementations for `UninitializedStateMachine<M>`, including `Freeze`, `RefUnwindSafe`, `Send`, `Sync`, `Unpin`, and `UnwindSafe`. These indicate thread safety and memory management characteristics.

```Rust
impl<M> Freeze for UninitializedStateMachine<M> where M: Freeze, <M as IntoStateMachine>::State: Freeze {} 
impl<M> RefUnwindSafe for UninitializedStateMachine<M> where M: RefUnwindSafe, <M as IntoStateMachine>::State: RefUnwindSafe {} 
impl<M> Send for UninitializedStateMachine<M> where M: Send, <M as IntoStateMachine>::State: Send {} 
impl<M> Sync for UninitializedStateMachine<M> where M: Sync, <M as IntoStateMachine>::State: Sync {} 
impl<M> Unpin for UninitializedStateMachine<M> where M: Unpin, <M as IntoStateMachine>::State: Unpin {} 
impl<M> UnwindSafe for UninitializedStateMachine<M> where M: UnwindSafe, <M as IntoStateMachine>::State: UnwindSafe {}
```

--------------------------------

### Eq Implementation for UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/blocking/struct

Implements the `Eq` trait for `UninitializedStateMachine<M>`, signifying that equality comparison is a total equivalence relation. This builds upon the `PartialEq` implementation.

```Rust
impl<M> Eq for UninitializedStateMachine<M>
where
    M: IntoStateMachine + PartialEq + Eq,
    M::State: PartialEq + Eq,
{
    // No methods to implement, as Eq is a marker trait that refines PartialEq
}
```

--------------------------------

### Define Superstates with Borrowed Data

Source: https://docs.rs/statig/latest/statig/index

Defines superstates for a state machine using Rust enums. Superstates borrow data from their child states, representing shared behavior.

```Rust
enum Superstate<'sub> {
    Blinking { counter: &'sub usize }
}
```

--------------------------------

### Implement Equivalent for Blanket

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Provides the `equivalent` method for checking if a value is equivalent to a borrowed key, for types that implement `Eq`.

```Rust
impl<Q, K> Equivalent<K> for Q
where Q: Eq + ?Sized,
      K: Borrow<Q> + ?Sized,
{
    fn equivalent(&self, key: &K) -> bool {
        // ... implementation details ...
    }
}
```

--------------------------------

### Statig State Definition

Source: https://docs.rs/statig/latest/statig/index

Illustrates how to define a state within a statig state machine. The `#[state]` attribute marks a method as a state, and the method processes events, returning an `Outcome` to dictate the state machine's behavior (Handled, Transition, or Super).

```Rust
#[state]
fn led_on(event: &Event) -> Outcome<State> {
    Transition(State::led_off())
}
```

--------------------------------

### Attach Current Subscriber

Source: https://docs.rs/statig/latest/statig/enum

Attaches the current default `Subscriber` to a type, returning a `WithDispatch` wrapper. This simplifies attaching the active subscriber context.

```Rust
fn with_current_subscriber(self) -> WithDispatch<Self>
```

--------------------------------

### Implement Auto Traits for UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Lists several auto trait implementations for `UninitializedStateMachine`, including `Freeze`, `RefUnwindSafe`, `Send`, `Sync`, `Unpin`, and `UnwindSafe`, indicating thread safety and memory management properties.

```Rust
impl<M> Freeze for UninitializedStateMachine<M>
where M: Freeze,
      <M as IntoStateMachine>::State: Freeze,
{
    // ...
}
```

```Rust
impl<M> RefUnwindSafe for UninitializedStateMachine<M>
where M: RefUnwindSafe,
      <M as IntoStateMachine>::State: RefUnwindSafe,
{
    // ...
}
```

```Rust
impl<M> Send for UninitializedStateMachine<M>
where M: Send,
      <M as IntoStateMachine>::State: Send,
{
    // ...
}
```

```Rust
impl<M> Sync for UninitializedStateMachine<M>
where M: Sync,
      <M as IntoStateMachine>::State: Sync,
{
    // ...
}
```

```Rust
impl<M> Unpin for UninitializedStateMachine<M>
where M: Unpin,
      <M as IntoStateMachine>::State: Unpin,
{
    // ...
}
```

```Rust
impl<M> UnwindSafe for UninitializedStateMachine<M>
where M: UnwindSafe,
      <M as IntoStateMachine>::State: UnwindSafe,
{
    // ...
}
```

--------------------------------

### Clone From UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Performs copy-assignment from a source UninitializedStateMachine into the current one. This is part of the `Clone` trait implementation.

```Rust
fn clone_from(&mut self, source: &Self)
```

--------------------------------

### Clone UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Creates a duplicate of the UninitializedStateMachine. This implementation requires that the underlying state machine type `M` and its state also implement `Clone`.

```Rust
fn clone(&self) -> Self
```

--------------------------------

### Attach Subscriber

Source: https://docs.rs/statig/latest/statig/enum

Attaches a provided `Subscriber` to a type, returning a `WithDispatch` wrapper. This is used for integrating with subscriber-based tracing systems.

```Rust
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
```

--------------------------------

### Try Convert T to U

Source: https://docs.rs/statig/latest/statig/enum

Attempts a conversion from type `T` to type `U`, returning a `Result`. This is the inverse of `try_from` and relies on `TryFrom<T>`.

```Rust
type Error = <U as TryFrom<T>>::Error
```

```Rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### DowncastSync Implementation for Blanket DowncastSync

Source: https://docs.rs/statig/latest/statig/blocking/struct

Provides `DowncastSync` implementations for types that are `Any`, `Send`, and `Sync`. This allows thread-safe downcasting of `Arc<Trait>` to `Arc<Any>`.

```Rust
fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync> where T: Any + Send + Sync;
```

--------------------------------

### Instrument with Span

Source: https://docs.rs/statig/latest/statig/enum

Instruments a type with a provided `Span`, returning an `Instrumented` wrapper. This is used for tracing and performance monitoring.

```Rust
fn instrument(self, span: Span) -> Instrumented<Self>
```

--------------------------------

### Define State Hierarchy with Superstate Method

Source: https://docs.rs/statig/latest/statig/index

Implements the `superstate` method for the `State` trait to define the hierarchical relationship between states. This method returns an optional superstate for the current state.

```Rust
impl statig::State<Blinky> for State {

    ... 

    fn superstate(&mut self) -> Option<Superstate<'_>> {
        match self {
            State::LedOn { counter } => Some(Superstate::Blinking { counter }),
            State::LedOff { counter } => Some(Superstate::Blinking { counter }),
            State::NotBlinking => None
        }
    }
}
```

--------------------------------

### Any Implementation for Blanket Any

Source: https://docs.rs/statig/latest/statig/blocking/struct

Provides the `Any` trait implementation for any type `T`. This allows for runtime type identification and downcasting, crucial for generic programming and trait objects.

```Rust
impl<T> Any for T where T: 'static + ?Sized {
    fn type_id(&self) -> TypeId {
        // Implementation using std::any::Any::type_id
    }
}
```

--------------------------------

### Downcast Implementations for Blanket Downcast

Source: https://docs.rs/statig/latest/statig/blocking/struct

Offers `Downcast` implementations for types that are `Any`. These methods enable converting trait objects (`Box<dyn Trait>`, `Rc<Trait>`, `&Trait`, `&mut Trait`) into concrete types or `dyn Any`.

```Rust
fn into_any(self: Box<T>) -> Box<dyn Any> where T: Any;
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any> where T: Any;
fn as_any(&self) -> &(dyn Any + 'static) where T: Any;
fn as_any_mut(&mut self) -> &mut (dyn Any + 'static) where T: Any;
```

--------------------------------

### Re-export Outcome in Statig

Source: https://docs.rs/statig/latest/statig/awaitable/index

This snippet demonstrates re-exporting the Outcome enum from the crate's root. It shows how to make the Outcome enum directly accessible from the top-level crate namespace.

```Rust
pub use crate::Outcome;

```

```Rust
pub use crate::Outcome::*;

```

```Rust
pub use crate::*;

```

--------------------------------

### Implement Downcast for Blanket

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Provides methods for downcasting trait objects to concrete types, including `into_any`, `into_any_rc`, `as_any`, and `as_any_mut`.

```Rust
impl<T> Downcast for T
where T: Any,
{
    fn into_any(self: Box<T>) -> Box<dyn Any> {
        // ... implementation details ...
    }
    fn into_any_rc(self: Rc<T>) -> Rc<dyn Any> {
        // ... implementation details ...
    }
    fn as_any(&self) -> &(dyn Any + 'static) {
        // ... implementation details ...
    }
    fn as_any_mut(&mut self) -> &mut (dyn Any + 'static) {
        // ... implementation details ...
    }
}
```

--------------------------------

### Implement BorrowMut for Blanket

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Provides the `borrow_mut` method for any type `T`, allowing mutable borrowing of the value.

```Rust
impl<T> BorrowMut<T> for T
where T: ?Sized,
{
    fn borrow_mut(&mut self) -> &mut T {
        // ... implementation details ...
    }
}
```

--------------------------------

### Rust WithSubscriber Trait

Source: https://docs.rs/statig/latest/statig/awaitable/struct

The `WithSubscriber` trait allows attaching a subscriber to a type, returning a `WithDispatch` wrapper. It includes methods for attaching a provided or the current default subscriber.

```Rust
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>
```

```Rust
fn with_current_subscriber(self) -> WithDispatch<Self>
```

--------------------------------

### Implement Superstate Handler Association

Source: https://docs.rs/statig/latest/statig/index

Implements the `Superstate` trait for the superstate enum, associating each superstate with its handler method. This enables shared behavior logic for nested states.

```Rust
impl statig::Superstate<Blinky> for Superstate {
    fn call_handler(&mut self, blinky: &mut Blinky, event: &Event, context: &mut ()) -> Outcome<Self> {
        match self {
            Superstate::Blinking { counter } => blinky.blinking(counter, event)
        }
    }
}
```

--------------------------------

### Implement Any for Blanket

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Provides the `type_id` method for any type `T`, allowing retrieval of its unique type identifier.

```Rust
impl<T> Any for T
where T: 'static + ?Sized,
{
    fn type_id(&self) -> TypeId {
        // ... implementation details ...
    }
}
```

--------------------------------

### Re-export Outcome Enum

Source: https://docs.rs/statig/latest/statig/blocking/index

This snippet shows how to re-export the Outcome enum and its variants from the crate's root.

```Rust
pub use crate::Outcome;
pub use crate::Outcome::*;
pub use crate::*;
```

--------------------------------

### Instrument in Current Span

Source: https://docs.rs/statig/latest/statig/enum

Instruments a type with the current `Span`, returning an `Instrumented` wrapper. This simplifies instrumentation within existing tracing contexts.

```Rust
fn in_current_span(self) -> Instrumented<Self>
```

--------------------------------

### Implement Eq for UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Indicates that `UninitializedStateMachine` implements the `Eq` trait, which is a marker trait for types that support total equality.

```Rust
impl<M> Eq for UninitializedStateMachine<M>
where
    M: IntoStateMachine + PartialEq + Eq,
    M::State: PartialEq + Eq,
{
    // No methods to implement, this is a marker trait.
}
```

--------------------------------

### Implement State Handler Association

Source: https://docs.rs/statig/latest/statig/index

Implements the `State` trait for the state enum, associating each state with its corresponding handler method. This allows the state machine to dispatch events to the correct state logic.

```Rust
impl statig::State<Blinky> for State {
    fn call_handler(&mut self, blinky: &mut Blinky, event: &Event, context: &mut ()) -> Outcome<Self> {
        match self {
            State::LedOn { counter } => blinky.led_on(counter, event),
            State::LedOff { counter } => blinky.led_off(counter, event),
            State::NotBlinking => blinky.not_blinking(event)
        }
    }
}
```

--------------------------------

### Implement Borrow for Blanket

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Provides the `borrow` method for any type `T`, allowing immutable borrowing of the value.

```Rust
impl<T> Borrow<T> for T
where T: ?Sized,
{
    fn borrow(&self) -> &T {
        // ... implementation details ...
    }
}
```

--------------------------------

### Rust TryInto Trait

Source: https://docs.rs/statig/latest/statig/blocking/struct

The `TryInto` trait provides a fallible conversion from one type to another, built upon `TryFrom`. It includes an `Error` type and a `try_into` method.

```Rust
type Error = <U as TryFrom<T>>::Error
```

```Rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Implement DowncastSync for Blanket

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Provides `into_any_arc` for downcasting `Arc<Trait>` to `Arc<Any>`, specifically for types that are `Send` and `Sync`.

```Rust
impl<T> DowncastSync for T
where T: Any + Send + Sync,
{
    fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Send + Sync> {
        // ... implementation details ...
    }
}
```

--------------------------------

### Rust TryInto Trait

Source: https://docs.rs/statig/latest/statig/awaitable/struct

The `TryInto` trait provides a fallible conversion from one type to another, built upon `TryFrom`. It includes an `Error` type and a `try_into` method.

```Rust
type Error = <U as TryFrom<T>>::Error
```

```Rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Rust Attribute Macro superstate

Source: https://docs.rs/statig/latest/statig/attr

The `superstate` attribute macro is used for tagging a superstate in the statig framework. It is available only when the 'macro' feature is enabled. This macro is detected by the `state_machine` macro and can be configured with attributes to set the superstate's name, parent superstate, entry and exit actions, and local storage.

```Rust
#[superstate]
#[superstate(name = "CustomSuperstateName")]
#[superstate(superstate = "superstate_name")]
#[superstate(entry_action = "entry_action_name")]
#[superstate(exit_action = "exit_action_name")]
#[superstate(local_storage("field_name_a: &'a mut FieldTypeA"))]
```

--------------------------------

### Convert T to T

Source: https://docs.rs/statig/latest/statig/enum

A simple conversion function that returns the argument unchanged. This is a basic implementation of the `From` trait.

```Rust
fn from(t: T) -> T
```

--------------------------------

### Implement Deref for UninitializedStateMachine

Source: https://docs.rs/statig/latest/statig/awaitable/struct

Provides the `Target` type and the `deref` method for the `UninitializedStateMachine` struct, allowing it to be dereferenced to its target type.

```Rust
impl<M> Deref for UninitializedStateMachine<M>
where M: IntoStateMachine,
{
    type Target = M;
    fn deref(&self) -> &Self::Target {
        // ... implementation details ...
    }
}
```

--------------------------------

### Cast to dyn Any

Source: https://docs.rs/statig/latest/statig/enum

Provides a method to cast a type to a `dyn Any` trait object. This is a fundamental operation for dynamic typing in Rust.

```Rust
fn as_any(&self) -> &(dyn Any + 'static)
```
Tokens:
Raw