Operators and Overloading
Rust allows for a limited form of operator overloading. There are certain operators that are able to be overloaded. To support a particular operator between types, there’s a specific trait that you can implement, which then overloads the operator.
For example, the + operator can be overloaded with the Add trait:
use std::ops::Add; #[derive(Debug)] struct Point { x: i32, y: i32, } impl Add for Point { type Output = Point; fn add(self, other: Point) -> Point { Point { x: self.x + other.x, y: self.y + other.y } } } fn main() { let p1 = Point { x: 1, y: 0 }; let p2 = Point { x: 2, y: 3 }; let p3 = p1 + p2; println!("{:?}", p3); }
In main, we can use + on our two Points, since we’ve implemented
Add<Output=Point> for Point.
There are a number of operators that can be overloaded this way, and all of
their associated traits live in the std::ops module. Check out its
documentation for the full list.
Implementing these traits follows a pattern. Let’s look at Add in more
detail:
# #![allow(unused_variables)] #fn main() { # mod foo { pub trait Add<RHS = Self> { type Output; fn add(self, rhs: RHS) -> Self::Output; } # } #}
There’s three types in total involved here: the type you impl Add for, RHS,
which defaults to Self, and Output. For an expression let z = x + y, x
is the Self type, y is the RHS, and z is the Self::Output type.
# #![allow(unused_variables)] #fn main() { # struct Point; # use std::ops::Add; impl Add<i32> for Point { type Output = f64; fn add(self, rhs: i32) -> f64 { // Add an i32 to a Point and get an f64. # 1.0 } } #}
will let you do this:
let p: Point = // ...
let x: f64 = p + 2i32;
Using operator traits in generic structs
Now that we know how operator traits are defined, we can define our HasArea
trait and Square struct from the traits chapter more generically:
use std::ops::Mul; trait HasArea<T> { fn area(&self) -> T; } struct Square<T> { x: T, y: T, side: T, } impl<T> HasArea<T> for Square<T> where T: Mul<Output=T> + Copy { fn area(&self) -> T { self.side * self.side } } fn main() { let s = Square { x: 0.0f64, y: 0.0f64, side: 12.0f64, }; println!("Area of s: {}", s.area()); }
For HasArea and Square, we declare a type parameter T and replace
f64 with it. The impl needs more involved modifications:
impl<T> HasArea<T> for Square<T>
where T: Mul<Output=T> + Copy { ... }
The area method requires that we can multiply the sides, so we declare that
type T must implement std::ops::Mul. Like Add, mentioned above, Mul
itself takes an Output parameter: since we know that numbers don't change
type when multiplied, we also set it to T. T must also support copying, so
Rust doesn't try to move self.side into the return value.