Sobrecargar operadores

En Rust, muchos de los operadores pueden ser sobrecargados a través de rasgos. Es decir, algunos operadores se pueden utilizar para realizar diferentes tareas en función de sus argumentos de entrada. Esto es posible porque los operadores son azúcares sintácticos para las llamadas a métodos. Por ejemplo, el operador + en a + b llama al método add (como en a.add(b)). Este método add es parte del rasgo Add. Por lo tanto, el operador + puede ser utilizado por cualquier implementador del rasgo Add.

Una lista de los rasgos, como Add, que los operadores de sobrecarga se pueden encontrar en core::ops.

use std::ops;

struct Foo;
struct Bar;

#[derive(Debug)]
struct FooBar;

#[derive(Debug)]
struct BarFoo;

// El rasgo `std::ops::Add` se usa para especificar la funcionalidad de `+`.
// Aquí, hacemos `Add<Bar>` - el rasgo para la adición con un RHS de tipo `Bar`.
// El siguiente bloque implementa la operación: Foo + Bar = FooBar
impl ops::Add<Bar> for Foo {
    type Output = FooBar;

    fn add(self, _rhs: Bar) -> FooBar {
        println!("> se ejecutó Foo.add(Bar)");

        FooBar
    }
}

// Al invertir los tipos, terminamos implementando la suma no conmutativa.
// Aquí, hacemos `Add<Foo>` - el rasgo para sumar con un RHS de tipo `Foo`.
// Este bloque implementa la operación: Bar + Foo = BarFoo
impl ops::Add<Foo> for Bar {
    type Output = BarFoo;

    fn add(self, _rhs: Foo) -> BarFoo {
        println!("> se ejecutó Bar.add(Foo)");

        BarFoo
    }
}

fn main() {
    println!("Foo + Bar = {:?}", Foo + Bar);
    println!("Bar + Foo = {:?}", Bar + Foo);
}

Ve también

Add, Índice de sintaxis