about summary refs log tree commit diff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/libstd/ops.rs252
1 files changed, 112 insertions, 140 deletions
diff --git a/src/libstd/ops.rs b/src/libstd/ops.rs
index 2f3e3eb9ca8..3418fd939bd 100644
--- a/src/libstd/ops.rs
+++ b/src/libstd/ops.rs
@@ -15,30 +15,30 @@
  *
  * Traits for the built-in operators. Implementing these traits allows you to get
  * an effect similar to oveloading 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 `Point`s.
- * 
+ *
  * ```rust
- * use std::ops::Add;
- * use std::ops::Sub;
- * 
  * 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}
@@ -49,33 +49,31 @@
  *     println(format!("{:?}", 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.
- * 
+ *
  */
 
 /**
- * 
+ *
  * The `Drop` trait is used to run some code when a value goes out of scope. This
  * is sometimes called a 'destructor'.
- * 
+ *
  * # Example
- * 
+ *
  * A trivial implementation of `Drop`. The `drop` method is called when `_x` goes
  * out of scope, and therefore `main` prints `Dropping!`.
- * 
+ *
  * ```rust
- * use std::ops::Drop;
- * 
  * struct HasDrop;
- * 
+ *
  * impl Drop for HasDrop {
  *   fn drop(&mut self) {
  *       println("Dropping!");
  *   }
  * }
- * 
+ *
  * fn main() {
  *   let _x = HasDrop;
  * }
@@ -87,26 +85,24 @@ pub trait Drop {
 }
 
 /**
- * 
- * The `Add` trait is used to override the functionality of `+`.
- * 
+ *
+ * The `Add` trait is used to specify the functionality of `+`.
+ *
  * # Example
- * 
+ *
  * A trivial implementation of `Add`. When `Foo + Foo` happens, it ends up
  * calling `add`, and therefore, `main` prints `Adding!`.
- * 
+ *
  * ```rust
- * use std::ops::Add;
- * 
  * struct Foo;
- * 
+ *
  * impl Add<Foo, Foo> for Foo {
  *     fn add(&self, _rhs: &Foo) -> Foo {
  *       println("Adding!");
  *       *self
  *   }
  * }
- * 
+ *
  * fn main() {
  *   Foo + Foo;
  * }
@@ -118,26 +114,24 @@ pub trait Add<RHS,Result> {
 }
 
 /**
- * 
- * The `Sub` trait is used to override the functionality of `-`.
- * 
+ *
+ * The `Sub` trait is used to specify the functionality of `-`.
+ *
  * # Example
- * 
+ *
  * A trivial implementation of `Sub`. When `Foo - Foo` happens, it ends up
  * calling `sub`, and therefore, `main` prints `Subtracting!`.
- * 
- * ```
- * use std::ops::Sub;
- * 
+ *
+ * ```rust
  * struct Foo;
- * 
+ *
  * impl Sub<Foo, Foo> for Foo {
  *     fn sub(&self, _rhs: &Foo) -> Foo {
  *         println("Subtracting!");
  *         *self
  *     }
  * }
- * 
+ *
  * fn main() {
  *     Foo - Foo;
  * }
@@ -149,26 +143,24 @@ pub trait Sub<RHS,Result> {
 }
 
 /**
- * 
- * The `Mul` trait is used to override the functionality of `*`.
- * 
+ *
+ * The `Mul` trait is used to specify the functionality of `*`.
+ *
  * # Example
- * 
+ *
  * A trivial implementation of `Mul`. When `Foo * Foo` happens, it ends up
  * calling `mul`, and therefore, `main` prints `Multiplying!`.
- * 
+ *
  * ```rust
- * use std::ops::Mul;
- * 
  * struct Foo;
- * 
+ *
  * impl Mul<Foo, Foo> for Foo {
  *     fn mul(&self, _rhs: &Foo) -> Foo {
  *         println("Multiplying!");
  *         *self
  *     }
  * }
- * 
+ *
  * fn main() {
  *     Foo * Foo;
  * }
@@ -180,26 +172,24 @@ pub trait Mul<RHS,Result> {
 }
 
 /**
- * 
- * The `Div` trait is used to override the functionality of `/`.
- * 
+ *
+ * The `Div` trait is used to specify the functionality of `/`.
+ *
  * # Example
- * 
+ *
  * A trivial implementation of `Div`. When `Foo / Foo` happens, it ends up
  * calling `div`, and therefore, `main` prints `Dividing!`.
- * 
+ *
  * ```
- * use std::ops::Div;
- * 
  * struct Foo;
- * 
+ *
  * impl Div<Foo, Foo> for Foo {
  *     fn div(&self, _rhs: &Foo) -> Foo {
  *         println("Dividing!");
  *         *self
  *     }
  * }
- * 
+ *
  * fn main() {
  *     Foo / Foo;
  * }
@@ -211,26 +201,24 @@ pub trait Div<RHS,Result> {
 }
 
 /**
- * 
- * The `Rem` trait is used to override the functionality of `%`.
- * 
+ *
+ * The `Rem` trait is used to specify the functionality of `%`.
+ *
  * # Example
- * 
- * A trivial implemtnation of `Rem`. When `Foo % Foo` happens, it ends up
+ *
+ * A trivial implementation of `Rem`. When `Foo % Foo` happens, it ends up
  * calling `rem`, and therefore, `main` prints `Remainder-ing!`.
- * 
+ *
  * ```
- * use std::ops::Rem;
- * 
  * struct Foo;
- * 
+ *
  * impl Rem<Foo, Foo> for Foo {
  *     fn rem(&self, _rhs: &Foo) -> Foo {
  *         println("Remainder-ing!");
  *         *self
  *     }
  * }
- * 
+ *
  * fn main() {
  *     Foo % Foo;
  * }
@@ -242,26 +230,24 @@ pub trait Rem<RHS,Result> {
 }
 
 /**
- * 
- * The `Neg` trait is used to override the functionality of unary `-`.
- * 
+ *
+ * The `Neg` trait is used to specify the functionality of unary `-`.
+ *
  * # Example
- * 
- * A trivial implemtnation of `Neg`. When `-Foo` happens, it ends up calling
+ *
+ * A trivial implementation of `Neg`. When `-Foo` happens, it ends up calling
  * `neg`, and therefore, `main` prints `Negating!`.
- * 
+ *
  * ```
- * use std::ops::Neg;
- * 
  * struct Foo;
- * 
+ *
  * impl Neg<Foo> for Foo {
  *     fn neg(&self) -> Foo {
  *         println("Negating!");
  *         *self
  *     }
  * }
- * 
+ *
  * fn main() {
  *     -Foo;
  * }
@@ -273,26 +259,24 @@ pub trait Neg<Result> {
 }
 
 /**
- * 
- * The `Not` trait is used to override the functionality of `!`.
- * 
+ *
+ * The `Not` trait is used to specify the functionality of unary `!`.
+ *
  * # Example
- * 
+ *
  * A trivial implementation of `Not`. When `!Foo` happens, it ends up calling
  * `not`, and therefore, `main` prints `Not-ing!`.
- * 
+ *
  * ```
- * use std::ops::Not;
- * 
  * struct Foo;
- * 
+ *
  * impl Not<Foo> for Foo {
  *     fn not(&self) -> Foo {
  *         println("Not-ing!");
  *         *self
  *     }
  * }
- * 
+ *
  * fn main() {
  *     !Foo;
  * }
@@ -304,26 +288,24 @@ pub trait Not<Result> {
 }
 
 /**
- * 
- * The `BitAnd` trait is used to override the functionality of `&`.
- * 
+ *
+ * The `BitAnd` trait is used to specify the functionality of `&`.
+ *
  * # Example
- * 
+ *
  * A trivial implementation of `BitAnd`. When `Foo & Foo` happens, it ends up
  * calling `bitand`, and therefore, `main` prints `Bitwise And-ing!`.
- * 
+ *
  * ```
- * use std::ops::BitAnd;
- * 
  * struct Foo;
- * 
+ *
  * impl BitAnd<Foo, Foo> for Foo {
  *     fn bitand(&self, _rhs: &Foo) -> Foo {
  *         println("Bitwise And-ing!");
  *         *self
  *     }
  * }
- * 
+ *
  * fn main() {
  *     Foo & Foo;
  * }
@@ -335,26 +317,24 @@ pub trait BitAnd<RHS,Result> {
 }
 
 /**
- * 
- * The `BitOr` trait is used to override the functionality of `|`.
- * 
+ *
+ * The `BitOr` trait is used to specify the functionality of `|`.
+ *
  * # Example
- * 
+ *
  * A trivial implementation of `BitOr`. When `Foo | Foo` happens, it ends up
  * calling `bitor`, and therefore, `main` prints `Bitwise Or-ing!`.
- * 
+ *
  * ```
- * use std::ops::BitOr;
- * 
  * struct Foo;
- * 
+ *
  * impl BitOr<Foo, Foo> for Foo {
  *     fn bitor(&self, _rhs: &Foo) -> Foo {
  *         println("Bitwise Or-ing!");
  *         *self
  *     }
  * }
- * 
+ *
  * fn main() {
  *     Foo | Foo;
  * }
@@ -366,26 +346,24 @@ pub trait BitOr<RHS,Result> {
 }
 
 /**
- * 
- * The `BitXor` trait is used to override the functionality of `^`.
- * 
+ *
+ * The `BitXor` trait is used to specify the functionality of `^`.
+ *
  * # Example
- * 
+ *
  * A trivial implementation of `BitXor`. When `Foo ^ Foo` happens, it ends up
  * calling `bixtor`, and therefore, `main` prints `Bitwise Xor-ing!`.
- * 
+ *
  * ```
- * use std::ops::BitXor;
- * 
  * struct Foo;
- * 
+ *
  * impl BitXor<Foo, Foo> for Foo {
  *     fn bitxor(&self, _rhs: &Foo) -> Foo {
  *         println("Bitwise Xor-ing!");
  *         *self
  *     }
  * }
- * 
+ *
  * fn main() {
  *     Foo ^ Foo;
  * }
@@ -397,26 +375,24 @@ pub trait BitXor<RHS,Result> {
 }
 
 /**
- * 
- * The `Shl` trait is used to override the functionality of `<<`.
- * 
+ *
+ * The `Shl` trait is used to specify the functionality of `<<`.
+ *
  * # Example
- * 
+ *
  * A trivial implementation of `Shl`. When `Foo << Foo` happens, it ends up
  * calling `shl`, and therefore, `main` prints `Shifting left!`.
- * 
+ *
  * ```
- * use std::ops::Shl;
- * 
  * struct Foo;
- * 
+ *
  * impl Shl<Foo, Foo> for Foo {
  *     fn shl(&self, _rhs: &Foo) -> Foo {
  *         println("Shifting left!");
  *         *self
  *     }
  * }
- * 
+ *
  * fn main() {
  *     Foo << Foo;
  * }
@@ -428,26 +404,24 @@ pub trait Shl<RHS,Result> {
 }
 
 /**
- * 
- * The `Shr` trait is used to override the functionality of `>>`.
- * 
+ *
+ * The `Shr` trait is used to specify the functionality of `>>`.
+ *
  * # Example
- * 
+ *
  * A trivial implementation of `Shr`. When `Foo >> Foo` happens, it ends up
  * calling `shr`, and therefore, `main` prints `Shifting right!`.
- * 
+ *
  * ```
- * use std::ops::Shr;
- * 
  * struct Foo;
- * 
+ *
  * impl Shr<Foo, Foo> for Foo {
  *     fn shr(&self, _rhs: &Foo) -> Foo {
  *         println("Shifting right!");
  *         *self
  *     }
  * }
- * 
+ *
  * fn main() {
  *     Foo >> Foo;
  * }
@@ -459,27 +433,25 @@ pub trait Shr<RHS,Result> {
 }
 
 /**
- * 
- * The `Index` trait is used to override the functionality of indexing operations
+ *
+ * The `Index` trait is used to specify the functionality of indexing operations
  * like `arr[idx]`.
- * 
+ *
  * # Example
- * 
- * A trivial implementation of `Index`. When `Foo[idx]` happens, it ends up
+ *
+ * A trivial implementation of `Index`. When `Foo[Foo]` happens, it ends up
  * calling `index`, and therefore, `main` prints `Indexing!`.
- * 
+ *
  * ```
- * use std::ops::Index;
- * 
  * struct Foo;
- * 
+ *
  * impl Index<Foo, Foo> for Foo {
  *     fn index(&self, _rhs: &Foo) -> Foo {
  *         println("Indexing!");
  *         *self
  *     }
  * }
- * 
+ *
  * fn main() {
  *     Foo[Foo];
  * }
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-01-11 22:27:51 +0000