Make initial constructor a function instead of a function pointer

examples/macro/history/src/main.rs

@@ -79,7 +79,7 @@ impl Dishwasher {
 
 fn main() {
     let mut state_machine = Dishwasher {
-        previous_state: Dishwasher::INITIAL,
+        previous_state: Dishwasher::initial(),
     }
     .uninitialized_state_machine()
     .init();

examples/no_macro/basic/src/main.rs

@@ -30,7 +30,9 @@ impl IntoStateMachine for Blinky {
     type Context<'ctx> = ();
 
     /// The initial state of the state machine.
-    const INITIAL: State = State::Off;
+    fn initial() -> Self::State {
+        State::Off
+    }
 
     /// This method is called on every transition of the state machine.
     const ON_TRANSITION: fn(&mut Self, &Self::State, &Self::State) = |_, source, target| {

examples/no_macro/bench/src/main.rs

@@ -49,7 +49,9 @@ impl IntoStateMachine for CdPlayer {
     type Context<'ctx> = ();
 
     /// The initial state of the state machine.
-    const INITIAL: State = State::Empty;
+    fn initial() -> Self::State {
+        State::Empty
+    }
 }
 
 impl blocking::State<CdPlayer> for State {

examples/no_macro/blinky/src/main.rs

@@ -41,7 +41,9 @@ impl IntoStateMachine for Blinky {
     type Context<'ctx> = ();
 
     /// The initial state of the state machine.
-    const INITIAL: State = State::LedOn;
+    fn initial() -> State {
+        State::LedOn
+    }
 }
 
 // Implement the `statig::State` trait for the state enum.

examples/no_macro/calculator/src/state.rs

@@ -66,7 +66,9 @@ impl blocking::IntoStateMachine for Calculator {
 
     type Context<'ctx> = ();
 
-    const INITIAL: State = State::Begin;
+    fn initial() -> Self::State {
+        State::Begin
+    }
 }
 
 impl blocking::State<Calculator> for State {

examples/no_macro/history/src/main.rs

@@ -36,7 +36,9 @@ impl IntoStateMachine for Dishwasher {
 
     type Context<'ctx> = ();
 
-    const INITIAL: State = State::Idle;
+    fn initial() -> Self::State {
+        State::Idle
+    }
 
     // On every transition we update the previous state, so we can
     // transition back to it.
@@ -135,7 +137,7 @@ impl Dishwasher {
 
 fn main() {
     let mut state_machine = Dishwasher {
-        previous_state: Dishwasher::INITIAL,
+        previous_state: Dishwasher::initial(),
     }
     .uninitialized_state_machine()
     .init();

macro/src/codegen.rs

@@ -100,7 +100,10 @@ fn codegen_state_machine_impl(ir: &Ir) -> ItemImpl {
             type Context<#context_lifetime> = #context_type;
             type State = #state_ident #state_generics;
             type Superstate<#superstate_lifetime> = #superstate_ident #superstate_generics ;
-            const INITIAL: #state_ident #state_generics = #initial_state;
+
+            fn initial() -> #state_ident #state_generics {
+                #initial_state
+            }
 
             #on_transition
 

statig/src/awaitable/into_state_machine.rs

@@ -22,7 +22,7 @@ where
         Self::State: 'sub;
 
     /// Initial state of the state machine.
-    const INITIAL: Self::State;
+    fn initial() -> Self::State;
 
     /// Method that is called *before* an event is dispatched to a state or
     /// superstate handler.

statig/src/awaitable/state_machine.rs

@@ -15,7 +15,7 @@ where
     {
         let inner = Inner {
             shared_storage: self,
-            state: Self::INITIAL,
+            state: Self::initial(),
         };
         StateMachine {
             inner,
@@ -28,7 +28,7 @@ where
     fn uninitialized_state_machine(self) -> UninitializedStateMachine<Self> {
         let inner = Inner {
             shared_storage: self,
-            state: Self::INITIAL,
+            state: Self::initial(),
         };
         UninitializedStateMachine { inner }
     }
@@ -154,7 +154,7 @@ where
     fn default() -> Self {
         let inner = Inner {
             shared_storage: M::default(),
-            state: M::INITIAL,
+            state: M::initial(),
         };
         Self {
             inner,

statig/src/blocking/into_state_machine.rs

@@ -20,7 +20,7 @@ where
         Self::State: 'sub;
 
     /// Initial state of the state machine.
-    const INITIAL: Self::State;
+    fn initial() -> Self::State;
 
     /// Method that is called *before* an event is dispatched to a state or
     /// superstate handler.

statig/src/blocking/state_machine.rs

@@ -14,7 +14,7 @@ where
     {
         let inner = Inner {
             shared_storage: self,
-            state: Self::INITIAL,
+            state: Self::initial(),
         };
         StateMachine {
             inner,
@@ -27,7 +27,7 @@ where
     fn uninitialized_state_machine(self) -> UninitializedStateMachine<Self> {
         let inner = Inner {
             shared_storage: self,
-            state: Self::INITIAL,
+            state: Self::initial(),
         };
         UninitializedStateMachine { inner }
     }
@@ -148,7 +148,7 @@ where
     fn default() -> Self {
         let inner = Inner {
             shared_storage: M::default(),
-            state: M::INITIAL,
+            state: M::initial(),
         };
         Self {
             inner,

statig/src/state_or_superstate.rs

@@ -1,4 +1,5 @@
-use core::fmt::Debug;
+use core::fmt;
+use core::fmt::{Debug, Formatter};
 
 /// Holds a reference to either a state or superstate.
 pub enum StateOrSuperstate<'a, State, Superstate> {
@@ -8,12 +9,12 @@ pub enum StateOrSuperstate<'a, State, Superstate> {
     Superstate(&'a Superstate),
 }
 
-impl<'a, State, Superstate> core::fmt::Debug for StateOrSuperstate<'a, State, Superstate>
+impl<'a, State, Superstate> Debug for StateOrSuperstate<'a, State, Superstate>
 where
     State: Debug,
     Superstate: Debug,
 {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         match self {
             Self::State(state) => f.debug_tuple("State").field(state as &dyn Debug).finish(),
             Self::Superstate(superstate) => f

statig/tests/async_transition.rs

@@ -58,7 +58,9 @@ mod tests {
 
         type Context<'ctx> = ();
 
-        const INITIAL: State = State::S11;
+        fn initial() -> Self::State {
+            State::S11
+        }
     }
 
     impl awaitable::State<Foo> for State {

statig/tests/state_local_storage.rs

@@ -24,15 +24,17 @@ mod tests {
         type Context<'ctx> = ();
 
         /// The initial state of the state machine.
-        const INITIAL: StateEnum = StateEnum::On {
-            led: false,
-            counter: 23,
-        };
+        fn initial() -> Self::State {
+            StateEnum::On {
+                led: false,
+                counter: 23,
+            }
+        }
     }
 
     impl Default for StateEnum {
         fn default() -> Self {
-            Blinky::INITIAL
+            Blinky::initial()
         }
     }
 

statig/tests/transition.rs

@@ -55,7 +55,9 @@ mod tests {
 
         type Context<'ctx> = ();
 
-        const INITIAL: State = State::S11;
+        fn initial() -> Self::State {
+            State::S11
+        }
     }
 
     impl blocking::State<Foo> for State {