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()`clone(). Another option is to rely on the types involved providing additional operator implementations for references. For example, for a user-defined type`. Another option is to rely on the types involved providing additional operator implementations for references. For example, for a user-defined type T`Twhich is supposed to support addition, it is probably a good idea to have both` which is supposed to support addition, it is probably a good idea to have both T`Tand` and &T`&Timplement the traits` implement the traits Add<T>`Addand` and Add<&T>`Add<&T>` so that generic code can be written without unnecessary cloning.

Examples

This example creates a Point`Pointstruct that implements` struct that implements Add`Addand` and Sub`Sub, and then demonstrates adding and subtracting two`, and then demonstrates adding and subtracting two Point`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`Addtrait is used to specify the functionality of` trait is used to specify the functionality of +`+`.

BitAnd

The BitAnd`BitAndtrait is used to specify the functionality of` trait is used to specify the functionality of &`&`.

BitOr

The BitOr`BitOrtrait is used to specify the functionality of` trait is used to specify the functionality of |`|`.

BitXor

The BitXor`BitXortrait is used to specify the functionality of` trait is used to specify the functionality of ^``.

Deref

The Deref`Dereftrait is used to specify the functionality of dereferencing operations like` trait is used to specify the functionality of dereferencing operations like *v`*v`.

DerefMut

The DerefMut`DerefMuttrait is used to specify the functionality of dereferencing mutably like` trait is used to specify the functionality of dereferencing mutably like *v = 1;`*v = 1;`

Div

The Div`Divtrait is used to specify the functionality of` trait is used to specify the functionality of /`/`.

Drop

The Drop`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`Indextrait is used to specify the functionality of indexing operations like` trait is used to specify the functionality of indexing operations like arr[idx]`arr[idx]` when used in an immutable context.

IndexMut

The IndexMut`IndexMuttrait is used to specify the functionality of indexing operations like` trait is used to specify the functionality of indexing operations like arr[idx]`arr[idx]`, when used in a mutable context.

Mul

The Mul`Multrait is used to specify the functionality of` trait is used to specify the functionality of *`*`.

Neg

The Neg`Negtrait is used to specify the functionality of unary` trait is used to specify the functionality of unary -`-`.

Not

The Not`Nottrait is used to specify the functionality of unary` trait is used to specify the functionality of unary !`!`.

Rem

The Rem`Remtrait is used to specify the functionality of` trait is used to specify the functionality of %`%`.

Shl

The Shl`Shltrait is used to specify the functionality of` trait is used to specify the functionality of <<`<<`.

Shr

The Shr`Shrtrait is used to specify the functionality of` trait is used to specify the functionality of >>`>>`.

Sub

The Sub`Subtrait is used to specify the functionality of` trait is used to specify the functionality of -`-`.

CoerceUnsized [Unstable]

Trait that indicates that this is a pointer or a wrapper for one, where unsizing can be performed on the pointee.