diff --git a/src/length.rs b/src/length.rs
index 4068108..726fd3a 100644
--- a/src/length.rs
+++ b/src/length.rs
@@ -12,6 +12,8 @@ use scale_factor::ScaleFactor;
 use num::Zero;
 
 use std::num::{NumCast, cast};
+use std::cmp::Ordering;
+use std::ops::{Add, Sub, Mul, Div, Neg};
 
 /// A one-dimensional distance, with value represented by `T` and unit of measurement `Unit`.
 ///
@@ -24,7 +26,7 @@ use std::num::{NumCast, cast};
 ///
 /// You can multiply a Length by a `scale_factor::ScaleFactor` to convert it from one unit to
 /// another.  See the ScaleFactor docs for an example.
-#[deriving(Copy, Decodable, Encodable, Show)]
+#[derive(Copy, RustcDecodable, RustcEncodable, Show)]
 pub struct Length<Unit, T>(pub T);
 
 impl<Unit, T: Clone> Length<Unit, T> {
@@ -36,51 +38,56 @@ impl<Unit, T: Clone> Length<Unit, T> {
 }
 
 // length + length
-impl<U, T: Clone + Add<T, T>> Add<Length<U, T>, Length<U, T>> for Length<U, T> {
-    fn add(&self, other: &Length<U, T>) -> Length<U, T> {
+impl<U, T: Clone + Add<T, Output=T>> Add for Length<U, T> {
+    type Output = Length<U, T>;
+    fn add(self, other: Length<U, T>) -> Length<U, T> {
         Length(self.get() + other.get())
     }
 }
 
 // length - length
-impl<U, T: Clone + Sub<T, T>> Sub<Length<U, T>, Length<U, T>> for Length<U, T> {
-    fn sub(&self, other: &Length<U, T>) -> Length<U, T> {
+impl<U, T: Clone + Sub<T, Output=T>> Sub<Length<U, T>> for Length<U, T> {
+    type Output = Length<U, T>;
+    fn sub(self, other: Length<U, T>) -> <Self as Sub>::Output {
         Length(self.get() - other.get())
     }
 }
 
 // length * scaleFactor
-impl<Src, Dst, T: Clone + Mul<T, T>> Mul<ScaleFactor<Src, Dst, T>, Length<Dst, T>> for Length<Src, T> {
+impl<Src, Dst, T: Clone + Mul<T, Output=T>> Mul<ScaleFactor<Src, Dst, T>> for Length<Src, T> {
+    type Output = Length<Dst, T>;
     #[inline]
-    fn mul(&self, scale: &ScaleFactor<Src, Dst, T>) -> Length<Dst, T> {
+    fn mul(self, scale: ScaleFactor<Src, Dst, T>) -> Length<Dst, T> {
         Length(self.get() * scale.get())
     }
 }
 
 // length / scaleFactor
-impl<Src, Dst, T: Clone + Div<T, T>> Div<ScaleFactor<Src, Dst, T>, Length<Src, T>> for Length<Dst, T> {
+impl<Src, Dst, T: Clone + Div<T, Output=T>> Div<ScaleFactor<Src, Dst, T>> for Length<Dst, T> {
+    type Output = Length<Src, T>;
     #[inline]
-    fn div(&self, scale: &ScaleFactor<Src, Dst, T>) -> Length<Src, T> {
+    fn div(self, scale: ScaleFactor<Src, Dst, T>) -> Length<Src, T> {
         Length(self.get() / scale.get())
     }
 }
 
 // -length
-impl <U, T:Clone + Neg<T>> Neg<Length<U, T>> for Length<U, T> {
+impl <U, T:Clone + Neg<Output=T>> Neg for Length<U, T> {
+    type Output = Length<U, T>;
     #[inline]
-    fn neg(&self) -> Length<U, T> {
+    fn neg(self) -> Length<U, T> {
         Length(-self.get())
     }
 }
 
-impl<Unit, T0: NumCast + Clone, T1: NumCast + Clone> Length<Unit, T0> {
+impl<Unit, T0: NumCast + Clone> Length<Unit, T0> {
     /// Cast from one numeric representation to another, preserving the units.
-    pub fn cast(&self) -> Option<Length<Unit, T1>> {
+    pub fn cast<T1: NumCast + Clone>(&self) -> Option<Length<Unit, T1>> {
         cast(self.get()).map(|x| Length(x))
     }
 }
 
-// FIXME: Switch to `deriving(Clone, PartialEq, PartialOrd, Zero)` after this Rust issue is fixed:
+// FIXME: Switch to `derive(Clone, PartialEq, PartialOrd, Zero)` after this Rust issue is fixed:
 // https://github.com/mozilla/rust/issues/7671
 
 impl<Unit, T: Clone> Clone for Length<Unit, T> {
@@ -117,9 +124,9 @@ mod tests {
     use scale_factor::ScaleFactor;
     use std::num::Zero;
 
-    #[deriving(Show)]
+    #[derive(Show)]
     enum Inch {}
-    #[deriving(Show)]
+    #[derive(Show)]
     enum Mm {}
 
     #[test]
diff --git a/src/lib.rs b/src/lib.rs
index f873bf8..f4a76ef 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -10,11 +10,11 @@
 #![crate_name = "geom"]
 #![crate_type = "rlib"]
 
-#![feature(asm, phase, simd)]
+#![feature(asm, simd, old_impl_check)]
 
-#[phase(plugin, link)]
+#[macro_use]
 extern crate log;
-extern crate serialize;
+extern crate "serialize" as rustc_serialize;
 
 extern crate rand;
 extern crate test;
diff --git a/src/matrix.rs b/src/matrix.rs
index 6ccc563..71323c7 100644
--- a/src/matrix.rs
+++ b/src/matrix.rs
@@ -12,8 +12,9 @@ use num::{One, Zero};
 
 use std::num;
 use std::num::NumCast;
+use std::ops::{Add, Mul, Div, Neg, Sub};
 
-pub fn Matrix4<T:Add<T,T> + Clone + ApproxEq<T> + Mul<T,T> + One + Zero>(
+pub fn Matrix4<T:Add<T, Output=T> + Clone + ApproxEq<T> + Mul<T, Output=T> + One + Zero>(
         m11: T, m12: T, m13: T, m14: T,
         m21: T, m22: T, m23: T, m24: T,
         m31: T, m32: T, m33: T, m34: T,
@@ -27,7 +28,7 @@ pub fn Matrix4<T:Add<T,T> + Clone + ApproxEq<T> + Mul<T,T> + One + Zero>(
     }
 }
 
-#[deriving(Show, Copy)]
+#[derive(Show, Copy)]
 pub struct Matrix4<T> {
     pub m11: T, pub m12: T, pub m13: T, pub m14: T,
     pub m21: T, pub m22: T, pub m23: T, pub m24: T,
@@ -35,7 +36,7 @@ pub struct Matrix4<T> {
     pub m41: T, pub m42: T, pub m43: T, pub m44: T,
 }
 
-impl<T:Add<T,T> + Clone + ApproxEq<T> + Mul<T,T> + One + Zero> Matrix4<T> {
+impl<T:Add<T, Output=T> + Copy + Clone + ApproxEq<T> + Mul<T, Output=T> + One + Zero> Matrix4<T> {
     pub fn approx_eq(&self, other: &Matrix4<T>) -> bool {
         self.m11.approx_eq(&other.m11) && self.m12.approx_eq(&other.m12) &&
         self.m13.approx_eq(&other.m13) && self.m14.approx_eq(&other.m14) &&
@@ -80,7 +81,7 @@ impl<T:Add<T,T> + Clone + ApproxEq<T> + Mul<T,T> + One + Zero> Matrix4<T> {
                 self.m41.clone(), self.m42.clone(), self.m43.clone(), self.m44.clone())
     }
 
-    pub fn to_array(&self) -> [T, ..16] {
+    pub fn to_array(&self) -> [T; 16] {
         [
             self.m11.clone(), self.m12.clone(), self.m13.clone(), self.m14.clone(),
             self.m21.clone(), self.m22.clone(), self.m23.clone(), self.m24.clone(),
@@ -100,8 +101,8 @@ impl<T:Add<T,T> + Clone + ApproxEq<T> + Mul<T,T> + One + Zero> Matrix4<T> {
     }
 }
 
-pub fn ortho<T:Add<T,T> + Clone + Div<T,T> + ApproxEq<T> + Mul<T,T> + Neg<T> + NumCast + One +
-               Sub<T,T> + Zero>
+pub fn ortho<T:Add<T, Output=T> + Copy + Clone + Div<T, Output=T> + ApproxEq<T> + Mul<T, Output=T> + Neg<Output=T> + NumCast + One +
+               Sub<T, Output=T> + Zero>
         (left: T,
          right: T,
          bottom: T,
@@ -109,7 +110,7 @@ pub fn ortho<T:Add<T,T> + Clone + Div<T,T> + ApproxEq<T> + Mul<T,T> + Neg<T> + N
          near: T,
          far: T)
       -> Matrix4<T> {
-    let _2: T = num::cast(2u).unwrap();
+    let _2: T = num::cast(2us).unwrap();
     let _1: T = One::one();
     let _0: T = Zero::zero();
 
@@ -123,7 +124,7 @@ pub fn ortho<T:Add<T,T> + Clone + Div<T,T> + ApproxEq<T> + Mul<T,T> + Neg<T> + N
             tx,                  ty,                  tz,                 _1.clone())
 }
 
-pub fn identity<T:Add<T,T> + Clone + ApproxEq<T> + Mul<T,T> + One + Zero>() -> Matrix4<T> {
+pub fn identity<T:Add<T, Output=T> + Clone + ApproxEq<T> + Mul<T, Output=T> + One + Zero>() -> Matrix4<T> {
     let (_0, _1): (T, T) = (Zero::zero(), One::one());
     Matrix4(_1.clone(), _0.clone(), _0.clone(), _0.clone(),
             _0.clone(), _1.clone(), _0.clone(), _0.clone(),
diff --git a/src/matrix2d.rs b/src/matrix2d.rs
index a1aca3c..5f54d9f 100644
--- a/src/matrix2d.rs
+++ b/src/matrix2d.rs
@@ -8,15 +8,16 @@
 // except according to those terms.
 
 use num::{One, Zero};
+use std::ops::{Add, Mul};
 
-#[deriving(Clone, Copy)]
+#[derive(Clone, Copy)]
 pub struct Matrix2D<T> {
     m11: T, m12: T,
     m21: T, m22: T,
     m31: T, m32: T
 }
 
-impl<T:Add<T,T> + Clone + Mul<T,T> + One + Zero> Matrix2D<T> {
+impl<T:Add<T, Output=T> + Copy + Clone + Mul<T, Output=T> + One + Zero> Matrix2D<T> {
     pub fn new(m11: T, m12: T, m21: T, m22: T, m31: T, m32: T) -> Matrix2D<T> {
         Matrix2D {
             m11: m11, m12: m12,
@@ -55,7 +56,7 @@ impl<T:Add<T,T> + Clone + Mul<T,T> + One + Zero> Matrix2D<T> {
                              _0.clone(), _0.clone());
     }
 
-    pub fn to_array(&self) -> [T, ..6] {
+    pub fn to_array(&self) -> [T; 6] {
         [
             self.m11.clone(), self.m12.clone(),
             self.m21.clone(), self.m22.clone(),
diff --git a/src/point.rs b/src/point.rs
index d8bc6e0..62b1213 100644
--- a/src/point.rs
+++ b/src/point.rs
@@ -13,8 +13,9 @@ use num::Zero;
 
 use std::fmt;
 use std::num::NumCast;
+use std::ops::{Add, Neg, Mul, Sub, Div};
 
-#[deriving(Clone, Copy, Decodable, Encodable, Eq, Hash, PartialEq)]
+#[derive(Clone, Copy, RustcDecodable, RustcEncodable, Eq, Hash, PartialEq)]
 pub struct Point2D<T> {
     pub x: T,
     pub y: T
@@ -28,7 +29,7 @@ impl<T: Zero> Point2D<T> {
 
 impl<T: fmt::Show> fmt::Show for Point2D<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "({},{})", self.x, self.y)
+        write!(f, "({:?},{:?})", self.x, self.y)
     }
 }
 
@@ -37,48 +38,54 @@ pub fn Point2D<T>(x: T, y: T) -> Point2D<T> {
 }
 
 
-impl<T:Clone + Add<T,T>> Add<Point2D<T>, Point2D<T>> for Point2D<T> {
-    fn add(&self, other: &Point2D<T>) -> Point2D<T> {
+impl<T:Clone + Add<T, Output=T>> Add for Point2D<T> {
+    type Output = Point2D<T>;
+    fn add(self, other: Point2D<T>) -> Point2D<T> {
         Point2D(self.x + other.x, self.y + other.y)
     }
 }
 
-impl<T:Clone + Add<T,T>> Add<Size2D<T>, Point2D<T>> for Point2D<T> {
-    fn add(&self, other: &Size2D<T>) -> Point2D<T> {
+impl<T:Clone + Add<T, Output=T>> Add<Size2D<T>> for Point2D<T> {
+    type Output = Point2D<T>;
+    fn add(self, other: Size2D<T>) -> Point2D<T> {
         Point2D(self.x + other.width, self.y + other.height)
     }
 }
 
-impl<T: Add<T, T>> Point2D<T> {
+impl<T: Copy + Add<T, Output=T>> Point2D<T> {
     pub fn add_size(&self, other: &Size2D<T>) -> Point2D<T> {
         Point2D { x: self.x + other.width, y: self.y + other.height }
     }
 }
 
-impl<T:Clone + Sub<T,T>> Sub<Point2D<T>, Point2D<T>> for Point2D<T> {
-    fn sub(&self, other: &Point2D<T>) -> Point2D<T> {
+impl<T:Clone + Sub<T, Output=T>> Sub for Point2D<T> {
+    type Output = Point2D<T>;
+    fn sub(self, other: Point2D<T>) -> Point2D<T> {
         Point2D(self.x - other.x, self.y - other.y)
     }
 }
 
-impl <T:Clone + Neg<T>> Neg<Point2D<T>> for Point2D<T> {
+impl <T:Clone + Neg<Output=T>> Neg for Point2D<T> {
+    type Output = Point2D<T>;
     #[inline]
-    fn neg(&self) -> Point2D<T> {
+    fn neg(self) -> Point2D<T> {
         Point2D(-self.x, -self.y)
     }
 }
 
-impl<Scale, T0: Mul<Scale, T1>, T1: Clone> Mul<Scale, Point2D<T1>> for Point2D<T0> {
+impl<Scale: Copy, T0: Mul<Scale, Output=T1>, T1: Clone> Mul<Scale> for Point2D<T0> {
+    type Output = Point2D<T1>;
     #[inline]
-    fn mul(&self, scale: &Scale) -> Point2D<T1> {
-        Point2D(self.x * *scale, self.y * *scale)
+    fn mul(self, scale: Scale) -> Point2D<T1> {
+        Point2D(self.x * scale, self.y * scale)
     }
 }
 
-impl<Scale, T0: Div<Scale, T1>, T1: Clone> Div<Scale, Point2D<T1>> for Point2D<T0> {
+impl<Scale: Copy, T0: Div<Scale, Output=T1>, T1: Clone> Div<Scale> for Point2D<T0> {
+    type Output = Point2D<T1>;
     #[inline]
-    fn div(&self, scale: &Scale) -> Point2D<T1> {
-        Point2D(self.x / *scale, self.y / *scale)
+    fn div(self, scale: Scale) -> Point2D<T1> {
+        Point2D(self.x / scale, self.y / scale)
     }
 }
 
@@ -102,9 +109,9 @@ impl<Unit, T: Clone> Point2D<Length<Unit, T>> {
     }
 }
 
-impl<Unit, T0: NumCast + Clone, T1: NumCast + Clone> Point2D<Length<Unit, T0>> {
+impl<Unit, T0: NumCast + Clone> Point2D<Length<Unit, T0>> {
     /// Cast from one numeric representation to another, preserving the units.
-    pub fn cast(&self) -> Option<Point2D<Length<Unit, T1>>> {
+    pub fn cast<T1: NumCast + Clone>(&self) -> Option<Point2D<Length<Unit, T1>>> {
         match (self.x.cast(), self.y.cast()) {
             (Some(x), Some(y)) => Some(Point2D(x, y)),
             _ => None
@@ -118,7 +125,7 @@ impl<Unit, T: NumCast + Clone> Point2D<Length<Unit, T>> {
         self.cast().unwrap()
     }
 
-    pub fn as_uint(&self) -> Point2D<Length<Unit, uint>> {
+    pub fn as_uint(&self) -> Point2D<Length<Unit, usize>> {
         self.cast().unwrap()
     }
 }
diff --git a/src/rect.rs b/src/rect.rs
index 3990dbd..e4ea9bc 100644
--- a/src/rect.rs
+++ b/src/rect.rs
@@ -15,8 +15,9 @@ use size::Size2D;
 use std::cmp::PartialOrd;
 use std::fmt;
 use std::num::NumCast;
+use std::ops::{Add, Sub, Mul, Div};
 
-#[deriving(Clone, Copy, Decodable, Encodable, PartialEq)]
+#[derive(Clone, Copy, RustcDecodable, RustcEncodable, PartialEq)]
 pub struct Rect<T> {
     pub origin: Point2D<T>,
     pub size: Size2D<T>,
@@ -24,7 +25,7 @@ pub struct Rect<T> {
 
 impl<T: fmt::Show> fmt::Show for Rect<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Rect({} at {})", self.size, self.origin)
+        write!(f, "Rect({:?} at {:?})", self.size, self.origin)
     }
 }
 
@@ -35,7 +36,7 @@ pub fn Rect<T:Clone>(origin: Point2D<T>, size: Size2D<T>) -> Rect<T> {
     }
 }
 
-impl<T: Clone + PartialOrd + Add<T,T> + Sub<T,T>> Rect<T> {
+impl<T: Copy + Clone + PartialOrd + Add<T, Output=T> + Sub<T, Output=T>> Rect<T> {
     #[inline]
     pub fn intersects(&self, other: &Rect<T>) -> bool {
         self.origin.x < other.origin.x + other.size.width &&
@@ -122,7 +123,8 @@ impl<T: Clone + PartialOrd + Add<T,T> + Sub<T,T>> Rect<T> {
     }
 }
 
-impl<Scale, T: Clone + Mul<Scale,T>> Rect<T> {
+#[old_impl_check]
+impl<Scale: Copy, T: Copy + Clone + Mul<Scale, Output=T>> Rect<T> {
     #[inline]
     pub fn scale(&self, x: Scale, y: Scale) -> Rect<T> {
         Rect {
@@ -154,17 +156,19 @@ pub fn max<T:Clone + PartialOrd>(x: T, y: T) -> T {
     if x >= y { x } else { y }
 }
 
-impl<Scale, T0: Mul<Scale, T1>, T1: Clone> Mul<Scale, Rect<T1>> for Rect<T0> {
+impl<Scale: Copy, T0: Mul<Scale, Output=T1>, T1: Clone> Mul<Scale> for Rect<T0> {
+    type Output = Rect<T1>;
     #[inline]
-    fn mul(&self, scale: &Scale) -> Rect<T1> {
-        Rect(self.origin * *scale, self.size * *scale)
+    fn mul(self, scale: Scale) -> Rect<T1> {
+        Rect(self.origin * scale, self.size * scale)
     }
 }
 
-impl<Scale, T0: Div<Scale, T1>, T1: Clone> Div<Scale, Rect<T1>> for Rect<T0> {
+impl<Scale: Copy, T0: Div<Scale, Output=T1>, T1: Clone> Div<Scale> for Rect<T0> {
+    type Output = Rect<T1>;
     #[inline]
-    fn div(&self, scale: &Scale) -> Rect<T1> {
-        Rect(self.origin / *scale, self.size / *scale)
+    fn div(self, scale: Scale) -> Rect<T1> {
+        Rect(self.origin / scale, self.size / scale)
     }
 }
 
@@ -183,9 +187,9 @@ impl<Unit, T: Clone> Rect<Length<Unit, T>> {
     }
 }
 
-impl<Unit, T0: NumCast + Clone, T1: NumCast + Clone> Rect<Length<Unit, T0>> {
+impl<Unit, T0: NumCast + Clone> Rect<Length<Unit, T0>> {
     /// Cast from one numeric representation to another, preserving the units.
-    pub fn cast(&self) -> Option<Rect<Length<Unit, T1>>> {
+    pub fn cast<T1: NumCast + Clone>(&self) -> Option<Rect<Length<Unit, T1>>> {
         match (self.origin.cast(), self.size.cast()) {
             (Some(origin), Some(size)) => Some(Rect(origin, size)),
             _ => None
@@ -199,7 +203,7 @@ impl<Unit, T: NumCast + Clone> Rect<Length<Unit, T>> {
         self.cast().unwrap()
     }
 
-    pub fn as_uint(&self) -> Rect<Length<Unit, uint>> {
+    pub fn as_uint(&self) -> Rect<Length<Unit, usize>> {
         self.cast().unwrap()
     }
 }
diff --git a/src/scale_factor.rs b/src/scale_factor.rs
index f3b0b0c..73845a2 100644
--- a/src/scale_factor.rs
+++ b/src/scale_factor.rs
@@ -10,6 +10,7 @@
 
 use num::One;
 use std::num::{NumCast, cast};
+use std::ops::{Add, Mul, Sub, Div};
 
 /// A scaling factor between two different units of measurement.
 ///
@@ -30,7 +31,7 @@ use std::num::{NumCast, cast};
 /// let one_foot: Length<Inch, f32> = Length(12.0);
 /// let one_foot_in_mm: Length<Mm, f32> = one_foot * mm_per_inch;
 /// ```
-#[deriving(Copy, Decodable, Encodable, Show)]
+#[derive(Copy, RustcDecodable, RustcEncodable, Show)]
 pub struct ScaleFactor<Src, Dst, T>(pub T);
 
 impl<Src, Dst, T: Clone> ScaleFactor<Src, Dst, T> {
@@ -41,7 +42,7 @@ impl<Src, Dst, T: Clone> ScaleFactor<Src, Dst, T> {
     }
 }
 
-impl<Src, Dst, T: Clone + One + Div<T, T>> ScaleFactor<Src, Dst, T> {
+impl<Src, Dst, T: Clone + One + Div<T, Output=T>> ScaleFactor<Src, Dst, T> {
     /// The inverse ScaleFactor (1.0 / self).
     pub fn inv(&self) -> ScaleFactor<Dst, Src, T> {
         let one: T = One::one();
@@ -50,40 +51,41 @@ impl<Src, Dst, T: Clone + One + Div<T, T>> ScaleFactor<Src, Dst, T> {
 }
 
 // scale0 * scale1
-impl<A, B, C, T: Clone + Mul<T,T>>
-Mul<ScaleFactor<B, C, T>, ScaleFactor<A, C, T>> for ScaleFactor<A, B, T> {
+impl<A, B, C, T: Clone + Mul<T, Output=T>>
+Mul<ScaleFactor<B, C, T>> for ScaleFactor<A, B, T> {
+    type Output = ScaleFactor<A, C, T>;
     #[inline]
-    fn mul(&self, other: &ScaleFactor<B, C, T>) -> ScaleFactor<A, C, T> {
+    fn mul(self, other: ScaleFactor<B, C, T>) -> ScaleFactor<A, C, T> {
         ScaleFactor(self.get() * other.get())
     }
 }
 
 // scale0 + scale1
-impl<Src, Dst, T: Clone + Add<T,T>>
-Add<ScaleFactor<Src, Dst, T>, ScaleFactor<Src, Dst, T>> for ScaleFactor<Src, Dst, T> {
+impl<Src, Dst, T: Clone + Add<T, Output=T>> Add for ScaleFactor<Src, Dst, T> {
+    type Output = ScaleFactor<Src, Dst, T>;
     #[inline]
-    fn add(&self, other: &ScaleFactor<Src, Dst, T>) -> ScaleFactor<Src, Dst, T> {
+    fn add(self, other: ScaleFactor<Src, Dst, T>) -> ScaleFactor<Src, Dst, T> {
         ScaleFactor(self.get() + other.get())
     }
 }
 
 // scale0 - scale1
-impl<Src, Dst, T: Clone + Sub<T,T>>
-Sub<ScaleFactor<Src, Dst, T>, ScaleFactor<Src, Dst, T>> for ScaleFactor<Src, Dst, T> {
+impl<Src, Dst, T: Clone + Sub<T, Output=T>> Sub for ScaleFactor<Src, Dst, T> {
+    type Output = ScaleFactor<Src, Dst, T>;
     #[inline]
-    fn sub(&self, other: &ScaleFactor<Src, Dst, T>) -> ScaleFactor<Src, Dst, T> {
+    fn sub(self, other: ScaleFactor<Src, Dst, T>) -> ScaleFactor<Src, Dst, T> {
         ScaleFactor(self.get() - other.get())
     }
 }
 
-impl<Src, Dst, T0: NumCast + Clone, T1: NumCast + Clone> ScaleFactor<Src, Dst, T0> {
+impl<Src, Dst, T0: NumCast + Clone> ScaleFactor<Src, Dst, T0> {
     /// Cast from one numeric representation to another, preserving the units.
-    pub fn cast(&self) -> Option<ScaleFactor<Src, Dst, T1>> {
+    pub fn cast<T1: NumCast + Clone>(&self) -> Option<ScaleFactor<Src, Dst, T1>> {
         cast(self.get()).map(|x| ScaleFactor(x))
     }
 }
 
-// FIXME: Switch to `deriving(PartialEq, Clone)` after this Rust issue is fixed:
+// FIXME: Switch to `derive(PartialEq, Clone)` after this Rust issue is fixed:
 // https://github.com/mozilla/rust/issues/7671
 
 impl<Src, Dst, T: Clone + PartialEq> PartialEq for ScaleFactor<Src, Dst, T> {
@@ -102,11 +104,11 @@ impl<Src, Dst, T: Clone> Clone for ScaleFactor<Src, Dst, T> {
 mod tests {
     use super::ScaleFactor;
 
-    #[deriving(Show)]
+    #[derive(Show)]
     enum Inch {}
-    #[deriving(Show)]
+    #[derive(Show)]
     enum Cm {}
-    #[deriving(Show)]
+    #[derive(Show)]
     enum Mm {}
 
     #[test]
diff --git a/src/side_offsets.rs b/src/side_offsets.rs
index 4914f22..c359356 100644
--- a/src/side_offsets.rs
+++ b/src/side_offsets.rs
@@ -11,11 +11,11 @@
 //! and margins in CSS.
 
 use num::Zero;
-use std::num::Num;
+use std::ops::Add;
 
 /// A group of side offsets, which correspond to top/left/bottom/right for borders, padding,
 /// and margins in CSS.
-#[deriving(Clone, Copy, PartialEq)]
+#[derive(Clone, Copy, PartialEq)]
 pub struct SideOffsets2D<T> {
     pub top: T,
     pub right: T,
@@ -40,7 +40,7 @@ impl<T:Clone> SideOffsets2D<T> {
     }
 }
 
-impl<T> SideOffsets2D<T> where T: Add<T,T> {
+impl<T> SideOffsets2D<T> where T: Add<T, Output=T> + Copy {
     pub fn horizontal(&self) -> T {
         self.left + self.right
     }
@@ -50,8 +50,9 @@ impl<T> SideOffsets2D<T> where T: Add<T,T> {
     }
 }
 
-impl<T:Num> Add<SideOffsets2D<T>, SideOffsets2D<T>> for SideOffsets2D<T> {
-    fn add(&self, other: &SideOffsets2D<T>) -> SideOffsets2D<T> {
+impl<T: Add<T, Output=T>> Add for SideOffsets2D<T> {
+    type Output = SideOffsets2D<T>;
+    fn add(self, other: SideOffsets2D<T>) -> SideOffsets2D<T> {
         SideOffsets2D {
             top: self.top + other.top,
             right: self.right + other.right,
@@ -73,7 +74,7 @@ impl<T: Zero> SideOffsets2D<T> {
 }
 
 /// A SIMD enabled version of SideOffsets2D specialized for i32.
-#[deriving(Clone, Copy, PartialEq, Rand)]
+#[derive(Clone, Copy, PartialEq, Rand)]
 #[simd]
 pub struct SideOffsets2DSimdI32 {
     pub top: i32,
@@ -113,12 +114,13 @@ impl SideOffsets2DSimdI32 {
     }
 }
 
-impl Add<SideOffsets2DSimdI32, SideOffsets2DSimdI32> for SideOffsets2DSimdI32 {
+/*impl Add for SideOffsets2DSimdI32 {
+    type Output = SideOffsets2DSimdI32;
     #[inline]
-    fn add(&self, other: &SideOffsets2DSimdI32) -> SideOffsets2DSimdI32 {
-        *self + *other // Use SIMD addition
+    fn add(self, other: SideOffsets2DSimdI32) -> SideOffsets2DSimdI32 {
+        self + other // Use SIMD addition
     }
-}
+}*/
 
 impl SideOffsets2DSimdI32 {
     #[inline]
diff --git a/src/size.rs b/src/size.rs
index 23540a5..9377cfc 100644
--- a/src/size.rs
+++ b/src/size.rs
@@ -12,8 +12,9 @@ use num::Zero;
 
 use std::fmt;
 use std::num::NumCast;
+use std::ops::{Mul, Div};
 
-#[deriving(Clone, Copy, Decodable, Encodable, PartialEq)]
+#[derive(Clone, Copy, RustcDecodable, RustcEncodable, PartialEq)]
 pub struct Size2D<T> {
     pub width: T,
     pub height: T
@@ -21,7 +22,7 @@ pub struct Size2D<T> {
 
 impl<T: fmt::Show> fmt::Show for Size2D<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}×{}", self.width, self.height)
+        write!(f, "{:?}×{:?}", self.width, self.height)
     }
 }
 
@@ -32,7 +33,7 @@ pub fn Size2D<T: Clone>(width: T, height: T) -> Size2D<T> {
     }
 }
 
-impl<T:Clone + Mul<T,U>, U> Size2D<T> {
+impl<T:Copy + Clone + Mul<T, Output=U>, U> Size2D<T> {
     pub fn area(&self) -> U { self.width * self.height }
 }
 
@@ -45,17 +46,19 @@ impl<T: Zero> Size2D<T> {
     }
 }
 
-impl<Scale, T0: Mul<Scale, T1>, T1: Clone> Mul<Scale, Size2D<T1>> for Size2D<T0> {
+impl<Scale: Copy, T0: Mul<Scale, Output=T1>, T1: Clone> Mul<Scale> for Size2D<T0> {
+    type Output = Size2D<T1>;
     #[inline]
-    fn mul(&self, scale: &Scale) -> Size2D<T1> {
-        Size2D(self.width * *scale, self.height * *scale)
+    fn mul(self, scale: Scale) -> Size2D<T1> {
+        Size2D(self.width * scale, self.height * scale)
     }
 }
 
-impl<Scale, T0: Div<Scale, T1>, T1: Clone> Div<Scale, Size2D<T1>> for Size2D<T0> {
+impl<Scale: Copy, T0: Div<Scale, Output=T1>, T1: Clone> Div<Scale> for Size2D<T0> {
+    type Output = Size2D<T1>;
     #[inline]
-    fn div(&self, scale: &Scale) -> Size2D<T1> {
-        Size2D(self.width / *scale, self.height / *scale)
+    fn div(self, scale: Scale) -> Size2D<T1> {
+        Size2D(self.width / scale, self.height / scale)
     }
 }
 
@@ -79,9 +82,9 @@ impl<Unit, T: Clone> Size2D<Length<Unit, T>> {
     }
 }
 
-impl<Unit, T0: NumCast + Clone, T1: NumCast + Clone> Size2D<Length<Unit, T0>> {
+impl<Unit, T0: NumCast + Clone> Size2D<Length<Unit, T0>> {
     /// Cast from one numeric representation to another, preserving the units.
-    pub fn cast(&self) -> Option<Size2D<Length<Unit, T1>>> {
+    pub fn cast<T1: NumCast + Clone>(&self) -> Option<Size2D<Length<Unit, T1>>> {
         match (self.width.cast(), self.height.cast()) {
             (Some(w), Some(h)) => Some(Size2D(w, h)),
             _ => None
@@ -95,7 +98,7 @@ impl<Unit, T: NumCast + Clone> Size2D<Length<Unit, T>> {
         self.cast().unwrap()
     }
 
-    pub fn as_uint(&self) -> Size2D<Length<Unit, uint>> {
+    pub fn as_uint(&self) -> Size2D<Length<Unit, usize>> {
         self.cast().unwrap()
     }
 }