Use struct+impl syntax instead of the (deprecated) struct with embedded methods syntax. Also standardise the comment indentation and add some whitespace between items.

src/libstd/bitv.rs

@@ -2,47 +2,57 @@ use vec::{to_mut, from_elem};
 
 export Bitv, from_bytes, from_bools, from_fn;
 
+struct SmallBitv {
+    /// only the lowest nbits of this value are used. the rest is undefined.
+    mut bits: u32
+}
+
+fn SmallBitv(bits: u32) -> SmallBitv {
+    SmallBitv {bits: bits}
+}
+
 /// a mask that has a 1 for each defined bit in a small_bitv, assuming n bits
 #[inline(always)]
 fn small_mask(nbits: uint) -> u32 {
     (1 << nbits) - 1
 }
 
-struct SmallBitv {
+impl SmallBitv {
-    /// only the lowest nbits of this value are used. the rest is undefined.
+
-    let mut bits: u32;
-    new(bits: u32) { self.bits = bits; }
-    priv {
     #[inline(always)]
-        fn bits_op(right_bits: u32, nbits: uint, f: fn(u32, u32) -> u32)
+    fn bits_op(right_bits: u32, nbits: uint, f: fn(u32, u32) -> u32) -> bool {
-                                                                     -> bool {
         let mask = small_mask(nbits);
         let old_b: u32 = self.bits;
         let new_b = f(old_b, right_bits);
         self.bits = new_b;
         mask & old_b != mask & new_b
     }
-    }
+
     #[inline(always)]
     fn union(s: &SmallBitv, nbits: uint) -> bool {
         self.bits_op(s.bits, nbits, |u1, u2| u1 | u2)
     }
+
     #[inline(always)]
     fn intersect(s: &SmallBitv, nbits: uint) -> bool {
         self.bits_op(s.bits, nbits, |u1, u2| u1 & u2)
     }
+
     #[inline(always)]
     fn become(s: &SmallBitv, nbits: uint) -> bool {
         self.bits_op(s.bits, nbits, |_u1, u2| u2)
     }
+
     #[inline(always)]
     fn difference(s: &SmallBitv, nbits: uint) -> bool {
         self.bits_op(s.bits, nbits, |u1, u2| u1 ^ u2)
     }
+
     #[inline(always)]
     pure fn get(i: uint) -> bool {
         (self.bits & (1 << i)) != 0
     }
+
     #[inline(always)]
     fn set(i: uint, x: bool) {
         if x {
@@ -52,25 +62,41 @@ struct SmallBitv {
             self.bits &= !(1<<i as u32);
         }
     }
+
     #[inline(always)]
     fn equals(b: &SmallBitv, nbits: uint) -> bool {
         let mask = small_mask(nbits);
         mask & self.bits == mask & b.bits
     }
+
     #[inline(always)]
     fn clear() { self.bits = 0; }
+
     #[inline(always)]
     fn set_all() { self.bits = !0; }
+
     #[inline(always)]
     fn is_true(nbits: uint) -> bool {
         small_mask(nbits) & !self.bits == 0
     }
+
     #[inline(always)]
     fn is_false(nbits: uint) -> bool {
         small_mask(nbits) & self.bits == 0
     }
+
     #[inline(always)]
     fn invert() { self.bits = !self.bits; }
+
+}
+
+struct BigBitv {
+    // only mut b/c of clone and lack of other constructor
+    mut storage: ~[mut uint]
+}
+
+fn BigBitv(-storage: ~[mut uint]) -> BigBitv {
+    BigBitv {storage: storage}
 }
 
 /**
@@ -89,16 +115,10 @@ fn big_mask(nbits: uint, elem: uint) -> uint {
     }
 }
 
-struct BigBitv {
+impl BigBitv {
-    // only mut b/c of clone and lack of other constructor
+
-    let mut storage: ~[mut uint];
-    new(-storage: ~[mut uint]) {
-        self.storage <- storage;
-    }
-    priv {
     #[inline(always)]
-        fn process(b: &BigBitv, nbits: uint, op: fn(uint, uint) -> uint)
+    fn process(b: &BigBitv, nbits: uint, op: fn(uint, uint) -> uint) -> bool {
-                                                                     -> bool {
         let len = b.storage.len();
         assert (self.storage.len() == len);
         let mut changed = false;
@@ -115,7 +135,7 @@ struct BigBitv {
         }
         changed
     }
-    }
+
     #[inline(always)]
      fn each_storage(op: fn(&uint) -> bool) {
         for uint::range(0, self.storage.len()) |i| {
@@ -125,20 +145,25 @@ struct BigBitv {
             if !b { break; }
         }
      }
+
     #[inline(always)]
     fn invert() { for self.each_storage() |w| { w = !w } }
+
     #[inline(always)]
     fn union(b: &BigBitv, nbits: uint) -> bool {
         self.process(b, nbits, lor)
     }
+
     #[inline(always)]
     fn intersect(b: &BigBitv, nbits: uint) -> bool {
         self.process(b, nbits, land)
     }
+
     #[inline(always)]
     fn become(b: &BigBitv, nbits: uint) -> bool {
         self.process(b, nbits, right)
     }
+
     #[inline(always)]
     fn difference(b: &BigBitv, nbits: uint) -> bool {
         self.invert();
@@ -146,6 +171,7 @@ struct BigBitv {
         self.invert();
         b
     }
+
     #[inline(always)]
     pure fn get(i: uint) -> bool {
         let w = i / uint_bits;
@@ -153,6 +179,7 @@ struct BigBitv {
         let x = 1 & self.storage[w] >> b;
         x == 1
     }
+
     #[inline(always)]
     fn set(i: uint, x: bool) {
         let w = i / uint_bits;
@@ -161,6 +188,7 @@ struct BigBitv {
         self.storage[w] = if x { self.storage[w] | flag }
                  else { self.storage[w] & !flag };
     }
+
     #[inline(always)]
     fn equals(b: &BigBitv, nbits: uint) -> bool {
         let len = b.storage.len();
@@ -171,6 +199,7 @@ struct BigBitv {
             }
         }
     }
+
 }
 
 enum BitvVariant { Big(~BigBitv), Small(~SmallBitv) }
@@ -179,28 +208,30 @@ enum Op {Union, Intersect, Assign, Difference}
 
 // The bitvector type
 struct Bitv {
-    let rep: BitvVariant;
+    rep: BitvVariant,
-    let nbits: uint;
+    nbits: uint
+}
 
-    new(nbits: uint, init: bool) {
+fn Bitv (nbits: uint, init: bool) -> Bitv {
-        self.nbits = nbits;
+    let rep = if nbits <= 32 {
-        if nbits <= 32 {
+        Small(~SmallBitv(if init {!0} else {0}))
-          self.rep = Small(~SmallBitv(if init {!0} else {0}));
     }
     else {
         let nelems = nbits/uint_bits +
                      if nbits % uint_bits == 0 {0} else {1};
         let elem = if init {!0} else {0};
         let s = to_mut(from_elem(nelems, elem));
-          self.rep = Big(~BigBitv(s));
+        Big(~BigBitv(s))
     };
+    Bitv {rep: rep, nbits: nbits}
+}
+
+priv impl Bitv {
+
+    fn die() -> ! {
+        fail ~"Tried to do operation on bit vectors with different sizes";
     }
 
-    priv {
-        fn die() -> ! {
-            fail ~"Tried to do operation on bit vectors with \
-                  different sizes";
-        }
     #[inline(always)]
     fn do_op(op: Op, other: &Bitv) -> bool {
         if self.nbits != other.nbits {
@@ -227,27 +258,30 @@ struct Bitv {
           }
         }
     }
-    }
 
-/**
+}
+
+impl Bitv {
+
+    /**
      * Calculates the union of two bitvectors
      *
      * Sets `self` to the union of `self` and `v1`. Both bitvectors must be
      * the same length. Returns 'true' if `self` changed.
-*/
+    */
     #[inline(always)]
     fn union(v1: &Bitv) -> bool { self.do_op(Union, v1) }
 
-/**
+    /**
      * Calculates the intersection of two bitvectors
      *
- * Sets `self` to the intersection of `self` and `v1`. Both bitvectors must be
+     * Sets `self` to the intersection of `self` and `v1`. Both bitvectors
- * the same length. Returns 'true' if `self` changed.
+     * must be the same length. Returns 'true' if `self` changed.
-*/
+    */
     #[inline(always)]
     fn intersect(v1: &Bitv) -> bool { self.do_op(Intersect, v1) }
 
-/**
+    /**
      * Assigns the value of `v1` to `self`
      *
      * Both bitvectors must be the same length. Returns `true` if `self` was
@@ -282,7 +316,7 @@ struct Bitv {
        }
     }
 
-/**
+    /**
      * Set the value of a bit at a given index
      *
      * `i` must be less than the length of the bitvector.
@@ -296,11 +330,11 @@ struct Bitv {
       }
     }
 
-/**
+    /**
      * Compares two bitvectors
      *
- * Both bitvectors must be the same length. Returns `true` if both bitvectors
+     * Both bitvectors must be the same length. Returns `true` if both
- * contain identical elements.
+     * bitvectors contain identical elements.
      */
     #[inline(always)]
     fn equal(v1: Bitv) -> bool {
@@ -342,11 +376,12 @@ struct Bitv {
         Big(s) => for s.each_storage() |w| { w = !w } }
     }
 
-/**
+    /**
      * Calculate the difference between two bitvectors
      *
- * Sets each element of `v0` to the value of that element minus the element
+     * Sets each element of `v0` to the value of that element minus the
- * of `v1` at the same index. Both bitvectors must be the same length.
+     * element of `v1` at the same index. Both bitvectors must be the same
+     * length.
      *
      * Returns `true` if `v0` was changed.
      */
@@ -375,7 +410,6 @@ struct Bitv {
     }
 
     /// Returns true if all bits are 0
-
     fn is_false() -> bool {
       match self.rep {
         Small(b) => b.is_false(self.nbits),
@@ -390,7 +424,7 @@ struct Bitv {
       return if self.get(i) { 1 } else { 0 };
     }
 
-/**
+    /**
      * Converts `self` to a vector of uint with the same length.
      *
      * Each uint in the resulting vector has either value 0u or 1u.
@@ -437,7 +471,7 @@ struct Bitv {
         vec::from_fn(self.nbits, |i| self[i])
     }
 
-/**
+    /**
      * Converts `self` to a string.
      *
      * The resulting string has the same length as `self`, and each
@@ -450,11 +484,11 @@ struct Bitv {
      }
 
 
-/**
+    /**
      * Compare a bitvector to a vector of uint
      *
- * The uint vector is expected to only contain the values 0u and 1u. Both the
+     * The uint vector is expected to only contain the values 0u and 1u. Both
- * bitvector and vector must have the same length
+     * the bitvector and vector must have the same length
      */
     fn eq_vec(v: ~[uint]) -> bool {
         assert self.nbits == v.len();
@@ -476,7 +510,7 @@ struct Bitv {
         }
     }
 
-} // end of bitv class
+}
 
 /**
  * Transform a byte-vector into a bitv. Each byte becomes 8 bits,