From 2c2b7a71d06f2a23cc70edf1fe03345eb7892187 Mon Sep 17 00:00:00 2001
From: Brendan Zabarauskas <bjzaba@yahoo.com.au>
Date: Thu, 28 Mar 2013 21:37:25 +1100
Subject: [PATCH] Remove instances of 'static'

---
 src/mat.rs  |  34 ++++++++---------
 src/mat2.rs |  52 +++++++++++++-------------
 src/mat3.rs |  74 ++++++++++++++++++-------------------
 src/mat4.rs |  46 +++++++++++------------
 src/quat.rs |  66 ++++++++++++++++-----------------
 src/vec.rs  |  30 +++++++--------
 src/vec2.rs |  84 +++++++++++++++++++++---------------------
 src/vec3.rs |  94 +++++++++++++++++++++++------------------------
 src/vec4.rs | 104 ++++++++++++++++++++++++++--------------------------
 9 files changed, 292 insertions(+), 292 deletions(-)

diff --git a/src/mat.rs b/src/mat.rs
index 8e4dbd2..5247937 100644
--- a/src/mat.rs
+++ b/src/mat.rs
@@ -36,21 +36,21 @@ pub trait Matrix<T,V>: Index<uint, V> + Eq + Neg<Self> {
     /**
      * Construct a diagonal matrix with the major diagonal set to `value`
      */
-    static fn from_value(value: T) -> Self;
+    fn from_value(value: T) -> Self;
 
     /**
      * # Return value
      *
      * The identity matrix
      */
-    static fn identity() -> Self;
+    fn identity() -> Self;
 
     /**
      * # Return value
      *
      * A matrix with all elements set to zero
      */
-    static fn zero() -> Self;
+    fn zero() -> Self;
 
     /**
      * # Return value
@@ -183,12 +183,12 @@ pub trait Matrix<T,V>: Index<uint, V> + Eq + Neg<Self> {
  * A 2 x 2 matrix
  */
 pub trait Matrix2<T,V>: Matrix<T,V> {
-    static fn new(c0r0: T, c0r1: T,
+    fn new(c0r0: T, c0r1: T,
                        c1r0: T, c1r1: T) -> Self;
 
-    static fn from_cols(c0: V, c1: V) -> Self;
+    fn from_cols(c0: V, c1: V) -> Self;
 
-    static fn from_angle(radians: T) -> Self;
+    fn from_angle(radians: T) -> Self;
 
     fn to_mat3(&self) -> Mat3<T>;
 
@@ -199,25 +199,25 @@ pub trait Matrix2<T,V>: Matrix<T,V> {
  * A 3 x 3 matrix
  */
 pub trait Matrix3<T,V>: Matrix<T,V> {
-    static fn new(c0r0:T, c0r1:T, c0r2:T,
+    fn new(c0r0:T, c0r1:T, c0r2:T,
                        c1r0:T, c1r1:T, c1r2:T,
                        c2r0:T, c2r1:T, c2r2:T) -> Self;
 
-    static fn from_cols(c0: V, c1: V, c2: V) -> Self;
+    fn from_cols(c0: V, c1: V, c2: V) -> Self;
 
-    static fn from_angle_x(radians: T) -> Self;
+    fn from_angle_x(radians: T) -> Self;
 
-    static fn from_angle_y(radians: T) -> Self;
+    fn from_angle_y(radians: T) -> Self;
 
-    static fn from_angle_z(radians: T) -> Self;
+    fn from_angle_z(radians: T) -> Self;
 
-    static fn from_angle_xyz(radians_x: T, radians_y: T, radians_z: T) -> Self;
+    fn from_angle_xyz(radians_x: T, radians_y: T, radians_z: T) -> Self;
 
-    static fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Self;
+    fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Self;
 
-    static fn from_axes(x: V, y: V, z: V) -> Self;
+    fn from_axes(x: V, y: V, z: V) -> Self;
 
-    static fn look_at(dir: &Vec3<T>, up: &Vec3<T>) -> Self;
+    fn look_at(dir: &Vec3<T>, up: &Vec3<T>) -> Self;
 
     fn to_mat4(&self) -> Mat4<T>;
 
@@ -228,12 +228,12 @@ pub trait Matrix3<T,V>: Matrix<T,V> {
  * A 4 x 4 matrix
  */
 pub trait Matrix4<T,V>: Matrix<T,V> {
-    static fn new(c0r0: T, c0r1: T, c0r2: T, c0r3: T,
+    fn new(c0r0: T, c0r1: T, c0r2: T, c0r3: T,
                        c1r0: T, c1r1: T, c1r2: T, c1r3: T,
                        c2r0: T, c2r1: T, c2r2: T, c2r3: T,
                        c3r0: T, c3r1: T, c3r2: T, c3r3: T) -> Self;
 
-    static fn from_cols(c0: V, c1: V, c2: V, c3: V) -> Self;
+    fn from_cols(c0: V, c1: V, c2: V, c3: V) -> Self;
 }
 
 /**
diff --git a/src/mat2.rs b/src/mat2.rs
index a313fdc..9e6fb8d 100644
--- a/src/mat2.rs
+++ b/src/mat2.rs
@@ -73,7 +73,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn from_value(value: T) -> Mat2<T> {
+    fn from_value(value: T) -> Mat2<T> {
         Matrix2::new(value, zero(),
                      zero(), value)
     }
@@ -90,7 +90,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn identity() -> Mat2<T> {
+    fn identity() -> Mat2<T> {
         Matrix2::new( one::<T>(), zero::<T>(),
                      zero::<T>(),  one::<T>())
     }
@@ -107,7 +107,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn zero() -> Mat2<T> {
+    fn zero() -> Mat2<T> {
         Matrix2::new(zero::<T>(), zero::<T>(),
                      zero::<T>(), zero::<T>())
     }
@@ -296,7 +296,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn new(c0r0: T, c0r1: T,
+    fn new(c0r0: T, c0r1: T,
                        c1r0: T, c1r1: T) -> Mat2<T> {
         Matrix2::from_cols(Vector2::new::<T,Vec2<T>>(c0r0, c0r1),
                            Vector2::new::<T,Vec2<T>>(c1r0, c1r1))
@@ -320,13 +320,13 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn from_cols(c0: Vec2<T>,
+    fn from_cols(c0: Vec2<T>,
                              c1: Vec2<T>) -> Mat2<T> {
         Mat2 { x: c0, y: c1 }
     }
 
     #[inline(always)]
-    static fn from_angle(radians: T) -> Mat2<T> {
+    fn from_angle(radians: T) -> Mat2<T> {
         let cos_theta = cos(radians);
         let sin_theta = sin(radians);
 
@@ -417,37 +417,37 @@ pub type dmat2 = Mat2<f64>;     // a 2×2 double-precision floating-point matrix
 // Static method wrappers for GLSL-style types
 
 impl mat2 {
-    #[inline(always)] static fn new(c0r0: f32, c0r1: f32, c1r0: f32, c1r1: f32)
+    #[inline(always)] fn new(c0r0: f32, c0r1: f32, c1r0: f32, c1r1: f32)
         -> mat2 { Matrix2::new(c0r0, c0r1, c1r0, c1r1) }
-    #[inline(always)] static fn from_cols(c0: vec2, c1: vec2)
+    #[inline(always)] fn from_cols(c0: vec2, c1: vec2)
         -> mat2 { Matrix2::from_cols(c0, c1) }
-    #[inline(always)] static fn from_value(v: f32) -> mat2 { Matrix::from_value(v) }
+    #[inline(always)] fn from_value(v: f32) -> mat2 { Matrix::from_value(v) }
 
-    #[inline(always)] static fn identity() -> mat2 { Matrix::identity() }
-    #[inline(always)] static fn zero() -> mat2 { Matrix::zero() }
+    #[inline(always)] fn identity() -> mat2 { Matrix::identity() }
+    #[inline(always)] fn zero() -> mat2 { Matrix::zero() }
 
-    #[inline(always)] static fn from_angle(radians: f32) -> mat2 { Matrix2::from_angle(radians) }
+    #[inline(always)] fn from_angle(radians: f32) -> mat2 { Matrix2::from_angle(radians) }
 
-    #[inline(always)] static fn dim() -> uint { 2 }
-    #[inline(always)] static fn rows() -> uint { 2 }
-    #[inline(always)] static fn cols() -> uint { 2 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<mat2>() }
+    #[inline(always)] fn dim() -> uint { 2 }
+    #[inline(always)] fn rows() -> uint { 2 }
+    #[inline(always)] fn cols() -> uint { 2 }
+    #[inline(always)] fn size_of() -> uint { size_of::<mat2>() }
 }
 
 impl dmat2 {
-    #[inline(always)] static fn new(c0r0: f64, c0r1: f64, c1r0: f64, c1r1: f64)
+    #[inline(always)] fn new(c0r0: f64, c0r1: f64, c1r0: f64, c1r1: f64)
         -> dmat2 { Matrix2::new(c0r0, c0r1, c1r0, c1r1) }
-    #[inline(always)] static fn from_cols(c0: dvec2, c1: dvec2)
+    #[inline(always)] fn from_cols(c0: dvec2, c1: dvec2)
         -> dmat2 { Matrix2::from_cols(c0, c1) }
-    #[inline(always)] static fn from_value(v: f64) -> dmat2 { Matrix::from_value(v) }
+    #[inline(always)] fn from_value(v: f64) -> dmat2 { Matrix::from_value(v) }
 
-    #[inline(always)] static fn identity() -> dmat2 { Matrix::identity() }
-    #[inline(always)] static fn zero() -> dmat2 { Matrix::zero() }
+    #[inline(always)] fn identity() -> dmat2 { Matrix::identity() }
+    #[inline(always)] fn zero() -> dmat2 { Matrix::zero() }
 
-    #[inline(always)] static fn from_angle(radians: f64) -> dmat2 { Matrix2::from_angle(radians) }
+    #[inline(always)] fn from_angle(radians: f64) -> dmat2 { Matrix2::from_angle(radians) }
 
-    #[inline(always)] static fn dim() -> uint { 2 }
-    #[inline(always)] static fn rows() -> uint { 2 }
-    #[inline(always)] static fn cols() -> uint { 2 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<dmat2>() }
+    #[inline(always)] fn dim() -> uint { 2 }
+    #[inline(always)] fn rows() -> uint { 2 }
+    #[inline(always)] fn cols() -> uint { 2 }
+    #[inline(always)] fn size_of() -> uint { size_of::<dmat2>() }
 }
diff --git a/src/mat3.rs b/src/mat3.rs
index b3ab371..0b17902 100644
--- a/src/mat3.rs
+++ b/src/mat3.rs
@@ -78,7 +78,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn from_value(value: T) -> Mat3<T> {
+    fn from_value(value: T) -> Mat3<T> {
         Matrix3::new(value, zero(), zero(),
                      zero(), value, zero(),
                      zero(), zero(), value)
@@ -98,7 +98,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn identity() -> Mat3<T> {
+    fn identity() -> Mat3<T> {
         Matrix3::new( one::<T>(), zero::<T>(), zero::<T>(),
                      zero::<T>(),  one::<T>(), zero::<T>(),
                      zero::<T>(), zero::<T>(),  one::<T>())
@@ -118,7 +118,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn zero() -> Mat3<T> {
+    fn zero() -> Mat3<T> {
         Matrix3::new(zero::<T>(), zero::<T>(), zero::<T>(),
                      zero::<T>(), zero::<T>(), zero::<T>(),
                      zero::<T>(), zero::<T>(), zero::<T>())
@@ -270,7 +270,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn new(c0r0:T, c0r1:T, c0r2:T,
+    fn new(c0r0:T, c0r1:T, c0r2:T,
                        c1r0:T, c1r1:T, c1r2:T,
                        c2r0:T, c2r1:T, c2r2:T) -> Mat3<T> {
         Matrix3::from_cols(Vector3::new::<T,Vec3<T>>(c0r0, c0r1, c0r2),
@@ -299,7 +299,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn from_cols(c0: Vec3<T>,
+    fn from_cols(c0: Vec3<T>,
                              c1: Vec3<T>,
                              c2: Vec3<T>) -> Mat3<T> {
         Mat3 { x: c0, y: c1, z: c2 }
@@ -309,7 +309,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * Construct a matrix from an angular rotation around the `x` axis
      */
     #[inline(always)]
-    static fn from_angle_x(radians: T) -> Mat3<T> {
+    fn from_angle_x(radians: T) -> Mat3<T> {
         // http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations
         let cos_theta = cos(radians);
         let sin_theta = sin(radians);
@@ -323,7 +323,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * Construct a matrix from an angular rotation around the `y` axis
      */
     #[inline(always)]
-    static fn from_angle_y(radians: T) -> Mat3<T> {
+    fn from_angle_y(radians: T) -> Mat3<T> {
         // http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations
         let cos_theta = cos(radians);
         let sin_theta = sin(radians);
@@ -337,7 +337,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * Construct a matrix from an angular rotation around the `z` axis
      */
     #[inline(always)]
-    static fn from_angle_z(radians: T) -> Mat3<T> {
+    fn from_angle_z(radians: T) -> Mat3<T> {
         // http://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations
         let cos_theta = cos(radians);
         let sin_theta = sin(radians);
@@ -357,7 +357,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * * `theta_z` - the angular rotation around the `z` axis (roll)
      */
     #[inline(always)]
-    static fn from_angle_xyz(radians_x: T, radians_y: T, radians_z: T) -> Mat3<T> {
+    fn from_angle_xyz(radians_x: T, radians_y: T, radians_z: T) -> Mat3<T> {
         // http://en.wikipedia.org/wiki/Rotation_matrix#General_rotations
         let cx = cos(radians_x);
         let sx = sin(radians_x);
@@ -375,7 +375,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * Construct a matrix from an axis and an angular rotation
      */
     #[inline(always)]
-    static fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Mat3<T> {
+    fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Mat3<T> {
         let c = cos(radians);
         let s = sin(radians);
         let _1_c = one::<T>() - c;
@@ -390,12 +390,12 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
     }
 
     #[inline(always)]
-    static fn from_axes(x: Vec3<T>, y: Vec3<T>, z: Vec3<T>) -> Mat3<T> {
+    fn from_axes(x: Vec3<T>, y: Vec3<T>, z: Vec3<T>) -> Mat3<T> {
         Matrix3::from_cols(x, y, z)
     }
 
     #[inline(always)]
-    static fn look_at(dir: &Vec3<T>, up: &Vec3<T>) -> Mat3<T> {
+    fn look_at(dir: &Vec3<T>, up: &Vec3<T>) -> Mat3<T> {
         let dir_ = dir.normalize();
         let side = dir_.cross(&up.normalize());
         let up_  = side.cross(&dir_).normalize();
@@ -596,42 +596,42 @@ pub type dmat3 = Mat3<f64>;     // a 3×3 double-precision floating-point matrix
 // Static method wrappers for GLSL-style types
 
 impl mat3 {
-    #[inline(always)] static fn new(c0r0: f32, c0r1: f32, c0r2: f32, c1r0: f32, c1r1: f32, c1r2: f32, c2r0: f32, c2r1: f32, c2r2: f32)
+    #[inline(always)] fn new(c0r0: f32, c0r1: f32, c0r2: f32, c1r0: f32, c1r1: f32, c1r2: f32, c2r0: f32, c2r1: f32, c2r2: f32)
         -> mat3 { Matrix3::new(c0r0, c0r1, c0r2, c1r0, c1r1, c1r2, c2r0, c2r1, c2r2) }
-    #[inline(always)] static fn from_cols(c0: vec3, c1: vec3, c2: vec3)
+    #[inline(always)] fn from_cols(c0: vec3, c1: vec3, c2: vec3)
         -> mat3 { Matrix3::from_cols(c0, c1, c2) }
-    #[inline(always)] static fn from_value(v: f32) -> mat3 { Matrix::from_value(v) }
+    #[inline(always)] fn from_value(v: f32) -> mat3 { Matrix::from_value(v) }
 
-    #[inline(always)] static fn identity() -> mat3 { Matrix::identity() }
-    #[inline(always)] static fn zero() -> mat3 { Matrix::zero() }
+    #[inline(always)] fn identity() -> mat3 { Matrix::identity() }
+    #[inline(always)] fn zero() -> mat3 { Matrix::zero() }
 
-    #[inline(always)] static fn from_angle_x(radians: f32) -> mat3 { Matrix3::from_angle_x(radians) }
-    #[inline(always)] static fn from_angle_y(radians: f32) -> mat3 { Matrix3::from_angle_y(radians) }
-    #[inline(always)] static fn from_angle_z(radians: f32) -> mat3 { Matrix3::from_angle_z(radians) }
-    #[inline(always)] static fn from_angle_xyz(radians_x: f32, radians_y: f32, radians_z: f32) -> mat3 { Matrix3::from_angle_xyz(radians_x, radians_y, radians_z) }
-    #[inline(always)] static fn from_angle_axis(radians: f32, axis: &vec3) -> mat3 { Matrix3::from_angle_axis(radians, axis) }
-    #[inline(always)] static fn from_axes(x: vec3, y: vec3, z: vec3) -> mat3 { Matrix3::from_axes(x, y, z) }
-    #[inline(always)] static fn look_at(dir: &vec3, up: &vec3) -> mat3 { Matrix3::look_at(dir, up) }
+    #[inline(always)] fn from_angle_x(radians: f32) -> mat3 { Matrix3::from_angle_x(radians) }
+    #[inline(always)] fn from_angle_y(radians: f32) -> mat3 { Matrix3::from_angle_y(radians) }
+    #[inline(always)] fn from_angle_z(radians: f32) -> mat3 { Matrix3::from_angle_z(radians) }
+    #[inline(always)] fn from_angle_xyz(radians_x: f32, radians_y: f32, radians_z: f32) -> mat3 { Matrix3::from_angle_xyz(radians_x, radians_y, radians_z) }
+    #[inline(always)] fn from_angle_axis(radians: f32, axis: &vec3) -> mat3 { Matrix3::from_angle_axis(radians, axis) }
+    #[inline(always)] fn from_axes(x: vec3, y: vec3, z: vec3) -> mat3 { Matrix3::from_axes(x, y, z) }
+    #[inline(always)] fn look_at(dir: &vec3, up: &vec3) -> mat3 { Matrix3::look_at(dir, up) }
 
-    #[inline(always)] static fn dim() -> uint { 3 }
-    #[inline(always)] static fn rows() -> uint { 3 }
-    #[inline(always)] static fn cols() -> uint { 3 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<mat3>() }
+    #[inline(always)] fn dim() -> uint { 3 }
+    #[inline(always)] fn rows() -> uint { 3 }
+    #[inline(always)] fn cols() -> uint { 3 }
+    #[inline(always)] fn size_of() -> uint { size_of::<mat3>() }
 }
 
 
 impl dmat3 {
-    #[inline(always)] static fn new(c0r0: f64, c0r1: f64, c0r2: f64, c1r0: f64, c1r1: f64, c1r2: f64, c2r0: f64, c2r1: f64, c2r2: f64)
+    #[inline(always)] fn new(c0r0: f64, c0r1: f64, c0r2: f64, c1r0: f64, c1r1: f64, c1r2: f64, c2r0: f64, c2r1: f64, c2r2: f64)
         -> dmat3 { Matrix3::new(c0r0, c0r1, c0r2, c1r0, c1r1, c1r2, c2r0, c2r1, c2r2) }
-    #[inline(always)] static fn from_cols(c0: dvec3, c1: dvec3, c2: dvec3)
+    #[inline(always)] fn from_cols(c0: dvec3, c1: dvec3, c2: dvec3)
         -> dmat3 { Matrix3::from_cols(c0, c1, c2) }
-    #[inline(always)] static fn from_value(v: f64) -> dmat3 { Matrix::from_value(v) }
+    #[inline(always)] fn from_value(v: f64) -> dmat3 { Matrix::from_value(v) }
 
-    #[inline(always)] static fn identity() -> dmat3 { Matrix::identity() }
-    #[inline(always)] static fn zero() -> dmat3 { Matrix::zero() }
+    #[inline(always)] fn identity() -> dmat3 { Matrix::identity() }
+    #[inline(always)] fn zero() -> dmat3 { Matrix::zero() }
 
-    #[inline(always)] static fn dim() -> uint { 3 }
-    #[inline(always)] static fn rows() -> uint { 3 }
-    #[inline(always)] static fn cols() -> uint { 3 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<dmat3>() }
+    #[inline(always)] fn dim() -> uint { 3 }
+    #[inline(always)] fn rows() -> uint { 3 }
+    #[inline(always)] fn cols() -> uint { 3 }
+    #[inline(always)] fn size_of() -> uint { size_of::<dmat3>() }
 }
diff --git a/src/mat4.rs b/src/mat4.rs
index 3357390..de354f5 100644
--- a/src/mat4.rs
+++ b/src/mat4.rs
@@ -78,7 +78,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn from_value(value: T) -> Mat4<T> {
+    fn from_value(value: T) -> Mat4<T> {
         Matrix4::new(value, zero(), zero(), zero(),
                      zero(), value, zero(), zero(),
                      zero(), zero(), value, zero(),
@@ -101,7 +101,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn identity() -> Mat4<T> {
+    fn identity() -> Mat4<T> {
         Matrix4::new( one::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
                      zero::<T>(),  one::<T>(), zero::<T>(), zero::<T>(),
                      zero::<T>(), zero::<T>(),  one::<T>(), zero::<T>(),
@@ -124,7 +124,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn zero() -> Mat4<T> {
+    fn zero() -> Mat4<T> {
         Matrix4::new(zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
                      zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
                      zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>(),
@@ -357,7 +357,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn new(c0r0: T, c0r1: T, c0r2: T, c0r3: T,
+    fn new(c0r0: T, c0r1: T, c0r2: T, c0r3: T,
                        c1r0: T, c1r1: T, c1r2: T, c1r3: T,
                        c2r0: T, c2r1: T, c2r2: T, c2r3: T,
                        c3r0: T, c3r1: T, c3r2: T, c3r3: T) -> Mat4<T>  {
@@ -391,7 +391,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * ~~~
      */
     #[inline(always)]
-    static fn from_cols(c0: Vec4<T>,
+    fn from_cols(c0: Vec4<T>,
                              c1: Vec4<T>,
                              c2: Vec4<T>,
                              c3: Vec4<T>) -> Mat4<T> {
@@ -533,33 +533,33 @@ pub type dmat4 = Mat4<f64>;     // a 4×4 double-precision floating-point matrix
 // Static method wrappers for GLSL-style types
 
 impl mat4 {
-    #[inline(always)] static fn new(c0r0: f32, c0r1: f32, c0r2: f32, c0r3: f32, c1r0: f32, c1r1: f32, c1r2: f32, c1r3: f32, c2r0: f32, c2r1: f32, c2r2: f32, c2r3: f32, c3r0: f32, c3r1: f32, c3r2: f32, c3r3: f32)
+    #[inline(always)] fn new(c0r0: f32, c0r1: f32, c0r2: f32, c0r3: f32, c1r0: f32, c1r1: f32, c1r2: f32, c1r3: f32, c2r0: f32, c2r1: f32, c2r2: f32, c2r3: f32, c3r0: f32, c3r1: f32, c3r2: f32, c3r3: f32)
         -> mat4 { Matrix4::new(c0r0, c0r1, c0r2, c0r3, c1r0, c1r1, c1r2, c1r3, c2r0, c2r1, c2r2, c2r3, c3r0, c3r1, c3r2, c3r3) }
-    #[inline(always)] static fn from_cols(c0: vec4, c1: vec4, c2: vec4, c3: vec4)
+    #[inline(always)] fn from_cols(c0: vec4, c1: vec4, c2: vec4, c3: vec4)
         -> mat4 { Matrix4::from_cols(c0, c1, c2, c3) }
-    #[inline(always)] static fn from_value(v: f32) -> mat4 { Matrix::from_value(v) }
+    #[inline(always)] fn from_value(v: f32) -> mat4 { Matrix::from_value(v) }
 
-    #[inline(always)] static fn identity() -> mat4 { Matrix::identity() }
-    #[inline(always)] static fn zero() -> mat4 { Matrix::zero() }
+    #[inline(always)] fn identity() -> mat4 { Matrix::identity() }
+    #[inline(always)] fn zero() -> mat4 { Matrix::zero() }
 
-    #[inline(always)] static fn dim() -> uint { 4 }
-    #[inline(always)] static fn rows() -> uint { 4 }
-    #[inline(always)] static fn cols() -> uint { 4 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<mat4>() }
+    #[inline(always)] fn dim() -> uint { 4 }
+    #[inline(always)] fn rows() -> uint { 4 }
+    #[inline(always)] fn cols() -> uint { 4 }
+    #[inline(always)] fn size_of() -> uint { size_of::<mat4>() }
 }
 
 impl dmat4 {
-    #[inline(always)] static fn new(c0r0: f64, c0r1: f64, c0r2: f64, c0r3: f64, c1r0: f64, c1r1: f64, c1r2: f64, c1r3: f64, c2r0: f64, c2r1: f64, c2r2: f64, c2r3: f64, c3r0: f64, c3r1: f64, c3r2: f64, c3r3: f64)
+    #[inline(always)] fn new(c0r0: f64, c0r1: f64, c0r2: f64, c0r3: f64, c1r0: f64, c1r1: f64, c1r2: f64, c1r3: f64, c2r0: f64, c2r1: f64, c2r2: f64, c2r3: f64, c3r0: f64, c3r1: f64, c3r2: f64, c3r3: f64)
         -> dmat4 { Matrix4::new(c0r0, c0r1, c0r2, c0r3, c1r0, c1r1, c1r2, c1r3, c2r0, c2r1, c2r2, c2r3, c3r0, c3r1, c3r2, c3r3) }
-    #[inline(always)] static fn from_cols(c0: dvec4, c1: dvec4, c2: dvec4, c3: dvec4)
+    #[inline(always)] fn from_cols(c0: dvec4, c1: dvec4, c2: dvec4, c3: dvec4)
         -> dmat4 { Matrix4::from_cols(c0, c1, c2, c3) }
-    #[inline(always)] static fn from_value(v: f64) -> dmat4 { Matrix::from_value(v) }
+    #[inline(always)] fn from_value(v: f64) -> dmat4 { Matrix::from_value(v) }
 
-    #[inline(always)] static fn identity() -> dmat4 { Matrix::identity() }
-    #[inline(always)] static fn zero() -> dmat4 { Matrix::zero() }
+    #[inline(always)] fn identity() -> dmat4 { Matrix::identity() }
+    #[inline(always)] fn zero() -> dmat4 { Matrix::zero() }
 
-    #[inline(always)] static fn dim() -> uint { 4 }
-    #[inline(always)] static fn rows() -> uint { 4 }
-    #[inline(always)] static fn cols() -> uint { 4 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<dmat4>() }
+    #[inline(always)] fn dim() -> uint { 4 }
+    #[inline(always)] fn rows() -> uint { 4 }
+    #[inline(always)] fn cols() -> uint { 4 }
+    #[inline(always)] fn size_of() -> uint { size_of::<dmat4>() }
 }
diff --git a/src/quat.rs b/src/quat.rs
index e83a7c3..dd5170c 100644
--- a/src/quat.rs
+++ b/src/quat.rs
@@ -61,7 +61,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * * `zk` - the third imaginary component
      */
     #[inline(always)]
-    static fn new(w: T, xi: T, yj: T, zk: T) -> Quat<T> {
+    fn new(w: T, xi: T, yj: T, zk: T) -> Quat<T> {
         Quat::from_sv(w, Vector3::new(xi, yj, zk))
     }
 
@@ -74,7 +74,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * * `v` - a vector containing the three imaginary components
      */
     #[inline(always)]
-    static fn from_sv(s: T, v: Vec3<T>) -> Quat<T> {
+    fn from_sv(s: T, v: Vec3<T>) -> Quat<T> {
         Quat { s: s, v: v }
     }
 
@@ -84,7 +84,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * The multiplicative identity, ie: `q = 1 + 0i + 0j + 0i`
      */
     #[inline(always)]
-    static fn identity() -> Quat<T> {
+    fn identity() -> Quat<T> {
         Quat::new(one(), zero(), zero(), zero())
     }
 
@@ -94,30 +94,30 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
      * The additive identity, ie: `q = 0 + 0i + 0j + 0i`
      */
     #[inline(always)]
-    static fn zero() -> Quat<T> {
+    fn zero() -> Quat<T> {
         Quat::new(zero(), zero(), zero(), zero())
     }
 
     #[inline(always)]
-    static fn from_angle_x(radians: T) -> Quat<T> {
+    fn from_angle_x(radians: T) -> Quat<T> {
         let _2 = Number::from(2);
         Quat::new(cos(radians / _2), sin(radians), zero(), zero())
     }
 
     #[inline(always)]
-    static fn from_angle_y(radians: T) -> Quat<T> {
+    fn from_angle_y(radians: T) -> Quat<T> {
         let _2 = Number::from(2);
         Quat::new(cos(radians / _2), zero(), sin(radians), zero())
     }
 
     #[inline(always)]
-    static fn from_angle_z(radians: T) -> Quat<T> {
+    fn from_angle_z(radians: T) -> Quat<T> {
         let _2 = Number::from(2);
         Quat::new(cos(radians / _2), zero(), zero(), sin(radians))
     }
 
     #[inline(always)]
-    static fn from_angle_xyz(radians_x: T, radians_y: T, radians_z: T) -> Quat<T> {
+    fn from_angle_xyz(radians_x: T, radians_y: T, radians_z: T) -> Quat<T> {
         // http://en.wikipedia.org/wiki/Conversion_between_quaternions_and_Euler_angles#Conversion
         let _2 = Number::from(2);
         let xdiv2 = radians_x / _2;
@@ -130,13 +130,13 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
     }
 
     #[inline(always)]
-    static fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Quat<T> {
+    fn from_angle_axis(radians: T, axis: &Vec3<T>) -> Quat<T> {
         let half = radians / Number::from(2);
         Quat::from_sv(cos(half), axis.mul_t(sin(half)))
     }
 
     #[inline(always)]
-    static fn from_axes(x: Vec3<T>, y: Vec3<T>, z: Vec3<T>) -> Quat<T> {
+    fn from_axes(x: Vec3<T>, y: Vec3<T>, z: Vec3<T>) -> Quat<T> {
         let m: Mat3<T> = Matrix3::from_axes(x, y, z); m.to_quat()
     }
 
@@ -145,7 +145,7 @@ impl<T:Copy + Float + FuzzyEq<T> + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + N
     }
 
     #[inline(always)]
-    static fn look_at(dir: &Vec3<T>, up: &Vec3<T>) -> Quat<T> {
+    fn look_at(dir: &Vec3<T>, up: &Vec3<T>) -> Quat<T> {
         let m: Mat3<T> = Matrix3::look_at(dir, up); m.to_quat()
     }
 
@@ -431,33 +431,33 @@ pub type dquat = Quat<f64>;             /// a double-precision floating-point qu
 // Static method wrappers for GLSL-style types
 
 impl quat {
-    #[inline(always)] static fn new(w: f32, xi: f32, yj: f32, zk: f32) -> quat { Quat::new(w, xi, yj, zk) }
-    #[inline(always)] static fn from_sv(s: f32, v: vec3) -> quat { Quat::from_sv(s, v) }
-    #[inline(always)] static fn identity() -> quat { Quat::identity() }
-    #[inline(always)] static fn zero() -> quat { Quat::zero() }
+    #[inline(always)] fn new(w: f32, xi: f32, yj: f32, zk: f32) -> quat { Quat::new(w, xi, yj, zk) }
+    #[inline(always)] fn from_sv(s: f32, v: vec3) -> quat { Quat::from_sv(s, v) }
+    #[inline(always)] fn identity() -> quat { Quat::identity() }
+    #[inline(always)] fn zero() -> quat { Quat::zero() }
 
-    #[inline(always)] static fn from_angle_x(radians: f32) -> quat { Quat::from_angle_x(radians) }
-    #[inline(always)] static fn from_angle_y(radians: f32) -> quat { Quat::from_angle_y(radians) }
-    #[inline(always)] static fn from_angle_z(radians: f32) -> quat { Quat::from_angle_z(radians) }
-    #[inline(always)] static fn from_angle_xyz(radians_x: f32, radians_y: f32, radians_z: f32)
+    #[inline(always)] fn from_angle_x(radians: f32) -> quat { Quat::from_angle_x(radians) }
+    #[inline(always)] fn from_angle_y(radians: f32) -> quat { Quat::from_angle_y(radians) }
+    #[inline(always)] fn from_angle_z(radians: f32) -> quat { Quat::from_angle_z(radians) }
+    #[inline(always)] fn from_angle_xyz(radians_x: f32, radians_y: f32, radians_z: f32)
         -> quat { Quat::from_angle_xyz(radians_x, radians_y, radians_z) }
-    #[inline(always)] static fn from_angle_axis(radians: f32, axis: &vec3) -> quat { Quat::from_angle_axis(radians, axis) }
-    #[inline(always)] static fn from_axes(x: vec3, y: vec3, z: vec3) -> quat { Quat::from_axes(x, y, z) }
-    #[inline(always)] static fn look_at(dir: &vec3, up: &vec3) -> quat { Quat::look_at(dir, up) }
+    #[inline(always)] fn from_angle_axis(radians: f32, axis: &vec3) -> quat { Quat::from_angle_axis(radians, axis) }
+    #[inline(always)] fn from_axes(x: vec3, y: vec3, z: vec3) -> quat { Quat::from_axes(x, y, z) }
+    #[inline(always)] fn look_at(dir: &vec3, up: &vec3) -> quat { Quat::look_at(dir, up) }
 }
 
 impl dquat {
-    #[inline(always)] static fn new(w: f64, xi: f64, yj: f64, zk: f64) -> dquat { Quat::new(w, xi, yj, zk) }
-    #[inline(always)] static fn from_sv(s: f64, v: dvec3) -> dquat { Quat::from_sv(s, v) }
-    #[inline(always)] static fn identity() -> dquat { Quat::identity() }
-    #[inline(always)] static fn zero() -> dquat { Quat::zero() }
+    #[inline(always)] fn new(w: f64, xi: f64, yj: f64, zk: f64) -> dquat { Quat::new(w, xi, yj, zk) }
+    #[inline(always)] fn from_sv(s: f64, v: dvec3) -> dquat { Quat::from_sv(s, v) }
+    #[inline(always)] fn identity() -> dquat { Quat::identity() }
+    #[inline(always)] fn zero() -> dquat { Quat::zero() }
 
-    #[inline(always)] static fn from_angle_x(radians: f64) -> dquat { Quat::from_angle_x(radians) }
-    #[inline(always)] static fn from_angle_y(radians: f64) -> dquat { Quat::from_angle_y(radians) }
-    #[inline(always)] static fn from_angle_z(radians: f64) -> dquat { Quat::from_angle_z(radians) }
-    #[inline(always)] static fn from_angle_xyz(radians_x: f64, radians_y: f64, radians_z: f64)
+    #[inline(always)] fn from_angle_x(radians: f64) -> dquat { Quat::from_angle_x(radians) }
+    #[inline(always)] fn from_angle_y(radians: f64) -> dquat { Quat::from_angle_y(radians) }
+    #[inline(always)] fn from_angle_z(radians: f64) -> dquat { Quat::from_angle_z(radians) }
+    #[inline(always)] fn from_angle_xyz(radians_x: f64, radians_y: f64, radians_z: f64)
         -> dquat { Quat::from_angle_xyz(radians_x, radians_y, radians_z) }
-    #[inline(always)] static fn from_angle_axis(radians: f64, axis: &dvec3) -> dquat { Quat::from_angle_axis(radians, axis) }
-    #[inline(always)] static fn from_axes(x: dvec3, y: dvec3, z: dvec3) -> dquat { Quat::from_axes(x, y, z) }
-    #[inline(always)] static fn look_at(dir: &dvec3, up: &dvec3) -> dquat { Quat::look_at(dir, up) }
+    #[inline(always)] fn from_angle_axis(radians: f64, axis: &dvec3) -> dquat { Quat::from_angle_axis(radians, axis) }
+    #[inline(always)] fn from_axes(x: dvec3, y: dvec3, z: dvec3) -> dquat { Quat::from_axes(x, y, z) }
+    #[inline(always)] fn look_at(dir: &dvec3, up: &dvec3) -> dquat { Quat::look_at(dir, up) }
 }
diff --git a/src/vec.rs b/src/vec.rs
index 7e11c04..fed64f6 100644
--- a/src/vec.rs
+++ b/src/vec.rs
@@ -21,7 +21,7 @@ pub trait Vector<T>: Index<uint, T> + Eq {
     /**
      * Construct the vector from a single value, copying it to each component
      */
-    static fn from_value(value: T) -> Self;
+    fn from_value(value: T) -> Self;
 
     /**
      * # Return value
@@ -47,21 +47,21 @@ pub trait MutableVector<T>: Vector<T> {
  * A generic 2-dimensional vector
  */
 pub trait Vector2<T>: Vector<T> {
-    static fn new(x: T, y: T) -> Self;
+    fn new(x: T, y: T) -> Self;
 }
 
 /**
  * A generic 3-dimensional vector
  */
 pub trait Vector3<T>: Vector<T> {
-    static fn new(x: T, y: T, z: T) -> Self;
+    fn new(x: T, y: T, z: T) -> Self;
 }
 
 /**
  * A generic 4-dimensional vector
  */
 pub trait Vector4<T>: Vector<T> {
-    static fn new(x: T, y: T, z: T, w: T) -> Self;
+    fn new(x: T, y: T, z: T, w: T) -> Self;
 }
 
 /**
@@ -75,7 +75,7 @@ pub trait NumericVector<T>: Vector<T> + Neg<Self> {
      *
      * A vector with each component set to one
      */
-    static fn identity() -> Self;
+    fn identity() -> Self;
 
     /**
      * The null vector
@@ -84,7 +84,7 @@ pub trait NumericVector<T>: Vector<T> + Neg<Self> {
      *
      * A vector with each component set to zero
      */
-    static fn zero() -> Self;
+    fn zero() -> Self;
 
     /**
      * # Return value
@@ -139,8 +139,8 @@ pub trait NumericVector<T>: Vector<T> + Neg<Self> {
  * A 2-dimensional vector with numeric components
  */
 pub trait NumericVector2<T>: NumericVector<T> {
-    static fn unit_x() -> Self;
-    static fn unit_y() -> Self;
+    fn unit_x() -> Self;
+    fn unit_y() -> Self;
 
     /**
      * # Return value
@@ -154,9 +154,9 @@ pub trait NumericVector2<T>: NumericVector<T> {
  * A 3-dimensional vector with numeric components
  */
 pub trait NumericVector3<T>: NumericVector<T> {
-    static fn unit_x() -> Self;
-    static fn unit_y() -> Self;
-    static fn unit_z() -> Self;
+    fn unit_x() -> Self;
+    fn unit_y() -> Self;
+    fn unit_z() -> Self;
 
     /**
      * # Return value
@@ -170,10 +170,10 @@ pub trait NumericVector3<T>: NumericVector<T> {
  * A 4-dimensional vector with numeric components
  */
 pub trait NumericVector4<T>: NumericVector<T> {
-    static fn unit_x() -> Self;
-    static fn unit_y() -> Self;
-    static fn unit_z() -> Self;
-    static fn unit_w() -> Self;
+    fn unit_x() -> Self;
+    fn unit_y() -> Self;
+    fn unit_z() -> Self;
+    fn unit_w() -> Self;
 }
 
 /**
diff --git a/src/vec2.rs b/src/vec2.rs
index ed35c52..eacae0c 100644
--- a/src/vec2.rs
+++ b/src/vec2.rs
@@ -45,7 +45,7 @@ pub struct Vec2<T> { x: T, y: T }
 
 impl<T:Copy + Eq> Vector<T> for Vec2<T> {
     #[inline(always)]
-    static fn from_value(value: T) -> Vec2<T> {
+    fn from_value(value: T) -> Vec2<T> {
         Vector2::new(value, value)
     }
 
@@ -61,7 +61,7 @@ impl<T:Copy + Eq> Vector<T> for Vec2<T> {
 
 impl<T> Vector2<T> for Vec2<T> {
     #[inline(always)]
-    static fn new(x: T, y: T ) -> Vec2<T> {
+    fn new(x: T, y: T ) -> Vec2<T> {
         Vec2 { x: x, y: y }
     }
 }
@@ -92,12 +92,12 @@ impl<T:Copy> MutableVector<T> for Vec2<T> {
 
 impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> NumericVector<T> for Vec2<T> {
     #[inline(always)]
-    static fn identity() -> Vec2<T> {
+    fn identity() -> Vec2<T> {
         Vector2::new(one::<T>(), one::<T>())
     }
 
     #[inline(always)]
-    static fn zero() -> Vec2<T> {
+    fn zero() -> Vec2<T> {
         Vector2::new(zero::<T>(), zero::<T>())
     }
 
@@ -159,12 +159,12 @@ impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> Neg<V
 
 impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> NumericVector2<T> for Vec2<T> {
     #[inline(always)]
-    static fn unit_x() -> Vec2<T> {
+    fn unit_x() -> Vec2<T> {
         Vector2::new(one::<T>(), zero::<T>())
     }
 
     #[inline(always)]
-    static fn unit_y() -> Vec2<T> {
+    fn unit_y() -> Vec2<T> {
         Vector2::new(zero::<T>(), one::<T>())
     }
 
@@ -367,63 +367,63 @@ pub type uvec2 = Vec2<u32>;     // a two-component unsigned integer vector
 // Static method wrappers for GLSL-style types
 
 impl vec2 {
-    #[inline(always)] static fn new(x: f32, y: f32) -> vec2 { Vector2::new(x, y) }
-    #[inline(always)] static fn from_value(v: f32) -> vec2 { Vector::from_value(v) }
-    #[inline(always)] static fn identity() -> vec2 { NumericVector::identity() }
-    #[inline(always)] static fn zero() -> vec2 { NumericVector::zero() }
+    #[inline(always)] fn new(x: f32, y: f32) -> vec2 { Vector2::new(x, y) }
+    #[inline(always)] fn from_value(v: f32) -> vec2 { Vector::from_value(v) }
+    #[inline(always)] fn identity() -> vec2 { NumericVector::identity() }
+    #[inline(always)] fn zero() -> vec2 { NumericVector::zero() }
 
-    #[inline(always)] static fn unit_x() -> vec2 { NumericVector2::unit_x() }
-    #[inline(always)] static fn unit_y() -> vec2 { NumericVector2::unit_y() }
+    #[inline(always)] fn unit_x() -> vec2 { NumericVector2::unit_x() }
+    #[inline(always)] fn unit_y() -> vec2 { NumericVector2::unit_y() }
 
-    #[inline(always)] static fn dim() -> uint { 2 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<vec2>() }
+    #[inline(always)] fn dim() -> uint { 2 }
+    #[inline(always)] fn size_of() -> uint { size_of::<vec2>() }
 }
 
 impl dvec2 {
-    #[inline(always)] static fn new(x: f64, y: f64) -> dvec2 { Vector2::new(x, y) }
-    #[inline(always)] static fn from_value(v: f64) -> dvec2 { Vector::from_value(v) }
-    #[inline(always)] static fn identity() -> dvec2 { NumericVector::identity() }
-    #[inline(always)] static fn zero() -> dvec2 { NumericVector::zero() }
+    #[inline(always)] fn new(x: f64, y: f64) -> dvec2 { Vector2::new(x, y) }
+    #[inline(always)] fn from_value(v: f64) -> dvec2 { Vector::from_value(v) }
+    #[inline(always)] fn identity() -> dvec2 { NumericVector::identity() }
+    #[inline(always)] fn zero() -> dvec2 { NumericVector::zero() }
 
-    #[inline(always)] static fn unit_x() -> dvec2 { NumericVector2::unit_x() }
-    #[inline(always)] static fn unit_y() -> dvec2 { NumericVector2::unit_y() }
+    #[inline(always)] fn unit_x() -> dvec2 { NumericVector2::unit_x() }
+    #[inline(always)] fn unit_y() -> dvec2 { NumericVector2::unit_y() }
 
-    #[inline(always)] static fn dim() -> uint { 2 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<dvec2>() }
+    #[inline(always)] fn dim() -> uint { 2 }
+    #[inline(always)] fn size_of() -> uint { size_of::<dvec2>() }
 }
 
 impl bvec2 {
-    #[inline(always)] static fn new(x: bool, y: bool) -> bvec2 { Vector2::new(x, y) }
-    #[inline(always)] static fn from_value(v: bool) -> bvec2 { Vector::from_value(v) }
+    #[inline(always)] fn new(x: bool, y: bool) -> bvec2 { Vector2::new(x, y) }
+    #[inline(always)] fn from_value(v: bool) -> bvec2 { Vector::from_value(v) }
 
-    #[inline(always)] static fn dim() -> uint { 2 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<bvec2>() }
+    #[inline(always)] fn dim() -> uint { 2 }
+    #[inline(always)] fn size_of() -> uint { size_of::<bvec2>() }
 }
 
 impl ivec2 {
-    #[inline(always)] static fn new(x: i32, y: i32) -> ivec2 { Vector2::new(x, y) }
-    #[inline(always)] static fn from_value(v: i32) -> ivec2 { Vector::from_value(v) }
-    #[inline(always)] static fn identity() -> ivec2 { NumericVector::identity() }
-    #[inline(always)] static fn zero() -> ivec2 { NumericVector::zero() }
+    #[inline(always)] fn new(x: i32, y: i32) -> ivec2 { Vector2::new(x, y) }
+    #[inline(always)] fn from_value(v: i32) -> ivec2 { Vector::from_value(v) }
+    #[inline(always)] fn identity() -> ivec2 { NumericVector::identity() }
+    #[inline(always)] fn zero() -> ivec2 { NumericVector::zero() }
 
-    #[inline(always)] static fn unit_x() -> ivec2 { NumericVector2::unit_x() }
-    #[inline(always)] static fn unit_y() -> ivec2 { NumericVector2::unit_y() }
+    #[inline(always)] fn unit_x() -> ivec2 { NumericVector2::unit_x() }
+    #[inline(always)] fn unit_y() -> ivec2 { NumericVector2::unit_y() }
 
-    #[inline(always)] static fn dim() -> uint { 2 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<ivec2>() }
+    #[inline(always)] fn dim() -> uint { 2 }
+    #[inline(always)] fn size_of() -> uint { size_of::<ivec2>() }
 }
 
 impl uvec2 {
-    #[inline(always)] static fn new(x: u32, y: u32) -> uvec2 { Vector2::new(x, y) }
-    #[inline(always)] static fn from_value(v: u32) -> uvec2 { Vector::from_value(v) }
-    #[inline(always)] static fn identity() -> uvec2 { NumericVector::identity() }
-    #[inline(always)] static fn zero() -> uvec2 { NumericVector::zero() }
+    #[inline(always)] fn new(x: u32, y: u32) -> uvec2 { Vector2::new(x, y) }
+    #[inline(always)] fn from_value(v: u32) -> uvec2 { Vector::from_value(v) }
+    #[inline(always)] fn identity() -> uvec2 { NumericVector::identity() }
+    #[inline(always)] fn zero() -> uvec2 { NumericVector::zero() }
 
-    #[inline(always)] static fn unit_x() -> uvec2 { NumericVector2::unit_x() }
-    #[inline(always)] static fn unit_y() -> uvec2 { NumericVector2::unit_y() }
+    #[inline(always)] fn unit_x() -> uvec2 { NumericVector2::unit_x() }
+    #[inline(always)] fn unit_y() -> uvec2 { NumericVector2::unit_y() }
 
-    #[inline(always)] static fn dim() -> uint { 2 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<uvec2>() }
+    #[inline(always)] fn dim() -> uint { 2 }
+    #[inline(always)] fn size_of() -> uint { size_of::<uvec2>() }
 }
 
 // Type aliases named in a more 'Rustic' style
diff --git a/src/vec3.rs b/src/vec3.rs
index f4a9a56..167bff6 100644
--- a/src/vec3.rs
+++ b/src/vec3.rs
@@ -47,7 +47,7 @@ pub struct Vec3<T> { x: T, y: T, z: T }
 
 impl<T:Copy + Eq> Vector<T> for Vec3<T> {
     #[inline(always)]
-    static fn from_value(value: T) -> Vec3<T> {
+    fn from_value(value: T) -> Vec3<T> {
         Vector3::new(value, value, value)
     }
 
@@ -63,7 +63,7 @@ impl<T:Copy + Eq> Vector<T> for Vec3<T> {
 
 impl<T> Vector3<T> for Vec3<T> {
     #[inline(always)]
-    static fn new(x: T, y: T, z: T) -> Vec3<T> {
+    fn new(x: T, y: T, z: T) -> Vec3<T> {
         Vec3 { x: x, y: y, z: z }
     }
 }
@@ -95,12 +95,12 @@ impl<T:Copy> MutableVector<T> for Vec3<T> {
 
 impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> NumericVector<T> for Vec3<T> {
     #[inline(always)]
-    static fn identity() -> Vec3<T> {
+    fn identity() -> Vec3<T> {
         Vector3::new(one::<T>(), one::<T>(), one::<T>())
     }
 
     #[inline(always)]
-    static fn zero() -> Vec3<T> {
+    fn zero() -> Vec3<T> {
         Vector3::new(zero::<T>(), zero::<T>(), zero::<T>())
     }
 
@@ -170,17 +170,17 @@ impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> Neg<V
 
 impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> NumericVector3<T> for Vec3<T> {
     #[inline(always)]
-    static fn unit_x() -> Vec3<T> {
+    fn unit_x() -> Vec3<T> {
         Vector3::new(one::<T>(), zero::<T>(), zero::<T>())
     }
 
     #[inline(always)]
-    static fn unit_y() -> Vec3<T> {
+    fn unit_y() -> Vec3<T> {
         Vector3::new(zero::<T>(), one::<T>(), zero::<T>())
     }
 
     #[inline(always)]
-    static fn unit_z() -> Vec3<T> {
+    fn unit_z() -> Vec3<T> {
         Vector3::new(zero::<T>(), zero::<T>(), one::<T>())
     }
 
@@ -406,65 +406,65 @@ pub type uvec3 = Vec3<u32>;     // a three-component unsigned integer vector
 // Static method wrappers for GLSL-style types
 
 impl vec3 {
-    #[inline(always)] static fn new(x: f32, y: f32, z: f32) -> vec3 { Vector3::new(x, y, z) }
-    #[inline(always)] static fn from_value(v: f32) -> vec3 { Vector::from_value(v) }
-    #[inline(always)] static fn identity() -> vec3 { NumericVector::identity() }
-    #[inline(always)] static fn zero() -> vec3 { NumericVector::zero() }
+    #[inline(always)] fn new(x: f32, y: f32, z: f32) -> vec3 { Vector3::new(x, y, z) }
+    #[inline(always)] fn from_value(v: f32) -> vec3 { Vector::from_value(v) }
+    #[inline(always)] fn identity() -> vec3 { NumericVector::identity() }
+    #[inline(always)] fn zero() -> vec3 { NumericVector::zero() }
 
-    #[inline(always)] static fn unit_x() -> vec3 { NumericVector3::unit_x() }
-    #[inline(always)] static fn unit_y() -> vec3 { NumericVector3::unit_y() }
-    #[inline(always)] static fn unit_z() -> vec3 { NumericVector3::unit_z() }
+    #[inline(always)] fn unit_x() -> vec3 { NumericVector3::unit_x() }
+    #[inline(always)] fn unit_y() -> vec3 { NumericVector3::unit_y() }
+    #[inline(always)] fn unit_z() -> vec3 { NumericVector3::unit_z() }
 
-    #[inline(always)] static fn dim() -> uint { 3 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<vec3>() }
+    #[inline(always)] fn dim() -> uint { 3 }
+    #[inline(always)] fn size_of() -> uint { size_of::<vec3>() }
 }
 
 impl dvec3 {
-    #[inline(always)] static fn new(x: f64, y: f64, z: f64) -> dvec3 { Vector3::new(x, y, z) }
-    #[inline(always)] static fn from_value(v: f64) -> dvec3 { Vector::from_value(v) }
-    #[inline(always)] static fn identity() -> dvec3 { NumericVector::identity() }
-    #[inline(always)] static fn zero() -> dvec3 { NumericVector::zero() }
+    #[inline(always)] fn new(x: f64, y: f64, z: f64) -> dvec3 { Vector3::new(x, y, z) }
+    #[inline(always)] fn from_value(v: f64) -> dvec3 { Vector::from_value(v) }
+    #[inline(always)] fn identity() -> dvec3 { NumericVector::identity() }
+    #[inline(always)] fn zero() -> dvec3 { NumericVector::zero() }
 
-    #[inline(always)] static fn unit_x() -> dvec3 { NumericVector3::unit_x() }
-    #[inline(always)] static fn unit_y() -> dvec3 { NumericVector3::unit_y() }
-    #[inline(always)] static fn unit_z() -> dvec3 { NumericVector3::unit_z() }
+    #[inline(always)] fn unit_x() -> dvec3 { NumericVector3::unit_x() }
+    #[inline(always)] fn unit_y() -> dvec3 { NumericVector3::unit_y() }
+    #[inline(always)] fn unit_z() -> dvec3 { NumericVector3::unit_z() }
 
-    #[inline(always)] static fn dim() -> uint { 3 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<dvec3>() }
+    #[inline(always)] fn dim() -> uint { 3 }
+    #[inline(always)] fn size_of() -> uint { size_of::<dvec3>() }
 }
 
 impl bvec3 {
-    #[inline(always)] static fn new(x: bool, y: bool, z: bool) -> bvec3 { Vector3::new(x, y, z) }
-    #[inline(always)] static fn from_value(v: bool) -> bvec3 { Vector::from_value(v) }
+    #[inline(always)] fn new(x: bool, y: bool, z: bool) -> bvec3 { Vector3::new(x, y, z) }
+    #[inline(always)] fn from_value(v: bool) -> bvec3 { Vector::from_value(v) }
 
-    #[inline(always)] static fn dim() -> uint { 3 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<bvec3>() }
+    #[inline(always)] fn dim() -> uint { 3 }
+    #[inline(always)] fn size_of() -> uint { size_of::<bvec3>() }
 }
 
 impl ivec3 {
-    #[inline(always)] static fn new(x: i32, y: i32, z: i32) -> ivec3 { Vector3::new(x, y, z) }
-    #[inline(always)] static fn from_value(v: i32) -> ivec3 { Vector::from_value(v) }
-    #[inline(always)] static fn identity() -> ivec3 { NumericVector::identity() }
-    #[inline(always)] static fn zero() -> ivec3 { NumericVector::zero() }
+    #[inline(always)] fn new(x: i32, y: i32, z: i32) -> ivec3 { Vector3::new(x, y, z) }
+    #[inline(always)] fn from_value(v: i32) -> ivec3 { Vector::from_value(v) }
+    #[inline(always)] fn identity() -> ivec3 { NumericVector::identity() }
+    #[inline(always)] fn zero() -> ivec3 { NumericVector::zero() }
 
-    #[inline(always)] static fn unit_x() -> ivec3 { NumericVector3::unit_x() }
-    #[inline(always)] static fn unit_y() -> ivec3 { NumericVector3::unit_y() }
-    #[inline(always)] static fn unit_z() -> ivec3 { NumericVector3::unit_z() }
+    #[inline(always)] fn unit_x() -> ivec3 { NumericVector3::unit_x() }
+    #[inline(always)] fn unit_y() -> ivec3 { NumericVector3::unit_y() }
+    #[inline(always)] fn unit_z() -> ivec3 { NumericVector3::unit_z() }
 
-    #[inline(always)] static fn dim() -> uint { 3 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<ivec3>() }
+    #[inline(always)] fn dim() -> uint { 3 }
+    #[inline(always)] fn size_of() -> uint { size_of::<ivec3>() }
 }
 
 impl uvec3 {
-    #[inline(always)] static fn new(x: u32, y: u32, z: u32) -> uvec3 { Vector3::new(x, y, z) }
-    #[inline(always)] static fn from_value(v: u32) -> uvec3 { Vector::from_value(v) }
-    #[inline(always)] static fn identity() -> uvec3 { NumericVector::identity() }
-    #[inline(always)] static fn zero() -> uvec3 { NumericVector::zero() }
+    #[inline(always)] fn new(x: u32, y: u32, z: u32) -> uvec3 { Vector3::new(x, y, z) }
+    #[inline(always)] fn from_value(v: u32) -> uvec3 { Vector::from_value(v) }
+    #[inline(always)] fn identity() -> uvec3 { NumericVector::identity() }
+    #[inline(always)] fn zero() -> uvec3 { NumericVector::zero() }
 
-    #[inline(always)] static fn unit_x() -> uvec3 { NumericVector3::unit_x() }
-    #[inline(always)] static fn unit_y() -> uvec3 { NumericVector3::unit_y() }
-    #[inline(always)] static fn unit_z() -> uvec3 { NumericVector3::unit_z() }
+    #[inline(always)] fn unit_x() -> uvec3 { NumericVector3::unit_x() }
+    #[inline(always)] fn unit_y() -> uvec3 { NumericVector3::unit_y() }
+    #[inline(always)] fn unit_z() -> uvec3 { NumericVector3::unit_z() }
 
-    #[inline(always)] static fn dim() -> uint { 3 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<uvec3>() }
+    #[inline(always)] fn dim() -> uint { 3 }
+    #[inline(always)] fn size_of() -> uint { size_of::<uvec3>() }
 }
diff --git a/src/vec4.rs b/src/vec4.rs
index ac4a7ad..ee247f5 100644
--- a/src/vec4.rs
+++ b/src/vec4.rs
@@ -45,7 +45,7 @@ pub struct Vec4<T> { x: T, y: T, z: T, w: T }
 
 impl<T:Copy + Eq> Vector<T> for Vec4<T> {
     #[inline(always)]
-    static fn from_value(value: T) -> Vec4<T> {
+    fn from_value(value: T) -> Vec4<T> {
         Vector4::new(value, value, value, value)
     }
 
@@ -61,7 +61,7 @@ impl<T:Copy + Eq> Vector<T> for Vec4<T> {
 
 impl<T> Vector4<T> for Vec4<T> {
     #[inline(always)]
-    static fn new(x: T, y: T, z: T, w: T) -> Vec4<T> {
+    fn new(x: T, y: T, z: T, w: T) -> Vec4<T> {
         Vec4 { x: x, y: y, z: z, w: w }
     }
 }
@@ -94,12 +94,12 @@ impl<T:Copy> MutableVector<T> for Vec4<T> {
 
 impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> NumericVector<T> for Vec4<T> {
     #[inline(always)]
-    static fn identity() -> Vec4<T> {
+    fn identity() -> Vec4<T> {
         Vector4::new(one::<T>(), one::<T>(), one::<T>(), one::<T>())
     }
 
     #[inline(always)]
-    static fn zero() -> Vec4<T> {
+    fn zero() -> Vec4<T> {
         Vector4::new(zero::<T>(), zero::<T>(), zero::<T>(), zero::<T>())
     }
 
@@ -177,22 +177,22 @@ impl<T:Copy + Number + Add<T,T> + Sub<T,T> + Mul<T,T> + Div<T,T> + Neg<T>> Neg<V
 
 impl<T:Copy + Number> NumericVector4<T> for Vec4<T> {
     #[inline(always)]
-    static fn unit_x() -> Vec4<T> {
+    fn unit_x() -> Vec4<T> {
         Vector4::new(one::<T>(), zero::<T>(), zero::<T>(), zero::<T>())
     }
 
     #[inline(always)]
-    static fn unit_y() -> Vec4<T> {
+    fn unit_y() -> Vec4<T> {
         Vector4::new(zero::<T>(), one::<T>(), zero::<T>(), zero::<T>())
     }
 
     #[inline(always)]
-    static fn unit_z() -> Vec4<T> {
+    fn unit_z() -> Vec4<T> {
         Vector4::new(zero::<T>(), zero::<T>(), one::<T>(), zero::<T>())
     }
 
     #[inline(always)]
-    static fn unit_w() -> Vec4<T> {
+    fn unit_w() -> Vec4<T> {
         Vector4::new(zero::<T>(), zero::<T>(), zero::<T>(), one::<T>())
     }
 }
@@ -411,70 +411,70 @@ pub type uvec4 = Vec4<u32>;     // a four-component unsigned integer vector
 // Static method wrappers for GLSL-style types
 
 impl vec4 {
-    #[inline(always)] static fn new(x: f32, y: f32, z: f32, w: f32) -> vec4 { Vector4::new(x, y, z, w) }
-    #[inline(always)] static fn from_value(v: f32) -> vec4 { Vector::from_value(v) }
-    #[inline(always)] static fn identity() -> vec4 { NumericVector::identity() }
-    #[inline(always)] static fn zero() -> vec4 { NumericVector::zero() }
+    #[inline(always)] fn new(x: f32, y: f32, z: f32, w: f32) -> vec4 { Vector4::new(x, y, z, w) }
+    #[inline(always)] fn from_value(v: f32) -> vec4 { Vector::from_value(v) }
+    #[inline(always)] fn identity() -> vec4 { NumericVector::identity() }
+    #[inline(always)] fn zero() -> vec4 { NumericVector::zero() }
 
-    #[inline(always)] static fn unit_x() -> vec4 { NumericVector4::unit_x() }
-    #[inline(always)] static fn unit_y() -> vec4 { NumericVector4::unit_y() }
-    #[inline(always)] static fn unit_z() -> vec4 { NumericVector4::unit_z() }
-    #[inline(always)] static fn unit_w() -> vec4 { NumericVector4::unit_w() }
+    #[inline(always)] fn unit_x() -> vec4 { NumericVector4::unit_x() }
+    #[inline(always)] fn unit_y() -> vec4 { NumericVector4::unit_y() }
+    #[inline(always)] fn unit_z() -> vec4 { NumericVector4::unit_z() }
+    #[inline(always)] fn unit_w() -> vec4 { NumericVector4::unit_w() }
 
-    #[inline(always)] static fn dim() -> uint { 4 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<vec4>() }
+    #[inline(always)] fn dim() -> uint { 4 }
+    #[inline(always)] fn size_of() -> uint { size_of::<vec4>() }
 }
 
 impl dvec4 {
-    #[inline(always)] static fn new(x: f64, y: f64, z: f64, w: f64) -> dvec4 { Vector4::new(x, y, z, w) }
-    #[inline(always)] static fn from_value(v: f64) -> dvec4 { Vector::from_value(v) }
-    #[inline(always)] static fn identity() -> dvec4 { NumericVector::identity() }
-    #[inline(always)] static fn zero() -> dvec4 { NumericVector::zero() }
+    #[inline(always)] fn new(x: f64, y: f64, z: f64, w: f64) -> dvec4 { Vector4::new(x, y, z, w) }
+    #[inline(always)] fn from_value(v: f64) -> dvec4 { Vector::from_value(v) }
+    #[inline(always)] fn identity() -> dvec4 { NumericVector::identity() }
+    #[inline(always)] fn zero() -> dvec4 { NumericVector::zero() }
 
-    #[inline(always)] static fn unit_x() -> dvec4 { NumericVector4::unit_x() }
-    #[inline(always)] static fn unit_y() -> dvec4 { NumericVector4::unit_y() }
-    #[inline(always)] static fn unit_z() -> dvec4 { NumericVector4::unit_z() }
-    #[inline(always)] static fn unit_w() -> dvec4 { NumericVector4::unit_w() }
+    #[inline(always)] fn unit_x() -> dvec4 { NumericVector4::unit_x() }
+    #[inline(always)] fn unit_y() -> dvec4 { NumericVector4::unit_y() }
+    #[inline(always)] fn unit_z() -> dvec4 { NumericVector4::unit_z() }
+    #[inline(always)] fn unit_w() -> dvec4 { NumericVector4::unit_w() }
 
-    #[inline(always)] static fn dim() -> uint { 4 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<dvec4>() }
+    #[inline(always)] fn dim() -> uint { 4 }
+    #[inline(always)] fn size_of() -> uint { size_of::<dvec4>() }
 }
 
 
 impl bvec4 {
-    #[inline(always)] static fn new(x: bool, y: bool, z: bool, w: bool) -> bvec4 { Vector4::new(x, y, z, w) }
-    #[inline(always)] static fn from_value(v: bool) -> bvec4 { Vector::from_value(v) }
+    #[inline(always)] fn new(x: bool, y: bool, z: bool, w: bool) -> bvec4 { Vector4::new(x, y, z, w) }
+    #[inline(always)] fn from_value(v: bool) -> bvec4 { Vector::from_value(v) }
 
-    #[inline(always)] static fn dim() -> uint { 4 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<bvec4>() }
+    #[inline(always)] fn dim() -> uint { 4 }
+    #[inline(always)] fn size_of() -> uint { size_of::<bvec4>() }
 }
 
 impl ivec4 {
-    #[inline(always)] static fn new(x: i32, y: i32, z: i32, w: i32) -> ivec4 { Vector4::new(x, y, z, w) }
-    #[inline(always)] static fn from_value(v: i32) -> ivec4 { Vector::from_value(v) }
-    #[inline(always)] static fn identity() -> ivec4 { NumericVector::identity() }
-    #[inline(always)] static fn zero() -> ivec4 { NumericVector::zero() }
+    #[inline(always)] fn new(x: i32, y: i32, z: i32, w: i32) -> ivec4 { Vector4::new(x, y, z, w) }
+    #[inline(always)] fn from_value(v: i32) -> ivec4 { Vector::from_value(v) }
+    #[inline(always)] fn identity() -> ivec4 { NumericVector::identity() }
+    #[inline(always)] fn zero() -> ivec4 { NumericVector::zero() }
 
-    #[inline(always)] static fn unit_x() -> ivec4 { NumericVector4::unit_x() }
-    #[inline(always)] static fn unit_y() -> ivec4 { NumericVector4::unit_y() }
-    #[inline(always)] static fn unit_z() -> ivec4 { NumericVector4::unit_z() }
-    #[inline(always)] static fn unit_w() -> ivec4 { NumericVector4::unit_w() }
+    #[inline(always)] fn unit_x() -> ivec4 { NumericVector4::unit_x() }
+    #[inline(always)] fn unit_y() -> ivec4 { NumericVector4::unit_y() }
+    #[inline(always)] fn unit_z() -> ivec4 { NumericVector4::unit_z() }
+    #[inline(always)] fn unit_w() -> ivec4 { NumericVector4::unit_w() }
 
-    #[inline(always)] static fn dim() -> uint { 4 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<ivec4>() }
+    #[inline(always)] fn dim() -> uint { 4 }
+    #[inline(always)] fn size_of() -> uint { size_of::<ivec4>() }
 }
 
 impl uvec4 {
-    #[inline(always)] static fn new(x: u32, y: u32, z: u32, w: u32) -> uvec4 { Vector4::new(x, y, z, w) }
-    #[inline(always)] static fn from_value(v: u32) -> uvec4 { Vector::from_value(v) }
-    #[inline(always)] static fn identity() -> uvec4 { NumericVector::identity() }
-    #[inline(always)] static fn zero() -> uvec4 { NumericVector::zero() }
+    #[inline(always)] fn new(x: u32, y: u32, z: u32, w: u32) -> uvec4 { Vector4::new(x, y, z, w) }
+    #[inline(always)] fn from_value(v: u32) -> uvec4 { Vector::from_value(v) }
+    #[inline(always)] fn identity() -> uvec4 { NumericVector::identity() }
+    #[inline(always)] fn zero() -> uvec4 { NumericVector::zero() }
 
-    #[inline(always)] static fn unit_x() -> uvec4 { NumericVector4::unit_x() }
-    #[inline(always)] static fn unit_y() -> uvec4 { NumericVector4::unit_y() }
-    #[inline(always)] static fn unit_z() -> uvec4 { NumericVector4::unit_z() }
-    #[inline(always)] static fn unit_w() -> uvec4 { NumericVector4::unit_w() }
+    #[inline(always)] fn unit_x() -> uvec4 { NumericVector4::unit_x() }
+    #[inline(always)] fn unit_y() -> uvec4 { NumericVector4::unit_y() }
+    #[inline(always)] fn unit_z() -> uvec4 { NumericVector4::unit_z() }
+    #[inline(always)] fn unit_w() -> uvec4 { NumericVector4::unit_w() }
 
-    #[inline(always)] static fn dim() -> uint { 4 }
-    #[inline(always)] static fn size_of() -> uint { size_of::<uvec4>() }
+    #[inline(always)] fn dim() -> uint { 4 }
+    #[inline(always)] fn size_of() -> uint { size_of::<uvec4>() }
 }