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;