Rust by Example

27 Operator Overloading

In Rust, many of the operators can be overloaded via traits. This is possible because operators are just sugar for method calls. For example, a + b desugars to a.add(b). This add method is part of the Add trait; hence, any implementor of the Add trait will be able to use the + operator.

use std::ops::Add; struct Foo; struct Bar; #[derive(Debug)] struct FooBar; #[derive(Debug)] struct BarFoo; // The `Add<T, U>` trait needs two generic parameters: // * T is the type of the RHS summand, and // * U is the type of the sum // This block implements the operation: Foo + Bar = FooBar impl Add<Bar> for Foo { type Output = FooBar; fn add(self, _rhs: Bar) -> FooBar { println!("> Foo.add(Bar) was called"); FooBar } } // Addition can be implemented in a non-commutative way // This block implements the operation: Bar + Foo = BarFoo impl Add<Foo> for Bar { type Output = BarFoo; fn add(self, _rhs: Foo) -> BarFoo { println!("> Bar.add(Foo) was called"); BarFoo } } fn main() { println!("Foo + Bar = {:?}", Foo + Bar); println!("Bar + Foo = {:?}", Bar + Foo); }

Here is a list of the traits that overload operators.