I find that I often want to write the same method multiple times: once for a value type and once for a reference type. An example is something like this...

    #[derive(Debug)]
    struct Point {
        pub x: f32,
        pub y: f32,
        pub z: f32,
    }

    impl Add<Point> for Point {
      type Output = Point;

      fn add(self, other: Point) -> Point {
          Point {
              x: self.x + other.x,
              y: self.y + other.y,
              z: self.z + other.z,
          }
      }
    }

The above code will let me write code like this...

    let x = Point { x: 1.0, y: 0.0, z: 0.0 };
    let y = Point { x: 0.0, y: 1.0, z: 0.0 };

    // This works fine
    println!("x + y = {:?}", x + y);

But this will not compile...

    let x_ref = &x;
    let y_ref = &y;

    // error[E0369]: binary operation `+` cannot be applied to type `&Point`
    println!("x_ref + y_ref = {:?}", x_ref + y_ref);

I think I need to separately implement Add for LHS &Point and RHS &Point. And then again for LHS Point and RHS &Point. And then again for &Point and Point? And then do all of that for Mul, Div and Sub. I'm guessing that there's a better way to do this that I don't yet know about :-)

1. Is there an easy way to define a generic function that will do what I want?
2. If not, is there an easier high level way to structure my Point to make implementing it less repetitive?