Update stub push towards immutable robots

As mentioned here:
exercism#146 (comment)

I like the idea of pushing towards a solution with immutable robots.
It's a different way of using structs than our other exercises do. As a
side benefit, it shortens the test functions.

Students can always edit the test file or the stub file, if they so
wish. So they could still implement mutable robots, though I don't think
many (or any, probably) will do so.

Author: whit0694

exercises/robot-simulator/src/lib.rs

@@ -13,19 +13,19 @@ impl Robot {
         unimplemented!()
     }
 
-    pub fn turn_right(&mut self) {
+    pub fn turn_right(self) -> Self {
         unimplemented!()
     }
 
-    pub fn turn_left(&mut self) {
+    pub fn turn_left(self) -> Self {
         unimplemented!()
     }
 
-    pub fn advance(&mut self) {
+    pub fn advance(self) -> Self {
         unimplemented!()
     }
 
-    pub fn instructions(&mut self, instructions: &str) {
+    pub fn instructions(self, instructions: &str) -> Self {
         unimplemented!()
     }
 

exercises/robot-simulator/tests/robot-simulator.rs

@@ -20,146 +20,128 @@ fn positions_can_be_negative() {
 #[test]
 #[ignore]
 fn turning_right_does_not_change_position() {
-    let mut robot = Robot::new(0, 0, &Direction::North);
-    robot.turn_right();
+    let robot = Robot::new(0, 0, &Direction::North).turn_right();
     assert_eq!((0, 0), robot.position());
 }
 
 #[test]
 #[ignore]
 fn turning_right_from_north_points_the_robot_east() {
-    let mut robot = Robot::new(0, 0, &Direction::North);
-    robot.turn_right();
+    let robot = Robot::new(0, 0, &Direction::North).turn_right();
     assert_eq!(Direction::East, robot.direction());
 }
 
 #[test]
 #[ignore]
 fn turning_right_from_east_points_the_robot_south() {
-    let mut robot = Robot::new(0, 0, &Direction::East);
-    robot.turn_right();
+    let robot = Robot::new(0, 0, &Direction::East).turn_right();
     assert_eq!(Direction::South, robot.direction());
 }
 
 #[test]
 #[ignore]
 fn turning_right_from_south_points_the_robot_west() {
-    let mut robot = Robot::new(0, 0, &Direction::South);
-    robot.turn_right();
+    let robot = Robot::new(0, 0, &Direction::South).turn_right();
     assert_eq!(Direction::West, robot.direction());
 }
 
 #[test]
 #[ignore]
 fn turning_right_from_west_points_the_robot_north() {
-    let mut robot = Robot::new(0, 0, &Direction::West);
-    robot.turn_right();
+    let robot = Robot::new(0, 0, &Direction::West).turn_right();
     assert_eq!(Direction::North, robot.direction());
 }
 
 #[test]
 #[ignore]
 fn turning_left_does_not_change_position() {
-    let mut robot = Robot::new(0, 0, &Direction::North);
-    robot.turn_left();
+    let robot = Robot::new(0, 0, &Direction::North).turn_left();
     assert_eq!((0, 0), robot.position());
 }
 
 #[test]
 #[ignore]
 fn turning_left_from_north_points_the_robot_west() {
-    let mut robot = Robot::new(0, 0, &Direction::North);
-    robot.turn_left();
+    let robot = Robot::new(0, 0, &Direction::North).turn_left();
     assert_eq!(Direction::East, robot.direction());
 }
 
 #[test]
 #[ignore]
 fn turning_left_from_west_points_the_robot_south() {
-    let mut robot = Robot::new(0, 0, &Direction::East);
-    robot.turn_left();
+    let robot = Robot::new(0, 0, &Direction::East).turn_left();
     assert_eq!(Direction::South, robot.direction());
 }
 
 #[test]
 #[ignore]
 fn turning_left_from_south_points_the_robot_east() {
-    let mut robot = Robot::new(0, 0, &Direction::South);
-    robot.turn_left();
+    let robot = Robot::new(0, 0, &Direction::South).turn_left();
     assert_eq!(Direction::East, robot.direction());
 }
 
 #[test]
 #[ignore]
 fn turning_left_from_east_points_the_robot_north() {
-    let mut robot = Robot::new(0, 0, &Direction::East);
-    robot.turn_left();
+    let robot = Robot::new(0, 0, &Direction::East).turn_left();
     assert_eq!(Direction::North, robot.direction());
 }
 
 #[test]
 #[ignore]
 fn advance_does_not_change_the_direction() {
-    let mut robot = Robot::new(0, 0, &Direction::North);
-    robot.advance();
+    let robot = Robot::new(0, 0, &Direction::North).advance();
     assert_eq!(Direction::North, robot.direction());
 }
 
 #[test]
 #[ignore]
 fn advance_increases_the_y_coordinate_by_one_when_facing_north() {
-    let mut robot = Robot::new(0, 0, &Direction::North);
-    robot.advance();
+    let robot = Robot::new(0, 0, &Direction::North).advance();
     assert_eq!((0, 1), robot.position());
 }
 
 #[test]
 #[ignore]
 fn advance_decreases_the_y_coordinate_by_one_when_facing_south() {
-    let mut robot = Robot::new(0, 0, &Direction::South);
-    robot.advance();
+    let robot = Robot::new(0, 0, &Direction::South).advance();
     assert_eq!((0, -1), robot.position());
 }
 
 #[test]
 #[ignore]
 fn advance_increases_the_x_coordinate_by_one_when_facing_east() {
-    let mut robot = Robot::new(0, 0, &Direction::East);
-    robot.advance();
+    let robot = Robot::new(0, 0, &Direction::East).advance();
     assert_eq!((1, 0), robot.position());
 }
 
 #[test]
 #[ignore]
 fn advance_decreases_the_x_coordinate_by_one_when_facing_west() {
-    let mut robot = Robot::new(0, 0, &Direction::West);
-    robot.advance();
+    let robot = Robot::new(0, 0, &Direction::West).advance();
     assert_eq!((-1, 0), robot.position());
 }
 
 #[test]
 #[ignore]
 fn follow_instructions_to_move_west_and_north() {
-    let mut robot = Robot::new(0, 0, &Direction::North);
-    robot.instructions("LAAARALA");
+    let robot = Robot::new(0, 0, &Direction::North).instructions("LAAARALA");
     assert_eq!((-4, 1), robot.position());
     assert_eq!(Direction::West, robot.direction());
 }
 
 #[test]
 #[ignore]
 fn follow_instructions_to_move_west_and_south() {
-    let mut robot = Robot::new(0, 0, &Direction::East);
-    robot.instructions("RRAAAAALA");
+    let robot = Robot::new(0, 0, &Direction::North).instructions("RRAAAAALA");
     assert_eq!((-3, -8), robot.position());
     assert_eq!(Direction::South, robot.direction());
 }
 
 #[test]
 #[ignore]
 fn follow_instructions_to_move_east_and_north() {
-    let mut robot = Robot::new(0, 0, &Direction::South);
-    robot.instructions("LAAARRRALLLL");
+    let robot = Robot::new(0, 0, &Direction::North).instructions("LAAARRRALLLL");
     assert_eq!((11, 5), robot.position());
     assert_eq!(Direction::North, robot.direction());
 }