Module core::opsExperimental [-]  [+] [src]

Overloadable operators

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

The values for the right hand side of an operator are automatically borrowed, so a + b is sugar for a.add(&b).

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

Example

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

#[deriving(Show)] struct Point { x: int, y: int } impl Add<Point, Point> for Point { fn add(self, other: Point) -> Point { Point {x: self.x + other.x, y: self.y + other.y} } } impl Sub<Point, Point> for 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}); }
#[deriving(Show)]
struct Point {
    x: int,
    y: int
}

impl Add<Point, Point> for Point {
    fn add(self, other: Point) -> Point {
        Point {x: self.x + other.x, y: self.y + other.y}
    }
}

impl Sub<Point, Point> for 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

FullRange

An unbounded range.

Range

A (half-open) range which is bounded at both ends.

RangeFrom

A range which is only bounded below.

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 >>.

Slice

The Slice trait is used to specify the functionality of slicing operations like arr[from..to] when used in an immutable context.

SliceMut

The SliceMut trait is used to specify the functionality of slicing operations like arr[from..to], when used in a mutable context.

Sub

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