# Module std::ops [−] [src]

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

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.
RangeFrom | A range which is only bounded below.
RangeFull | An unbounded range.
RangeTo | A range which is only bounded above.

## Traits

Add | The `Add` trait is used to specify the functionality of `+`.
BitAnd | The `BitAnd` trait is used to specify the functionality of `&`.
BitOr | The `BitOr` trait is used to specify the functionality of `|`.
BitXor | The `BitXor` 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 `/`.
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 `*`.
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 `%`.
Shl | The `Shl` trait is used to specify the functionality of `<<`.
Shr | The `Shr` trait is used to specify the functionality of `>>`.
Sub | The `Sub` trait is used to specify the functionality of `-`.
AddAssign | [Unstable] The `AddAssign` trait is used to specify the functionality of `+=`.
BitAndAssign | [Unstable] The `BitAndAssign` trait is used to specify the functionality of `&=`.
BitOrAssign | [Unstable] The `BitOrAssign` trait is used to specify the functionality of `|=`.
BitXorAssign | [Unstable] The `BitXorAssign` 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.
DivAssign | [Unstable] The `DivAssign` trait is used to specify the functionality of `/=`.
InPlace | [Unstable] Specialization of `Place` trait supporting `in (PLACE) EXPR`.
MulAssign | [Unstable] The `MulAssign` trait is used to specify the functionality of `*=`.
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`.
RemAssign | [Unstable] The `RemAssign` trait is used to specify the functionality of `%=`.
ShlAssign | [Unstable] The `ShlAssign` trait is used to specify the functionality of `<<=`.
ShrAssign | [Unstable] The `ShrAssign` trait is used to specify the functionality of `>>=`.
SubAssign | [Unstable] The `SubAssign` trait is used to specify the functionality of `-=`.

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize`)