forward_ref_generic
This crate serves as a standalone extension of forward_ref to optionally support generics.
The forward_ref_* macros are macros used by the rust's core library to more easily implement Operations on primitive types.
When implementing an operation op like Add or Mul for a type T, the std::ops documentation recommends implementing the operation not just for T op T but also for T op &T, &T op T and &T op &T.
In practice, the implementations of those variants for Copy types is somewhat trivial and cumbersome to do.
Since those trivial implementations are basically the same for all Copy types, one can use the forward_ref_* macros to get them implemented automatically.
There are existing solutions for this (one of them the aforementioned forwardref crate, as well as implops), however none of them (or at least none I could find) support generic types.
That is to say, if one has a type like Point<T> {x: T, y: T}, so far it was necessary to implement all variants by hand.
This crate offers macros that also support generic types, including trait bounds, so the only assumption left is that the type the operation is implemented on is Copy.
There are seperate macros offered for types of operations:
* Unary Operators like Neg: forward_ref_unop
* Binary Operators like Add: forward_ref_binop
* Assignment Operators like AddAssign: forward_ref_op_assign
Add this to your Cargo.toml:
toml
[dependencies]
forward_ref_generic = "0.1"
For usage of the macros, refer to the documentation or see the examples below.
std::ops's Point exampleLet's use the std::ops's Point example to see how one would usually implement this, and how it can instead be done using forward_ref_* macros:
```rust
use std::ops::Add;
struct Point { x: i32, y: i32, }
impl Add for Point { type Output = Self;
fn add(self, rhs: Self) -> Self::Output {
Self {x: self.x + rhs.x, y: self.y + rhs.y}
}
} ```
At this point, one can add two points together like so:
rust
let p1 = Point { x: 3, y: 3 };
let p2 = Point { x: 5, y: 2 };
assert_eq!(p1 + p2, Point { x: 8, y: 5 });
However, using the operator on references will not compile:
rust
let p3 = &p2;
assert_eq!(p1 + &p2, Point { x: 8, y: 5 }); // ✖ does not compile
assert_eq!(p1 + p3, Point { x: 8, y: 5 }); // ✖ does not compile
assert_eq!(p1 + *p3, Point { x: 8, y: 5 }); // ✔ compiles
To fix this, one would need to implement Add<&Point> for Point:
```rust impl Add<&Point> for Point { type Output = Self;
fn add(self, rhs: &Self) -> Self::Output {
Self::add(self, *rhs)
}
}
let p3 = &p2; asserteq!(p1 + &p2, Point { x: 8, y: 5 }); asserteq!(p1 + p3, Point { x: 8, y: 5 }); ```
And now we would have to add implementations for &Point + Point and &Point + &Point as well.
But that is very verbose and annoying to do.
Instead, we can use forward_ref_binop:
```rust use forwardrefgeneric::forwardrefbinop;
forwardrefbinop! { impl Add for Point }
let p1 = Point { x: 3, y: 3 }; let p2 = Point { x: 5, y: 2 }; asserteq!(p1 + p2, Point { x: 8, y: 5 }); asserteq!(p1 + &p2, Point { x: 8, y: 5 }); asserteq!(&p1 + p2, Point { x: 8, y: 5 }); asserteq!(&p1 + &p2, Point { x: 8, y: 5 }); ```
Let's generalize our Point struct so that it supports members of any type.
We can still use forward_ref_binop in that case, but we'll need to tell the macro which generics we used.
We will also need to tell it all trait bounds that are required.
Note that, for technical reasons, we'll need to add angled brackets [] around the list of generics.
```rust use std::ops::Add; use forwardrefgeneric::forwardrefbinop;
struct Point
impl
fn add(self, rhs: Self) -> Self::Output {
Self {x: self.x + rhs.x, y: self.y + rhs.y}
}
}
// for the exact syntax required by each macro, refer to the macro's documentation page
forwardrefbinop! {
[T]
impl Add for Point
let p1 = Point { x: 3, y: 3 }; let p2 = Point { x: 5, y: 2 }; asserteq!(p1 + p2, Point { x: 8, y: 5 }); asserteq!(p1 + &p2, Point { x: 8, y: 5 }); asserteq!(&p1 + p2, Point { x: 8, y: 5 }); asserteq!(&p1 + &p2, Point { x: 8, y: 5 }); ```
So far, the right hand side of the operation was of the same type as the left hand side.
But forward_ref_* macros also optionally support defining a different right hand side.
To do so, simply add the RHS-type right after the LHS type like so:
rust
forward_ref_binop! {
[generics...]
impl OP for LHS, RHS
where ...
}
To demonstrate this in action, we'll use a generic Stack-Matrix and implement Mul on it:
```rust use std::ops::{Add, Mul}; use forwardrefgeneric::forwardrefbinop;
struct Matrix
impl
fn mul(self, rhs: Matrix<T, N, L>) -> Self::Output {
// ...
}
}
forwardrefbinop! {
[T, const M: usize, const N: usize, const L: usize]
impl Mul for Matrix
let m1 = Matrix {m: [[1, 2, 2], [2, 1, 2]]}; let m2 = Matrix {m: [[0, 1], [1, 1], [2, 1]]};
asserteq!(m1 * m2, Matrix {m: [[6, 5], [5, 5]]}); asserteq!(m1 * &m2, Matrix {m: [[6, 5], [5, 5]]}); asserteq!(&m1 * m2, Matrix {m: [[6, 5], [5, 5]]}); asserteq!(&m1 * &m2, Matrix {m: [[6, 5], [5, 5]]}); ```
Notice that in all previous examples, all information the macro required on which operation is supposed to be implemented was the Trait's name. This is done by specifically checking for known Operator Traits and inserting the required method's name from inside the macro. This is currently only done for standard mathematical operators (i.e. not for bitwise operators and not for custom operators). However, one can still use the macros, but the method's name has to be specified in that case. RHS can again be omitted if LHS = RHS:
rust
forward_ref_binop! {
[generics...]
impl OP, METHOD for LHS, RHS
where ...
}
To demonstrate, we will implement the Not unary operator on the std::ops::Not's doc's Answer example:
```rust use std::ops::Not; use forwardrefgeneric::forwardrefunop;
// notice we have to add the Copy trait, as otherwise the macro will not work correctly
enum Answer { Yes, No, }
impl Not for Answer { type Output = Self;
fn not(self) -> Self::Output {
match self {
Answer::Yes => Answer::No,
Answer::No => Answer::Yes,
}
}
}
// this time we use the macro for unary operators and specify the not method's name
forwardrefunop! {
impl Not, not for Answer
}
asserteq!(!Answer::Yes, Answer::No); asserteq!(!Answer::No, Answer::Yes);
asserteq!(!&Answer::Yes, Answer::No); asserteq!(!&Answer::No, Answer::Yes); ```
It is planned to add macros that automatically make an operation commutative.