added methods on buiilder

src/executor.rs

@@ -6,7 +6,10 @@ use std::{
 
 use crate::{Algorithm, Maze, Pos};
 
-use self::builder::{new_builder, BuildableMazeState, ExecutorBuilder, Unprovided};
+use self::builder::{
+    maze_state::{BuildableMazeState, Unprovided},
+    new_builder, ExecutorBuilder,
+};
 
 /// A guess to pass to the current [`Executor`] at the end of every `progress` call.
 pub struct Guess(Vec<Pos>);
@@ -112,7 +115,7 @@ where
         F: Fn(ExecutorBuilder<Unprovided>) -> ExecutorBuilder<MS>,
     {
         let operation = builder;
-        let mut builder = (operation)(new_builder());
+        let builder = (operation)(new_builder());
         let (maze, delay) = builder.build();
         Self::new(maze, algorithm, delay)
     }

src/executor/builder.rs

@@ -2,37 +2,59 @@ use std::time::Duration;
 
 use crate::{labyrinth::generator::MazeGenerator, Maze};
 
-pub trait MazeState {}
+use self::maze_state::{BuildableMazeState, Generated, MazeState, Provided, Unprovided};
-pub trait BuildableMazeState: MazeState {
+
+pub mod maze_state {
+
+    use crate::{labyrinth::generator::MazeGenerator, Maze};
+
+    pub trait MazeState {}
+    pub trait BuildableMazeState: MazeState {
         fn get(self) -> Maze;
-}
+    }
 
-pub struct Unprovided;
+    pub struct Unprovided;
 
-impl MazeState for Unprovided {}
+    impl MazeState for Unprovided {}
 
-struct Provided {
+    pub struct Provided {
         maze: Maze,
-}
+    }
 
-impl MazeState for Provided {}
+    impl Provided {
-impl BuildableMazeState for Provided {
+        pub fn new(maze: Maze) -> Self {
+            Self { maze }
+        }
+    }
+
+    impl MazeState for Provided {}
+    impl BuildableMazeState for Provided {
         fn get(self) -> Maze {
             self.maze
         }
-}
+    }
 
-struct Generated {
+    pub struct Generated {
         generator: Box<dyn MazeGenerator>,
-}
+    }
 
-impl MazeState for Generated {}
+    impl Generated {
-impl BuildableMazeState for Generated {
+        pub fn new<G>(generator: G) -> Self
+        where
+            G: MazeGenerator + 'static,
+        {
+            let generator = Box::new(generator);
+            Self { generator }
+        }
+    }
+
+    impl MazeState for Generated {}
+    impl BuildableMazeState for Generated {
         fn get(mut self) -> Maze {
             self.generator.generate()
         }
+    }
 }
-
 pub struct ExecutorBuilder<MS>
 where
     MS: MazeState,
@@ -48,6 +70,40 @@ pub fn new_builder() -> ExecutorBuilder<Unprovided> {
     }
 }
 
+impl<MS: MazeState> ExecutorBuilder<MS> {
+    pub fn maze(self, maze: Maze) -> ExecutorBuilder<Provided> {
+        let Self {
+            delay,
+            maze_state: _,
+        } = self;
+        ExecutorBuilder {
+            delay,
+            maze_state: Provided::new(maze),
+        }
+    }
+    pub fn generated<G>(self, generator: G) -> ExecutorBuilder<Generated>
+    where
+        G: MazeGenerator + 'static,
+    {
+        let Self {
+            delay,
+            maze_state: _,
+        } = self;
+        ExecutorBuilder {
+            delay,
+            maze_state: Generated::new(generator),
+        }
+    }
+    pub fn delay_ms(self, delay: u64) -> Self {
+        let delay = Duration::from_millis(delay);
+        let Self {
+            maze_state,
+            delay: _,
+        } = self;
+        Self { maze_state, delay }
+    }
+}
+
 impl<MS: BuildableMazeState> ExecutorBuilder<MS> {
     pub fn build(self) -> (Maze, Duration) {
         let maze = self.maze_state.get();