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` operator can be overloaded with the Add`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`main, we can use`, we can use +`+on our two` on our two Point`Points, since we’ve implemented`s, since we’ve implemented
Add<Output=Point>`Add
There are a number of operators that can be overloaded this way, and all of
their associated traits live in the std::ops`std::ops` module. Check out its
documentation for the full list.
Implementing these traits follows a pattern. Let’s look at Add`Add` in more
detail:
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`impl Addfor,` for, RHS`RHS, which defaults to`,
which defaults to Self`Self, and`, and Output`Output. For an expression`. For an expression let z = x + y`let z = x + y,`, x`xis the`
is the Self`Selftype,` type, y`yis the RHS, and` is the RHS, and z`zis the` is the Self::Output`Self::Output` type.
impl Add<i32> for Point { type Output = f64; fn add(self, rhs: i32) -> f64 { // add an i32 to a Point and get an f64 } }
will let you do this:
fn main() { let p: Point = // ... let x: f64 = p + 2i32; }let p: Point = // ... let x: f64 = p + 2i32;