Formatted with cargo fmt --all

rstm/src/programs/program.rs

@@ -54,8 +54,6 @@ impl<Q> Program<Q> {
     pub fn push(&mut self, instruction: Instruction<Q>) {
         self.instructions.push(instruction);
     }
-
-
 }
 
 impl<T> Extend<Instruction<T>> for Program<T> {

rstm/src/state/mod.rs

@@ -11,7 +11,6 @@ pub(crate) mod prelude {
     pub use crate::state::{State, Transition};
 }
 
-
 #[allow(unused)]
 #[doc(hidden)]
 mod private {
@@ -31,26 +30,13 @@ mod private {
         Future(T),
     }
 
-    pub enum StateGroup<S> where S: State {
-        A {
-            prev: S,
-            curr: S,
-        },
-        B {
-            curr: S,
-            next: S,
-        },
-        C {
-            prev: S,
-            next: S,
-        },
-        D {
-            prev: S,
-            curr: S,
-            next: S,
-        }
+    pub enum StateGroup<S>
+    where
+        S: State,
+    {
+        A { prev: S, curr: S },
+        B { curr: S, next: S },
+        C { prev: S, next: S },
+        D { prev: S, curr: S, next: S },
     }
-
-
-
-}
+}

rstm/src/turing/context.rs

@@ -0,0 +1 @@
+

rstm/src/turing/machine.rs

@@ -26,7 +26,10 @@ impl<T> Context<T> {
     }
 
     pub fn with_transitions(self, transitions: Vec<Transition<T>>) -> Self {
-        Self { transitions, ..self }
+        Self {
+            transitions,
+            ..self
+        }
     }
 
     pub fn initial_state(&self) -> &State<T> {
@@ -40,8 +43,6 @@ impl<T> Context<T> {
     pub fn transitions(&self) -> &Vec<Transition<T>> {
         &self.transitions
     }
-
-
 }
 
 ///
@@ -53,11 +54,7 @@ pub struct TuringMachine {
 }
 
 impl TuringMachine {
-    pub fn new(
-        initial_state: State,
-        tape: Tape,
-        transforms: Vec<Transition>,
-    ) -> Self {
+    pub fn new(initial_state: State, tape: Tape, transforms: Vec<Transition>) -> Self {
         let ctx = Context::new(initial_state.clone());
         let mut transitions = Registry::new();
         for trs in transforms {
@@ -67,8 +64,6 @@ impl TuringMachine {
             );
         }
 
-
-
         TuringMachine {
             cstate: initial_state,
             ctx,
@@ -89,8 +84,6 @@ impl TuringMachine {
         &self.tape
     }
 
-
-
     pub fn step(&mut self) -> Result<(), FsmError> {
         let cursor = self.cstate.clone();
         let current_symbol = *self.tape.read()?;

rstm/src/types/direction.rs

@@ -43,10 +43,7 @@ impl IntoDirection for &str {
     strum::EnumIter,
     strum::VariantNames,
 )]
-#[cfg_attr(
-    feature = "serde",
-    derive(serde::Deserialize, serde::Serialize),
-)]
+#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 #[repr(i8)]
 #[strum(serialize_all = "lowercase")]
 pub enum Direction {

rstm/src/types/parts.rs

@@ -5,8 +5,8 @@
 use crate::prelude::{Direction, State};
 
 /// The head of a turing machine generally speaks to the current state and symbol of the machine
-/// w.r.t. the [tape](crate::types::Tape). Currently, the head simply stores a reference to the 
-/// 
+/// w.r.t. the [tape](crate::types::Tape). Currently, the head simply stores a reference to the
+///
 #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Ord, PartialOrd)]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
 pub struct Head<T> {