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` 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); }
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>`Addfor` for Point`Point`.

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:

fn main() { mod foo { pub trait Add<RHS = Self> { type Output; fn add(self, rhs: RHS) -> Self::Output; } } }
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.

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 } } }
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;