Operators and Overloading - The Rust Programming Language

You are reading an outdated edition of TRPL. For more, go here.

# 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 `Point`s, 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.