% 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:
# 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.
# 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.