diff --git a/src/common/ncast.rs b/src/common/ncast.rs
index 12a098c..6b61857 100644
--- a/src/common/ncast.rs
+++ b/src/common/ncast.rs
@@ -8,295 +8,295 @@ trait NumCast {
     static pure fn from<T:NumCast>(n: T) -> self;
     pure fn cast<T:NumCast>() -> T;
     
-    pure fn cast_u8()    -> u8;
-    pure fn cast_u16()   -> u16;
-    pure fn cast_u32()   -> u32;
-    pure fn cast_u64()   -> u64;
-    pure fn cast_uint()  ->  uint;
+    pure fn to_u8()    -> u8;
+    pure fn to_u16()   -> u16;
+    pure fn to_u32()   -> u32;
+    pure fn to_u64()   -> u64;
+    pure fn to_uint()  ->  uint;
     
-    pure fn cast_i8()    -> i8;
-    pure fn cast_i16()   -> i16;
-    pure fn cast_i32()   -> i32;
-    pure fn cast_i64()   -> i64;
-    pure fn cast_int()   -> int;
+    pure fn to_i8()    -> i8;
+    pure fn to_i16()   -> i16;
+    pure fn to_i32()   -> i32;
+    pure fn to_i64()   -> i64;
+    pure fn to_int()   -> int;
     
-    pure fn cast_f32()   -> f32;
-    pure fn cast_f64()   -> f64;
-    pure fn cast_float() -> float;
+    pure fn to_f32()   -> f32;
+    pure fn to_f64()   -> f64;
+    pure fn to_float() -> float;
 }
 
 #[inline(always)]
 pub pure fn cast<T:NumCast, U:NumCast>(n: T) -> U { n.cast() }
 
 pub impl u8: NumCast {
-    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> u8 { n.cast_u8() }
+    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> u8 { n.to_u8() }
     #[inline(always)] pure fn cast<T:NumCast>() -> T { from(self) }
     
-    #[inline(always)] pure fn cast_u8()    -> u8    { self          }
-    #[inline(always)] pure fn cast_u16()   -> u16   { self as u16   }
-    #[inline(always)] pure fn cast_u32()   -> u32   { self as u32   }
-    #[inline(always)] pure fn cast_u64()   -> u64   { self as u64   }
-    #[inline(always)] pure fn cast_uint()  -> uint  { self as uint  }
+    #[inline(always)] pure fn to_u8()    -> u8    { self          }
+    #[inline(always)] pure fn to_u16()   -> u16   { self as u16   }
+    #[inline(always)] pure fn to_u32()   -> u32   { self as u32   }
+    #[inline(always)] pure fn to_u64()   -> u64   { self as u64   }
+    #[inline(always)] pure fn to_uint()  -> uint  { self as uint  }
     
-    #[inline(always)] pure fn cast_i8()    -> i8    { self as i8    }
-    #[inline(always)] pure fn cast_i16()   -> i16   { self as i16   }
-    #[inline(always)] pure fn cast_i32()   -> i32   { self as i32   }
-    #[inline(always)] pure fn cast_i64()   -> i64   { self as i64   }
-    #[inline(always)] pure fn cast_int()   -> int   { self as int   }
+    #[inline(always)] pure fn to_i8()    -> i8    { self as i8    }
+    #[inline(always)] pure fn to_i16()   -> i16   { self as i16   }
+    #[inline(always)] pure fn to_i32()   -> i32   { self as i32   }
+    #[inline(always)] pure fn to_i64()   -> i64   { self as i64   }
+    #[inline(always)] pure fn to_int()   -> int   { self as int   }
     
-    #[inline(always)] pure fn cast_f32()   -> f32   { self as f32   }
-    #[inline(always)] pure fn cast_f64()   -> f64   { self as f64   }
-    #[inline(always)] pure fn cast_float() -> float { self as float }
+    #[inline(always)] pure fn to_f32()   -> f32   { self as f32   }
+    #[inline(always)] pure fn to_f64()   -> f64   { self as f64   }
+    #[inline(always)] pure fn to_float() -> float { self as float }
 }
 
 pub impl u16: NumCast {
-    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> u16 { n.cast_u16() }
+    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> u16 { n.to_u16() }
     #[inline(always)] pure fn cast<T:NumCast>() -> T { from(self) }
     
-    #[inline(always)] pure fn cast_u8()    -> u8    { self as u8    }
-    #[inline(always)] pure fn cast_u16()   -> u16   { self          }
-    #[inline(always)] pure fn cast_u32()   -> u32   { self as u32   }
-    #[inline(always)] pure fn cast_u64()   -> u64   { self as u64   }
-    #[inline(always)] pure fn cast_uint()  -> uint  { self as uint  }
+    #[inline(always)] pure fn to_u8()    -> u8    { self as u8    }
+    #[inline(always)] pure fn to_u16()   -> u16   { self          }
+    #[inline(always)] pure fn to_u32()   -> u32   { self as u32   }
+    #[inline(always)] pure fn to_u64()   -> u64   { self as u64   }
+    #[inline(always)] pure fn to_uint()  -> uint  { self as uint  }
     
-    #[inline(always)] pure fn cast_i8()    -> i8    { self as i8    }
-    #[inline(always)] pure fn cast_i16()   -> i16   { self as i16   }
-    #[inline(always)] pure fn cast_i32()   -> i32   { self as i32   }
-    #[inline(always)] pure fn cast_i64()   -> i64   { self as i64   }
-    #[inline(always)] pure fn cast_int()   -> int   { self as int   }
+    #[inline(always)] pure fn to_i8()    -> i8    { self as i8    }
+    #[inline(always)] pure fn to_i16()   -> i16   { self as i16   }
+    #[inline(always)] pure fn to_i32()   -> i32   { self as i32   }
+    #[inline(always)] pure fn to_i64()   -> i64   { self as i64   }
+    #[inline(always)] pure fn to_int()   -> int   { self as int   }
     
-    #[inline(always)] pure fn cast_f32()   -> f32   { self as f32   }
-    #[inline(always)] pure fn cast_f64()   -> f64   { self as f64   }
-    #[inline(always)] pure fn cast_float() -> float { self as float }
+    #[inline(always)] pure fn to_f32()   -> f32   { self as f32   }
+    #[inline(always)] pure fn to_f64()   -> f64   { self as f64   }
+    #[inline(always)] pure fn to_float() -> float { self as float }
 }
 
 pub impl u32: NumCast {
-    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> u32 { n.cast_u32() }
+    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> u32 { n.to_u32() }
     #[inline(always)] pure fn cast<T:NumCast>() -> T { from(self) }
     
-    #[inline(always)] pure fn cast_u8()    -> u8    { self as u8    }
-    #[inline(always)] pure fn cast_u16()   -> u16   { self as u16   }
-    #[inline(always)] pure fn cast_u32()   -> u32   { self          }
-    #[inline(always)] pure fn cast_u64()   -> u64   { self as u64   }
-    #[inline(always)] pure fn cast_uint()  -> uint  { self as uint  }
+    #[inline(always)] pure fn to_u8()    -> u8    { self as u8    }
+    #[inline(always)] pure fn to_u16()   -> u16   { self as u16   }
+    #[inline(always)] pure fn to_u32()   -> u32   { self          }
+    #[inline(always)] pure fn to_u64()   -> u64   { self as u64   }
+    #[inline(always)] pure fn to_uint()  -> uint  { self as uint  }
     
-    #[inline(always)] pure fn cast_i8()    -> i8    { self as i8    }
-    #[inline(always)] pure fn cast_i16()   -> i16   { self as i16   }
-    #[inline(always)] pure fn cast_i32()   -> i32   { self as i32   }
-    #[inline(always)] pure fn cast_i64()   -> i64   { self as i64   }
-    #[inline(always)] pure fn cast_int()   -> int   { self as int   }
+    #[inline(always)] pure fn to_i8()    -> i8    { self as i8    }
+    #[inline(always)] pure fn to_i16()   -> i16   { self as i16   }
+    #[inline(always)] pure fn to_i32()   -> i32   { self as i32   }
+    #[inline(always)] pure fn to_i64()   -> i64   { self as i64   }
+    #[inline(always)] pure fn to_int()   -> int   { self as int   }
     
-    #[inline(always)] pure fn cast_f32()   -> f32   { self as f32   }
-    #[inline(always)] pure fn cast_f64()   -> f64   { self as f64   }
-    #[inline(always)] pure fn cast_float() -> float { self as float }
+    #[inline(always)] pure fn to_f32()   -> f32   { self as f32   }
+    #[inline(always)] pure fn to_f64()   -> f64   { self as f64   }
+    #[inline(always)] pure fn to_float() -> float { self as float }
 }
 
 pub impl u64: NumCast {
-    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> u64 { n.cast_u64() }
+    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> u64 { n.to_u64() }
     #[inline(always)] pure fn cast<T:NumCast>() -> T { from(self) }
     
-    #[inline(always)] pure fn cast_u8()    -> u8    { self as u8    }
-    #[inline(always)] pure fn cast_u16()   -> u16   { self as u16   }
-    #[inline(always)] pure fn cast_u32()   -> u32   { self as u32   }
-    #[inline(always)] pure fn cast_u64()   -> u64   { self          }
-    #[inline(always)] pure fn cast_uint()  -> uint  { self as uint  }
+    #[inline(always)] pure fn to_u8()    -> u8    { self as u8    }
+    #[inline(always)] pure fn to_u16()   -> u16   { self as u16   }
+    #[inline(always)] pure fn to_u32()   -> u32   { self as u32   }
+    #[inline(always)] pure fn to_u64()   -> u64   { self          }
+    #[inline(always)] pure fn to_uint()  -> uint  { self as uint  }
     
-    #[inline(always)] pure fn cast_i8()    -> i8    { self as i8    }
-    #[inline(always)] pure fn cast_i16()   -> i16   { self as i16   }
-    #[inline(always)] pure fn cast_i32()   -> i32   { self as i32   }
-    #[inline(always)] pure fn cast_i64()   -> i64   { self as i64   }
-    #[inline(always)] pure fn cast_int()   -> int   { self as int   }
+    #[inline(always)] pure fn to_i8()    -> i8    { self as i8    }
+    #[inline(always)] pure fn to_i16()   -> i16   { self as i16   }
+    #[inline(always)] pure fn to_i32()   -> i32   { self as i32   }
+    #[inline(always)] pure fn to_i64()   -> i64   { self as i64   }
+    #[inline(always)] pure fn to_int()   -> int   { self as int   }
     
-    #[inline(always)] pure fn cast_f32()   -> f32   { self as f32   }
-    #[inline(always)] pure fn cast_f64()   -> f64   { self as f64   }
-    #[inline(always)] pure fn cast_float() -> float { self as float }
+    #[inline(always)] pure fn to_f32()   -> f32   { self as f32   }
+    #[inline(always)] pure fn to_f64()   -> f64   { self as f64   }
+    #[inline(always)] pure fn to_float() -> float { self as float }
 }
 
 pub impl uint: NumCast {
-    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> uint { n.cast_uint() }
+    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> uint { n.to_uint() }
     #[inline(always)] pure fn cast<T:NumCast>() -> T { from(self) }
     
-    #[inline(always)] pure fn cast_u8()    -> u8    { self as u8    }
-    #[inline(always)] pure fn cast_u16()   -> u16   { self as u16   }
-    #[inline(always)] pure fn cast_u32()   -> u32   { self as u32   }
-    #[inline(always)] pure fn cast_u64()   -> u64   { self as u64   }
-    #[inline(always)] pure fn cast_uint()  -> uint  { self          }
+    #[inline(always)] pure fn to_u8()    -> u8    { self as u8    }
+    #[inline(always)] pure fn to_u16()   -> u16   { self as u16   }
+    #[inline(always)] pure fn to_u32()   -> u32   { self as u32   }
+    #[inline(always)] pure fn to_u64()   -> u64   { self as u64   }
+    #[inline(always)] pure fn to_uint()  -> uint  { self          }
     
-    #[inline(always)] pure fn cast_i8()    -> i8    { self as i8    }
-    #[inline(always)] pure fn cast_i16()   -> i16   { self as i16   }
-    #[inline(always)] pure fn cast_i32()   -> i32   { self as i32   }
-    #[inline(always)] pure fn cast_i64()   -> i64   { self as i64   }
-    #[inline(always)] pure fn cast_int()   -> int   { self as int   }
+    #[inline(always)] pure fn to_i8()    -> i8    { self as i8    }
+    #[inline(always)] pure fn to_i16()   -> i16   { self as i16   }
+    #[inline(always)] pure fn to_i32()   -> i32   { self as i32   }
+    #[inline(always)] pure fn to_i64()   -> i64   { self as i64   }
+    #[inline(always)] pure fn to_int()   -> int   { self as int   }
     
-    #[inline(always)] pure fn cast_f32()   -> f32   { self as f32   }
-    #[inline(always)] pure fn cast_f64()   -> f64   { self as f64   }
-    #[inline(always)] pure fn cast_float() -> float { self as float }
+    #[inline(always)] pure fn to_f32()   -> f32   { self as f32   }
+    #[inline(always)] pure fn to_f64()   -> f64   { self as f64   }
+    #[inline(always)] pure fn to_float() -> float { self as float }
 }
 
 pub impl i8: NumCast {
-    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> i8 { n.cast_i8() }
+    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> i8 { n.to_i8() }
     #[inline(always)] pure fn cast<T:NumCast>() -> T { from(self) }
     
-    #[inline(always)] pure fn cast_u8()    -> u8    { self as u8    }
-    #[inline(always)] pure fn cast_u16()   -> u16   { self as u16   }
-    #[inline(always)] pure fn cast_u32()   -> u32   { self as u32   }
-    #[inline(always)] pure fn cast_u64()   -> u64   { self as u64   }
-    #[inline(always)] pure fn cast_uint()  -> uint  { self as uint  }
+    #[inline(always)] pure fn to_u8()    -> u8    { self as u8    }
+    #[inline(always)] pure fn to_u16()   -> u16   { self as u16   }
+    #[inline(always)] pure fn to_u32()   -> u32   { self as u32   }
+    #[inline(always)] pure fn to_u64()   -> u64   { self as u64   }
+    #[inline(always)] pure fn to_uint()  -> uint  { self as uint  }
     
-    #[inline(always)] pure fn cast_i8()    -> i8    { self          }
-    #[inline(always)] pure fn cast_i16()   -> i16   { self as i16   }
-    #[inline(always)] pure fn cast_i32()   -> i32   { self as i32   }
-    #[inline(always)] pure fn cast_i64()   -> i64   { self as i64   }
-    #[inline(always)] pure fn cast_int()   -> int   { self as int   }
+    #[inline(always)] pure fn to_i8()    -> i8    { self          }
+    #[inline(always)] pure fn to_i16()   -> i16   { self as i16   }
+    #[inline(always)] pure fn to_i32()   -> i32   { self as i32   }
+    #[inline(always)] pure fn to_i64()   -> i64   { self as i64   }
+    #[inline(always)] pure fn to_int()   -> int   { self as int   }
     
-    #[inline(always)] pure fn cast_f32()   -> f32   { self as f32   }
-    #[inline(always)] pure fn cast_f64()   -> f64   { self as f64   }
-    #[inline(always)] pure fn cast_float() -> float { self as float }
+    #[inline(always)] pure fn to_f32()   -> f32   { self as f32   }
+    #[inline(always)] pure fn to_f64()   -> f64   { self as f64   }
+    #[inline(always)] pure fn to_float() -> float { self as float }
 }
 
 pub impl i16: NumCast {
-    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> i16 { n.cast_i16() }
+    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> i16 { n.to_i16() }
     #[inline(always)] pure fn cast<T:NumCast>() -> T { from(self) }
     
-    #[inline(always)] pure fn cast_u8()    -> u8    { self as u8    }
-    #[inline(always)] pure fn cast_u16()   -> u16   { self as u16   }
-    #[inline(always)] pure fn cast_u32()   -> u32   { self as u32   }
-    #[inline(always)] pure fn cast_u64()   -> u64   { self as u64   }
-    #[inline(always)] pure fn cast_uint()  -> uint  { self as uint  }
+    #[inline(always)] pure fn to_u8()    -> u8    { self as u8    }
+    #[inline(always)] pure fn to_u16()   -> u16   { self as u16   }
+    #[inline(always)] pure fn to_u32()   -> u32   { self as u32   }
+    #[inline(always)] pure fn to_u64()   -> u64   { self as u64   }
+    #[inline(always)] pure fn to_uint()  -> uint  { self as uint  }
     
-    #[inline(always)] pure fn cast_i8()    -> i8    { self as i8    }
-    #[inline(always)] pure fn cast_i16()   -> i16   { self          }
-    #[inline(always)] pure fn cast_i32()   -> i32   { self as i32   }
-    #[inline(always)] pure fn cast_i64()   -> i64   { self as i64   }
-    #[inline(always)] pure fn cast_int()   -> int   { self as int   }
+    #[inline(always)] pure fn to_i8()    -> i8    { self as i8    }
+    #[inline(always)] pure fn to_i16()   -> i16   { self          }
+    #[inline(always)] pure fn to_i32()   -> i32   { self as i32   }
+    #[inline(always)] pure fn to_i64()   -> i64   { self as i64   }
+    #[inline(always)] pure fn to_int()   -> int   { self as int   }
     
-    #[inline(always)] pure fn cast_f32()   -> f32   { self as f32   }
-    #[inline(always)] pure fn cast_f64()   -> f64   { self as f64   }
-    #[inline(always)] pure fn cast_float() -> float { self as float }
+    #[inline(always)] pure fn to_f32()   -> f32   { self as f32   }
+    #[inline(always)] pure fn to_f64()   -> f64   { self as f64   }
+    #[inline(always)] pure fn to_float() -> float { self as float }
 }
 
 pub impl i32: NumCast {
-    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> i32 { n.cast_i32() }
+    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> i32 { n.to_i32() }
     #[inline(always)] pure fn cast<T:NumCast>() -> T { from(self) }
     
-    #[inline(always)] pure fn cast_u8()    -> u8    { self as u8    }
-    #[inline(always)] pure fn cast_u16()   -> u16   { self as u16   }
-    #[inline(always)] pure fn cast_u32()   -> u32   { self as u32   }
-    #[inline(always)] pure fn cast_u64()   -> u64   { self as u64   }
-    #[inline(always)] pure fn cast_uint()  -> uint  { self as uint  }
+    #[inline(always)] pure fn to_u8()    -> u8    { self as u8    }
+    #[inline(always)] pure fn to_u16()   -> u16   { self as u16   }
+    #[inline(always)] pure fn to_u32()   -> u32   { self as u32   }
+    #[inline(always)] pure fn to_u64()   -> u64   { self as u64   }
+    #[inline(always)] pure fn to_uint()  -> uint  { self as uint  }
     
-    #[inline(always)] pure fn cast_i8()    -> i8    { self as i8    }
-    #[inline(always)] pure fn cast_i16()   -> i16   { self as i16   }
-    #[inline(always)] pure fn cast_i32()   -> i32   { self          }
-    #[inline(always)] pure fn cast_i64()   -> i64   { self as i64   }
-    #[inline(always)] pure fn cast_int()   -> int   { self as int   }
+    #[inline(always)] pure fn to_i8()    -> i8    { self as i8    }
+    #[inline(always)] pure fn to_i16()   -> i16   { self as i16   }
+    #[inline(always)] pure fn to_i32()   -> i32   { self          }
+    #[inline(always)] pure fn to_i64()   -> i64   { self as i64   }
+    #[inline(always)] pure fn to_int()   -> int   { self as int   }
     
-    #[inline(always)] pure fn cast_f32()   -> f32   { self as f32   }
-    #[inline(always)] pure fn cast_f64()   -> f64   { self as f64   }
-    #[inline(always)] pure fn cast_float() -> float { self as float }
+    #[inline(always)] pure fn to_f32()   -> f32   { self as f32   }
+    #[inline(always)] pure fn to_f64()   -> f64   { self as f64   }
+    #[inline(always)] pure fn to_float() -> float { self as float }
 }
 
 pub impl i64: NumCast {
-    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> i64 { n.cast_i64() }
+    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> i64 { n.to_i64() }
     #[inline(always)] pure fn cast<T:NumCast>() -> T { from(self) }
     
-    #[inline(always)] pure fn cast_u8()    -> u8    { self as u8    }
-    #[inline(always)] pure fn cast_u16()   -> u16   { self as u16   }
-    #[inline(always)] pure fn cast_u32()   -> u32   { self as u32   }
-    #[inline(always)] pure fn cast_u64()   -> u64   { self as u64   }
-    #[inline(always)] pure fn cast_uint()  -> uint  { self as uint  }
+    #[inline(always)] pure fn to_u8()    -> u8    { self as u8    }
+    #[inline(always)] pure fn to_u16()   -> u16   { self as u16   }
+    #[inline(always)] pure fn to_u32()   -> u32   { self as u32   }
+    #[inline(always)] pure fn to_u64()   -> u64   { self as u64   }
+    #[inline(always)] pure fn to_uint()  -> uint  { self as uint  }
     
-    #[inline(always)] pure fn cast_i8()    -> i8    { self as i8    }
-    #[inline(always)] pure fn cast_i16()   -> i16   { self as i16   }
-    #[inline(always)] pure fn cast_i32()   -> i32   { self as i32   }
-    #[inline(always)] pure fn cast_i64()   -> i64   { self          }
-    #[inline(always)] pure fn cast_int()   -> int   { self as int   }
+    #[inline(always)] pure fn to_i8()    -> i8    { self as i8    }
+    #[inline(always)] pure fn to_i16()   -> i16   { self as i16   }
+    #[inline(always)] pure fn to_i32()   -> i32   { self as i32   }
+    #[inline(always)] pure fn to_i64()   -> i64   { self          }
+    #[inline(always)] pure fn to_int()   -> int   { self as int   }
     
-    #[inline(always)] pure fn cast_f32()   -> f32   { self as f32   }
-    #[inline(always)] pure fn cast_f64()   -> f64   { self as f64   }
-    #[inline(always)] pure fn cast_float() -> float { self as float }
+    #[inline(always)] pure fn to_f32()   -> f32   { self as f32   }
+    #[inline(always)] pure fn to_f64()   -> f64   { self as f64   }
+    #[inline(always)] pure fn to_float() -> float { self as float }
 }
 
 pub impl int: NumCast {
-    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> int { n.cast_int() }
+    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> int { n.to_int() }
     #[inline(always)] pure fn cast<T:NumCast>() -> T { from(self) }
     
-    #[inline(always)] pure fn cast_u8()    -> u8    { self as u8    }
-    #[inline(always)] pure fn cast_u16()   -> u16   { self as u16   }
-    #[inline(always)] pure fn cast_u32()   -> u32   { self as u32   }
-    #[inline(always)] pure fn cast_u64()   -> u64   { self as u64   }
-    #[inline(always)] pure fn cast_uint()  -> uint  { self as uint  }
+    #[inline(always)] pure fn to_u8()    -> u8    { self as u8    }
+    #[inline(always)] pure fn to_u16()   -> u16   { self as u16   }
+    #[inline(always)] pure fn to_u32()   -> u32   { self as u32   }
+    #[inline(always)] pure fn to_u64()   -> u64   { self as u64   }
+    #[inline(always)] pure fn to_uint()  -> uint  { self as uint  }
     
-    #[inline(always)] pure fn cast_i8()    -> i8    { self as i8    }
-    #[inline(always)] pure fn cast_i16()   -> i16   { self as i16   }
-    #[inline(always)] pure fn cast_i32()   -> i32   { self as i32   }
-    #[inline(always)] pure fn cast_i64()   -> i64   { self as i64   }
-    #[inline(always)] pure fn cast_int()   -> int   { self          }
+    #[inline(always)] pure fn to_i8()    -> i8    { self as i8    }
+    #[inline(always)] pure fn to_i16()   -> i16   { self as i16   }
+    #[inline(always)] pure fn to_i32()   -> i32   { self as i32   }
+    #[inline(always)] pure fn to_i64()   -> i64   { self as i64   }
+    #[inline(always)] pure fn to_int()   -> int   { self          }
     
-    #[inline(always)] pure fn cast_f32()   -> f32   { self as f32   }
-    #[inline(always)] pure fn cast_f64()   -> f64   { self as f64   }
-    #[inline(always)] pure fn cast_float() -> float { self as float }
+    #[inline(always)] pure fn to_f32()   -> f32   { self as f32   }
+    #[inline(always)] pure fn to_f64()   -> f64   { self as f64   }
+    #[inline(always)] pure fn to_float() -> float { self as float }
 }
 
 pub impl f32: NumCast {
-    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> f32 { n.cast_f32() }
+    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> f32 { n.to_f32() }
     #[inline(always)] pure fn cast<T:NumCast>() -> T { from(self) }
     
-    #[inline(always)] pure fn cast_u8()    -> u8    { self as u8    }
-    #[inline(always)] pure fn cast_u16()   -> u16   { self as u16   }
-    #[inline(always)] pure fn cast_u32()   -> u32   { self as u32   }
-    #[inline(always)] pure fn cast_u64()   -> u64   { self as u64   }
-    #[inline(always)] pure fn cast_uint()  -> uint  { self as uint  }
+    #[inline(always)] pure fn to_u8()    -> u8    { self as u8    }
+    #[inline(always)] pure fn to_u16()   -> u16   { self as u16   }
+    #[inline(always)] pure fn to_u32()   -> u32   { self as u32   }
+    #[inline(always)] pure fn to_u64()   -> u64   { self as u64   }
+    #[inline(always)] pure fn to_uint()  -> uint  { self as uint  }
     
-    #[inline(always)] pure fn cast_i8()    -> i8    { self as i8    }
-    #[inline(always)] pure fn cast_i16()   -> i16   { self as i16   }
-    #[inline(always)] pure fn cast_i32()   -> i32   { self as i32   }
-    #[inline(always)] pure fn cast_i64()   -> i64   { self as i64   }
-    #[inline(always)] pure fn cast_int()   -> int   { self as int   }
+    #[inline(always)] pure fn to_i8()    -> i8    { self as i8    }
+    #[inline(always)] pure fn to_i16()   -> i16   { self as i16   }
+    #[inline(always)] pure fn to_i32()   -> i32   { self as i32   }
+    #[inline(always)] pure fn to_i64()   -> i64   { self as i64   }
+    #[inline(always)] pure fn to_int()   -> int   { self as int   }
     
-    #[inline(always)] pure fn cast_f32()   -> f32   { self          }
-    #[inline(always)] pure fn cast_f64()   -> f64   { self as f64   }
-    #[inline(always)] pure fn cast_float() -> float { self as float }
+    #[inline(always)] pure fn to_f32()   -> f32   { self          }
+    #[inline(always)] pure fn to_f64()   -> f64   { self as f64   }
+    #[inline(always)] pure fn to_float() -> float { self as float }
 }
 
 pub impl f64: NumCast {
-    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> f64 { n.cast_f64() }
+    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> f64 { n.to_f64() }
     #[inline(always)] pure fn cast<T:NumCast>() -> T { from(self) }
     
-    #[inline(always)] pure fn cast_u8()    -> u8    { self as u8    }
-    #[inline(always)] pure fn cast_u16()   -> u16   { self as u16   }
-    #[inline(always)] pure fn cast_u32()   -> u32   { self as u32   }
-    #[inline(always)] pure fn cast_u64()   -> u64   { self as u64   }
-    #[inline(always)] pure fn cast_uint()  -> uint  { self as uint  }
+    #[inline(always)] pure fn to_u8()    -> u8    { self as u8    }
+    #[inline(always)] pure fn to_u16()   -> u16   { self as u16   }
+    #[inline(always)] pure fn to_u32()   -> u32   { self as u32   }
+    #[inline(always)] pure fn to_u64()   -> u64   { self as u64   }
+    #[inline(always)] pure fn to_uint()  -> uint  { self as uint  }
     
-    #[inline(always)] pure fn cast_i8()    -> i8    { self as i8    }
-    #[inline(always)] pure fn cast_i16()   -> i16   { self as i16   }
-    #[inline(always)] pure fn cast_i32()   -> i32   { self as i32   }
-    #[inline(always)] pure fn cast_i64()   -> i64   { self as i64   }
-    #[inline(always)] pure fn cast_int()   -> int   { self as int   }
+    #[inline(always)] pure fn to_i8()    -> i8    { self as i8    }
+    #[inline(always)] pure fn to_i16()   -> i16   { self as i16   }
+    #[inline(always)] pure fn to_i32()   -> i32   { self as i32   }
+    #[inline(always)] pure fn to_i64()   -> i64   { self as i64   }
+    #[inline(always)] pure fn to_int()   -> int   { self as int   }
     
-    #[inline(always)] pure fn cast_f32()   -> f32   { self as f32   }
-    #[inline(always)] pure fn cast_f64()   -> f64   { self          }
-    #[inline(always)] pure fn cast_float() -> float { self as float }
+    #[inline(always)] pure fn to_f32()   -> f32   { self as f32   }
+    #[inline(always)] pure fn to_f64()   -> f64   { self          }
+    #[inline(always)] pure fn to_float() -> float { self as float }
 }
 
 pub impl float: NumCast {
-    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> float { n.cast_float() }
+    #[inline(always)] static pure fn from<T:NumCast>(n: T) -> float { n.to_float() }
     #[inline(always)] pure fn cast<T:NumCast>() -> T { from(self) }
     
-    #[inline(always)] pure fn cast_u8()    -> u8    { self as u8    }
-    #[inline(always)] pure fn cast_u16()   -> u16   { self as u16   }
-    #[inline(always)] pure fn cast_u32()   -> u32   { self as u32   }
-    #[inline(always)] pure fn cast_u64()   -> u64   { self as u64   }
-    #[inline(always)] pure fn cast_uint()  -> uint  { self as uint  }
+    #[inline(always)] pure fn to_u8()    -> u8    { self as u8    }
+    #[inline(always)] pure fn to_u16()   -> u16   { self as u16   }
+    #[inline(always)] pure fn to_u32()   -> u32   { self as u32   }
+    #[inline(always)] pure fn to_u64()   -> u64   { self as u64   }
+    #[inline(always)] pure fn to_uint()  -> uint  { self as uint  }
     
-    #[inline(always)] pure fn cast_i8()    -> i8    { self as i8    }
-    #[inline(always)] pure fn cast_i16()   -> i16   { self as i16   }
-    #[inline(always)] pure fn cast_i32()   -> i32   { self as i32   }
-    #[inline(always)] pure fn cast_i64()   -> i64   { self as i64   }
-    #[inline(always)] pure fn cast_int()   -> int   { self as int   }
+    #[inline(always)] pure fn to_i8()    -> i8    { self as i8    }
+    #[inline(always)] pure fn to_i16()   -> i16   { self as i16   }
+    #[inline(always)] pure fn to_i32()   -> i32   { self as i32   }
+    #[inline(always)] pure fn to_i64()   -> i64   { self as i64   }
+    #[inline(always)] pure fn to_int()   -> int   { self as int   }
     
-    #[inline(always)] pure fn cast_f32()   -> f32   { self as f32   }
-    #[inline(always)] pure fn cast_f64()   -> f64   { self as f64   }
-    #[inline(always)] pure fn cast_float() -> float { self          }
+    #[inline(always)] pure fn to_f32()   -> f32   { self as f32   }
+    #[inline(always)] pure fn to_f64()   -> f64   { self as f64   }
+    #[inline(always)] pure fn to_float() -> float { self          }
 }
\ No newline at end of file