core: Mark some functions as pure

src/libcore/dvec.rs

@@ -67,17 +67,17 @@ pub pure fn DVec<A>() -> DVec<A> {
 }
 
 /// Creates a new dvec with a single element
-pub fn from_elem<A>(e: A) -> DVec<A> {
+pub pure fn from_elem<A>(e: A) -> DVec<A> {
     DVec {mut data: ~[move e]}
 }
 
 /// Creates a new dvec with the contents of a vector
-pub fn from_vec<A>(v: ~[A]) -> DVec<A> {
+pub pure fn from_vec<A>(v: ~[A]) -> DVec<A> {
     DVec {mut data: move v}
 }
 
 /// Consumes the vector and returns its contents
-pub fn unwrap<A>(d: DVec<A>) -> ~[A] {
+pub pure fn unwrap<A>(d: DVec<A>) -> ~[A] {
     let DVec {data: v} = move d;
     move v
 }

src/libcore/float.rs

@@ -188,7 +188,7 @@ pub pure fn to_str_common(num: float, digits: uint, exact: bool) -> ~str {
  * * num - The float value
  * * digits - The number of significant digits
  */
-pub fn to_str_exact(num: float, digits: uint) -> ~str {
+pub pure fn to_str_exact(num: float, digits: uint) -> ~str {
     to_str_common(num, digits, true)
 }
 
@@ -238,7 +238,7 @@ pub pure fn to_str(num: float, digits: uint) -> ~str {
  * `none` if the string did not represent a valid number.  Otherwise,
  * `Some(n)` where `n` is the floating-point number represented by `[num]`.
  */
-pub fn from_str(num: &str) -> Option<float> {
+pub pure fn from_str(num: &str) -> Option<float> {
    if num == "inf" {
        return Some(infinity as float);
    } else if num == "-inf" {

src/libcore/int-template/int.rs

@@ -17,12 +17,12 @@ mod inst {
     pub const bits: uint = uint::bits;
 
     /// Returns `base` raised to the power of `exponent`
-    pub fn pow(base: int, exponent: uint) -> int {
+    pub pure fn pow(base: int, exponent: uint) -> int {
         if exponent == 0u {
             //Not mathemtically true if ~[base == 0]
             return 1;
         }
-        if base     == 0  { return 0; }
+        if base == 0 { return 0; }
         let mut my_pow  = exponent;
         let mut acc     = 1;
         let mut multiplier = base;

src/libcore/ptr.rs

@@ -170,13 +170,13 @@ pub pure fn to_mut_unsafe_ptr<T>(thing: &mut T) -> *mut T {
   (I couldn't think of a cutesy name for this one.)
 */
 #[inline(always)]
-pub fn to_uint<T>(thing: &T) -> uint unsafe {
+pub pure fn to_uint<T>(thing: &T) -> uint unsafe {
     cast::reinterpret_cast(&thing)
 }
 
 /// Determine if two borrowed pointers point to the same thing.
 #[inline(always)]
-pub fn ref_eq<T>(thing: &a/T, other: &b/T) -> bool {
+pub pure fn ref_eq<T>(thing: &a/T, other: &b/T) -> bool {
     to_uint(thing) == to_uint(other)
 }
 

src/libcore/rand.rs

@@ -309,12 +309,12 @@ impl XorShiftState: Rng {
     }
 }
 
-pub fn xorshift() -> Rng {
+pub pure fn xorshift() -> Rng {
     // constants taken from http://en.wikipedia.org/wiki/Xorshift
     seeded_xorshift(123456789u32, 362436069u32, 521288629u32, 88675123u32)
 }
 
-pub fn seeded_xorshift(x: u32, y: u32, z: u32, w: u32) -> Rng {
+pub pure fn seeded_xorshift(x: u32, y: u32, z: u32, w: u32) -> Rng {
     {mut x: x, mut y: y, mut z: z, mut w: w} as Rng
 }
 

src/libcore/str.rs

@@ -214,7 +214,7 @@ pub pure fn connect(v: &[~str], sep: &str) -> ~str {
 }
 
 /// Given a string, make a new string with repeated copies of it
-pub fn repeat(ss: &str, nn: uint) -> ~str {
+pub pure fn repeat(ss: &str, nn: uint) -> ~str {
     let mut acc = ~"";
     for nn.times { acc += ss; }
     acc
@@ -1684,9 +1684,7 @@ pub struct CharRange {
  *
  * This function can be used to iterate over a unicode string in reverse.
  */
-pure fn char_range_at_reverse(ss: &str, start: uint)
+pure fn char_range_at_reverse(ss: &str, start: uint) -> CharRange {
-    -> CharRange {
-
     let mut prev = start;
 
     // while there is a previous byte == 10......

src/libcore/uint-template/uint.rs

@@ -104,7 +104,7 @@ mod inst {
 
     /// Returns the smallest power of 2 greater than or equal to `n`
     #[inline(always)]
-    pub fn next_power_of_two(n: uint) -> uint {
+    pub pure fn next_power_of_two(n: uint) -> uint {
         let halfbits: uint = sys::size_of::<uint>() * 4u;
         let mut tmp: uint = n - 1u;
         let mut shift: uint = 1u;