Fixes bounds/bounds.rs

examples/bounds/bounds.rs

@@ -1,43 +1,38 @@
#[deriving(Show)]
#[deriving(Show, Copy)]
struct Vec2<T> {
    x: T,
    y: T,
}

impl<
    // Bound: `T` must implement the `Add` trait
    T: Add<T, T>
> Add<Vec2<T>, Vec2<T>>
for Vec2<T> {
    fn add(&self, rhs: &Vec2<T>) -> Vec2<T> {
// Apply bound to `T` at first instance of `T`. `T`
// must implement the `Add` trait.
impl<T: Add<T, T>> Add<Vec2<T>, Vec2<T>>
        for Vec2<T> {
    fn add(self, rhs: Vec2<T>) -> Vec2<T> {
        Vec2 {
            // `x` and `y` are of type `T`, and implement the `add` method
            x: self.x.add(&rhs.x),
            x: self.x.add(rhs.x),
            // The sugary `+` operator can also be used
            y: self.y + rhs.y,
        }
    }
}

impl<
    // Bound: `T` must implement the `Sub` trait
    T: Sub<T, T>
> Sub<Vec2<T>, Vec2<T>>
for Vec2<T> {
    fn sub(&self, rhs: &Vec2<T>) -> Vec2<T> {
// Bound: `T` must implement the `Sub` trait
impl<T> Sub<Vec2<T>, Vec2<T>> for Vec2<T>
        where T: Sub<T, T> {
    fn sub(self, rhs: Vec2<T>) -> Vec2<T> {
        Vec2 {
            x: self.x - rhs.x,
            y: self.y - rhs.y,
        }
    }
}

impl<
    // Bound: `T` must implement *both* the `Add` trait and the `Mul` trait
    T: Add<T, T> + Mul<T, T>
> Mul<Vec2<T>, T>
for Vec2<T> {
    fn mul(&self, rhs: &Vec2<T>) -> T {
// Bound: `T` must implement *both* the `Add` trait and the `Mul` trait
impl<T> Vec2<T> 
        where T: Add<T, T> + Mul<T, T> {
    fn dot(self, rhs: Vec2<T>) -> T {
        (self.x * rhs.x) + (self.y * rhs.y)
    }
}
@@ -49,7 +44,7 @@ fn main() {

    println!("{} + {} = {}", v1, v2, v1 + v2);
    println!("{} - {} = {}", v1, v2, v1 - v2);
    println!("{} . {} = {}", v1, v2, v1.dot(&v2));
    println!("{} ⋅ {} = {}", v1, v2, v1.dot(v2));

    // Error! `char` doesn't implement the `Add` trait
    println!("{}", Vec2 { x: ' ', y: 'b' } + Vec2 { x: 'c', y: 'd' });

examples/bounds/input.md

@@ -7,4 +7,9 @@ When working with generics, the type parameters (e.g. `Ty`) may use traits
* The generic can only be specialized for type parameters that conform to the
  bounds.

Bounds are typically applied in one of two ways:

* At the first instance of the type
* In a `where` clause which directly precedes the `{` in the `impl`

{bounds.play}

examples/ops/input.md

@@ -1,11 +1,10 @@
In Rust, many of the operators can be overloaded via traits. This is possible
because operators are just sugar for method calls. For example, `a + b`
desugars to `a.add(&b)`. This `add` method is part of the `Add` trait, hence
desugars to `a.add(b)`. This `add` method is part of the `Add` trait, hence
any implementor of the `Add` trait will be able to use the `+` operator.

{operator.play}

Here is a [list][ops] of
the traits that overload operators.
Here is a [list][ops] of the traits that overload operators.

[ops]: http://doc.rust-lang.org/core/ops/

examples/ops/operator.rs

@@ -13,7 +13,7 @@ struct BarFoo;
// This block implements the operation: Foo + Bar = FooBar
impl Add<Bar, FooBar> for Foo {
    fn add(self, _rhs: Bar) -> FooBar {
        println!("> Foo.add(&Bar) was called");
        println!("> Foo.add(Bar) was called");

        FooBar
    }
@@ -23,7 +23,7 @@ impl Add<Bar, FooBar> for Foo {
// This block implements the operation: Bar + Foo = BarFoo
impl Add<Foo, BarFoo> for Bar {
    fn add(self, _rhs: Foo) -> BarFoo {
        println!("> Bar.add(&Foo) was called");
        println!("> Bar.add(Foo) was called");

        BarFoo
    }