Refactor to simpler interface

As discussed here:
http://doc.rust-lang.org/std/result/enum.Result.html#variant.Err

I like the `queen.can_attack(queen2)` API a lot better. It has a
downside of `Queen::new` returning a Result, so all tests that check for
valid attacks have to call `unwrap`

Though that might just be because there's a better way to do this that I
am unaware of. I'm still quite new to Rust, especially the
error-handling part of it.

The us of `is_err` was recommended by Manishearth in this thread
https://users.rust-lang.org/t/what-am-i-not-understanding-about-result/5143/11?u=ianwhitney

Author: whit0694

exercises/queen-attack/example.rs

@@ -1,48 +1,40 @@
 #[derive(Debug, PartialEq)]
-pub struct Queen {
-    position: (i8, i8)
-}
-
-#[derive(Debug, PartialEq)]
-pub struct InvalidQueen;
+pub struct Queen { position: (i8, i8) }
 
 impl Queen {
-    pub fn new(position: (i8, i8)) -> Result<Queen, InvalidQueen> {
-        if (position.0 < 0 || position.0 > 7) || (position.1 < 0 || position.1 >7 ) {
-            Err(InvalidQueen)
+    pub fn new(position: (i8, i8)) -> Queen {
+        Queen { position: position }
+    }
+
+    pub fn can_attack(&self, piece: Queen) -> Result<bool, ()> {
+        if self.position_valid() && piece.position_valid() {
+            Ok(self.rank() == piece.rank() ||
+               self.file() == piece.file() ||
+               self.sum() == piece.sum() ||
+               self.difference() == piece.difference())
         } else {
-            Ok(Queen {position: position})
+            Err(())
         }
     }
-}
 
-pub struct Queens {
-    first: Queen,
-    second: Queen
-}
+    fn position_valid(&self) -> bool {
+        (self.rank() >= 0 && self.rank() <= 7) &&
+        (self.file() >= 0 && self.file() <= 7)
+    }
 
-impl Queens {
-    pub fn new(first: Result<Queen, InvalidQueen>, second: Result<Queen, InvalidQueen>) -> Queens {
-        Queens {
-            first: first.unwrap(),
-            second: second.unwrap()
-        }
+    fn rank(&self) -> i8 {
+        self.position.0
     }
 
-    pub fn can_attack(&self) -> bool {
-        self.first.position.0 == self.second.position.0 ||
-            self.first.position.1 == self.second.position.1 ||
-            (
-                (self.first.position.0 + self.first.position.1)
-                ==
-                (self.second.position.0 + self.second.position.1)
-            )
-            ||
-            (
-                (self.first.position.0 - self.first.position.1)
-                ==
-                (self.second.position.0 - self.second.position.1)
-            )
+    fn file(&self) -> i8 {
+        self.position.1
+    }
+
+    fn sum(&self) -> i8 {
+        self.rank() + self.file()
+    }
 
+    fn difference(&self) -> i8 {
+        self.rank() - self.file()
     }
 }

exercises/queen-attack/tests/queen-attack.rs

@@ -6,88 +6,73 @@ use queen_attack::*;
 fn test_can_not_attack() {
     let white_queen = Queen::new((2,4));
     let black_queen = Queen::new((6,6));
-    let queens = Queens::new(white_queen, black_queen);
-    assert_eq!(false, queens.can_attack());
+    assert_eq!(false, white_queen.can_attack(black_queen).unwrap());
 }
 
 #[test]
 #[ignore]
 fn test_can_attack_on_same_rank() {
     let white_queen = Queen::new((2,4));
     let black_queen = Queen::new((2,6));
-    let queens = Queens::new(white_queen, black_queen);
-    assert!(queens.can_attack());
+    assert!(white_queen.can_attack(black_queen).unwrap());
 }
 
 #[test]
 #[ignore]
 fn test_can_attack_on_same_file() {
     let white_queen = Queen::new((4,5));
     let black_queen = Queen::new((3,5));
-    let queens = Queens::new(white_queen, black_queen);
-    assert!(queens.can_attack());
+    assert!(white_queen.can_attack(black_queen).unwrap());
 }
 
 #[test]
 #[ignore]
 fn test_can_attack_on_first_diagonal() {
     let white_queen = Queen::new((2,2));
     let black_queen = Queen::new((0,4));
-    let queens = Queens::new(white_queen, black_queen);
-    assert!(queens.can_attack());
+    assert!(white_queen.can_attack(black_queen).unwrap());
 }
 
 #[test]
 #[ignore]
 fn test_can_attack_on_second_diagonal() {
     let white_queen = Queen::new((2,2));
     let black_queen = Queen::new((3,1));
-    let queens = Queens::new(white_queen, black_queen);
-    assert!(queens.can_attack());
+    assert!(white_queen.can_attack(black_queen).unwrap());
 }
 
 #[test]
 #[ignore]
 fn test_can_attack_on_third_diagonal() {
     let white_queen = Queen::new((2,2));
     let black_queen = Queen::new((1,1));
-    let queens = Queens::new(white_queen, black_queen);
-    assert!(queens.can_attack());
+    assert!(white_queen.can_attack(black_queen).unwrap());
 }
 
 #[test]
 #[ignore]
 fn test_can_attack_on_fourth_diagonal() {
     let white_queen = Queen::new((2,2));
     let black_queen = Queen::new((5,5));
-    let queens = Queens::new(white_queen, black_queen);
-    assert!(queens.can_attack());
+    assert!(white_queen.can_attack(black_queen).unwrap());
 }
 
 #[test]
 #[ignore]
 fn test_queen_with_invalid_position() {
     let white_queen = Queen::new((-1,2));
-    match white_queen {
-        Ok(_) => panic!("This queen should be invalid"),
-        Err(_) => assert!(true)
-    }
+    let black_queen = Queen::new((5,5));
+    assert!(white_queen.can_attack(black_queen).is_err());
 
     let white_queen = Queen::new((8,2));
-    match white_queen {
-        Ok(_) => panic!("This queen should be invalid"),
-        Err(_) => assert!(true)
-    }
+    let black_queen = Queen::new((5,5));
+    assert!(white_queen.can_attack(black_queen).is_err());
 
-    let white_queen = Queen::new((2,-1));
-    match white_queen {
-        Ok(_) => panic!("This queen should be invalid"),
-        Err(_) => assert!(true)
-    }
+    let white_queen = Queen::new((2,2));
+    let black_queen = Queen::new((5,-1));
+    assert!(white_queen.can_attack(black_queen).is_err());
 
-    let white_queen = Queen::new((2,8));
-    match white_queen {
-        Ok(_) => panic!("This queen should be invalid"),
-        Err(_) => assert!(true)
-    }
+    let white_queen = Queen::new((2,2));
+    let black_queen = Queen::new((5,8));
+    assert!(white_queen.can_attack(black_queen).is_err());
 }