Module std::ops

Overloadable operators.

Implementing these traits allows you to get an effect similar to overloading operators.

Some of these traits are imported by the prelude, so they are available in every Rust program.

Many of the operators take their operands by value. In non-generic contexts involving built-in types, this is usually not a problem. However, using these operators in generic code, requires some attention if values have to be reused as opposed to letting the operators consume them. One option is to occasionally use clone(). Another option is to rely on the types involved providing additional operator implementations for references. For example, for a user-defined type T which is supposed to support addition, it is probably a good idea to have both T and &T implement the traits Add<T> and Add<&T> so that generic code can be written without unnecessary cloning.

Examples

This example creates a Point struct that implements Add and Sub, and then demonstrates adding and subtracting two Points.

use std::ops::{Add, Sub}; #[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} } } impl Sub for Point { type Output = Point; fn sub(self, other: Point) -> Point { Point {x: self.x - other.x, y: self.y - other.y} } } fn main() { println!("{:?}", Point {x: 1, y: 0} + Point {x: 2, y: 3}); println!("{:?}", Point {x: 1, y: 0} - Point {x: 2, y: 3}); }

use std::ops::{Add, Sub};

#[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}
    }
}

impl Sub for Point {
    type Output = Point;

    fn sub(self, other: Point) -> Point {
        Point {x: self.x - other.x, y: self.y - other.y}
    }
}
fn main() {
    println!("{:?}", Point {x: 1, y: 0} + Point {x: 2, y: 3});
    println!("{:?}", Point {x: 1, y: 0} - Point {x: 2, y: 3});
}

See the documentation for each trait for a minimum implementation that prints something to the screen.

Structs

Range	A (half-open) range which is bounded at both ends: { x | start <= x < end }. Use start..end (two dots) for its shorthand.
RangeFrom	A range which is only bounded below: { x | start <= x }. Use start.. for its shorthand.
RangeFull	An unbounded range. Use .. (two dots) for its shorthand.
RangeTo	A range which is only bounded above: { x | x < end }. Use ..end (two dots) for its shorthand.
RangeToInclusive	[Unstable] An inclusive range which is only bounded above: { x | x <= end }. Use ...end (three dots) for its shorthand.

Enums

RangeInclusive

[Unstable] An inclusive range which is bounded at both ends: { x | start <= x <= end }. Use start...end (three dots) for its shorthand.

Traits

Add	The Add trait is used to specify the functionality of +.
AddAssign	The AddAssign trait is used to specify the functionality of +=.
BitAnd	The BitAnd trait is used to specify the functionality of &.
BitAndAssign	The BitAndAssign trait is used to specify the functionality of &=.
BitOr	The BitOr trait is used to specify the functionality of |.
BitOrAssign	The BitOrAssign trait is used to specify the functionality of |=.
BitXor	The BitXor trait is used to specify the functionality of ^.
BitXorAssign	The BitXorAssign trait is used to specify the functionality of ^=.
Deref	The Deref trait is used to specify the functionality of dereferencing operations, like *v.
DerefMut	The DerefMut trait is used to specify the functionality of dereferencing mutably like *v = 1;
Div	The Div trait is used to specify the functionality of /.
DivAssign	The DivAssign trait is used to specify the functionality of /=.
Drop	The Drop trait is used to run some code when a value goes out of scope. This is sometimes called a 'destructor'.
Fn	A version of the call operator that takes an immutable receiver.
FnMut	A version of the call operator that takes a mutable receiver.
FnOnce	A version of the call operator that takes a by-value receiver.
Index	The Index trait is used to specify the functionality of indexing operations like arr[idx] when used in an immutable context.
IndexMut	The IndexMut trait is used to specify the functionality of indexing operations like arr[idx], when used in a mutable context.
Mul	The Mul trait is used to specify the functionality of *.
MulAssign	The MulAssign trait is used to specify the functionality of *=.
Neg	The Neg trait is used to specify the functionality of unary -.
Not	The Not trait is used to specify the functionality of unary !.
Rem	The Rem trait is used to specify the functionality of %.
RemAssign	The RemAssign trait is used to specify the functionality of %=.
Shl	The Shl trait is used to specify the functionality of <<.
ShlAssign	The ShlAssign trait is used to specify the functionality of <<=.
Shr	The Shr trait is used to specify the functionality of >>.
ShrAssign	The ShrAssign trait is used to specify the functionality of >>=.
Sub	The Sub trait is used to specify the functionality of -.
SubAssign	The SubAssign trait is used to specify the functionality of -=.
BoxPlace	[Unstable] Specialization of Place trait supporting box EXPR.
Boxed	[Unstable] Core trait for the box EXPR form.
CoerceUnsized	[Unstable] Trait that indicates that this is a pointer or a wrapper for one, where unsizing can be performed on the pointee.
InPlace	[Unstable] Specialization of Place trait supporting in (PLACE) EXPR.
Place	[Unstable] Both in (PLACE) EXPR and box EXPR desugar into expressions that allocate an intermediate "place" that holds uninitialized state. The desugaring evaluates EXPR, and writes the result at the address returned by the pointer method of this trait.
Placer	[Unstable] Interface to implementations of in (PLACE) EXPR.