More operator overloading

2019/11/src/main.rs

@@ -10,7 +10,7 @@ struct Robot {
 
 impl Robot {
     fn mov(&mut self) {
-        self.position.mov(&self.direction);
+        self.position += self.direction;
     }
 
     fn paint(&mut self, color: i64) {

2019/grid/Cargo.toml

@@ -8,3 +8,4 @@ edition = "2018"
 
 [dependencies]
 itertools = "0.8.2"
+impl_ops = "0.1.1"

2019/grid/src/lib.rs

@@ -2,7 +2,10 @@ use itertools::join;
 use std::collections::HashMap;
 use std::fmt::Display;
 use std::hash::BuildHasher;
-use std::ops::{Add, AddAssign};
+use std::ops::AddAssign;
+#[macro_use]
+extern crate impl_ops;
+use std::ops;
 
 #[derive(Hash, PartialEq, Eq, Debug, Clone, Copy)]
 pub struct Position2D {
@@ -75,15 +78,28 @@ impl Direction {
     }
 }
 
-impl Position2D {
-    pub fn mov(&mut self, dir: &Direction) {
-        *self = *self
-            + match dir {
-                Direction::Up => (0, 1).into(),
-                Direction::Right => (1, 0).into(),
-                Direction::Left => (-1, 0).into(),
-                Direction::Down => (0, -1).into(),
-            }
+impl_op!(+ |a: Position2D, b: Position2D| -> Position2D {
+    Position2D {
+        x: a.x + b.x,
+        y: a.y + b.y }
+});
+impl_op!(-|a: Position2D, b: Position2D| -> Position2D {
+    Position2D {
+        x: a.x - b.x,
+        y: a.y - b.y,
+    }
+});
+impl_op!(+ |a: Position2D, b: Direction| -> Position2D { a + match b {
+            Direction::Up => Position2D::from((0, 1)),
+            Direction::Right => Position2D::from((1, 0)),
+            Direction::Left => Position2D::from((-1, 0)),
+            Direction::Down => Position2D::from((0, -1)),
+        }
+});
+
+impl AddAssign<Direction> for Position2D {
+    fn add_assign(&mut self, rhs: Direction) {
+        *self = *self + rhs;
     }
 }
 
@@ -93,17 +109,6 @@ impl AddAssign for Position2D {
     }
 }
 
-impl Add for Position2D {
-    type Output = Position2D;
-
-    fn add(self, rhs: Position2D) -> Position2D {
-        Position2D {
-            x: self.x + rhs.x,
-            y: self.y + rhs.y,
-        }
-    }
-}
-
 impl From<(i64, i64)> for Position2D {
     fn from(tuple: (i64, i64)) -> Position2D {
         Position2D {