diff --git a/src/libcollections/bench.rs b/src/libcollections/bench.rs
index c5c19ee56bf..b0a5911720a 100644
--- a/src/libcollections/bench.rs
+++ b/src/libcollections/bench.rs
@@ -13,40 +13,40 @@ use std::rand;
 use std::rand::Rng;
 use test::{Bencher, black_box};
 
-pub fn insert_rand_n<M, I, R>(n: uint,
+pub fn insert_rand_n<M, I, R>(n: usize,
                               map: &mut M,
                               b: &mut Bencher,
                               mut insert: I,
                               mut remove: R) where
-    I: FnMut(&mut M, uint),
-    R: FnMut(&mut M, uint),
+    I: FnMut(&mut M, usize),
+    R: FnMut(&mut M, usize),
 {
     // setup
     let mut rng = rand::weak_rng();
 
     for _ in 0..n {
-        insert(map, rng.gen::<uint>() % n);
+        insert(map, rng.gen::<usize>() % n);
     }
 
     // measure
     b.iter(|| {
-        let k = rng.gen::<uint>() % n;
+        let k = rng.gen::<usize>() % n;
         insert(map, k);
         remove(map, k);
     });
     black_box(map);
 }
 
-pub fn insert_seq_n<M, I, R>(n: uint,
+pub fn insert_seq_n<M, I, R>(n: usize,
                              map: &mut M,
                              b: &mut Bencher,
                              mut insert: I,
                              mut remove: R) where
-    I: FnMut(&mut M, uint),
-    R: FnMut(&mut M, uint),
+    I: FnMut(&mut M, usize),
+    R: FnMut(&mut M, usize),
 {
     // setup
-    for i in 0u..n {
+    for i in 0..n {
         insert(map, i * 2);
     }
 
@@ -60,18 +60,17 @@ pub fn insert_seq_n<M, I, R>(n: uint,
     black_box(map);
 }
 
-pub fn find_rand_n<M, T, I, F>(n: uint,
+pub fn find_rand_n<M, T, I, F>(n: usize,
                                map: &mut M,
                                b: &mut Bencher,
                                mut insert: I,
                                mut find: F) where
-    I: FnMut(&mut M, uint),
-    F: FnMut(&M, uint) -> T,
+    I: FnMut(&mut M, usize),
+    F: FnMut(&M, usize) -> T,
 {
     // setup
     let mut rng = rand::weak_rng();
-    let mut keys = (0..n).map(|_| rng.gen::<uint>() % n)
-                              .collect::<Vec<_>>();
+    let mut keys: Vec<_> = (0..n).map(|_| rng.gen::<usize>() % n).collect();
 
     for k in &keys {
         insert(map, *k);
@@ -88,16 +87,16 @@ pub fn find_rand_n<M, T, I, F>(n: uint,
     })
 }
 
-pub fn find_seq_n<M, T, I, F>(n: uint,
+pub fn find_seq_n<M, T, I, F>(n: usize,
                               map: &mut M,
                               b: &mut Bencher,
                               mut insert: I,
                               mut find: F) where
-    I: FnMut(&mut M, uint),
-    F: FnMut(&M, uint) -> T,
+    I: FnMut(&mut M, usize),
+    F: FnMut(&M, usize) -> T,
 {
     // setup
-    for i in 0u..n {
+    for i in 0..n {
         insert(map, i);
     }
 
diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs
index b51ec13335e..3bc5b0ca053 100644
--- a/src/libcollections/binary_heap.rs
+++ b/src/libcollections/binary_heap.rs
@@ -28,12 +28,12 @@
 //! ```
 //! use std::cmp::Ordering;
 //! use std::collections::BinaryHeap;
-//! use std::uint;
+//! use std::usize;
 //!
 //! #[derive(Copy, Eq, PartialEq)]
 //! struct State {
-//!     cost: uint,
-//!     position: uint,
+//!     cost: usize,
+//!     position: usize,
 //! }
 //!
 //! // The priority queue depends on `Ord`.
@@ -53,21 +53,21 @@
 //!     }
 //! }
 //!
-//! // Each node is represented as an `uint`, for a shorter implementation.
+//! // Each node is represented as an `usize`, for a shorter implementation.
 //! struct Edge {
-//!     node: uint,
-//!     cost: uint,
+//!     node: usize,
+//!     cost: usize,
 //! }
 //!
 //! // Dijkstra's shortest path algorithm.
 //!
 //! // Start at `start` and use `dist` to track the current shortest distance
 //! // to each node. This implementation isn't memory-efficient as it may leave duplicate
-//! // nodes in the queue. It also uses `uint::MAX` as a sentinel value,
+//! // nodes in the queue. It also uses `usize::MAX` as a sentinel value,
 //! // for a simpler implementation.
-//! fn shortest_path(adj_list: &Vec<Vec<Edge>>, start: uint, goal: uint) -> uint {
+//! fn shortest_path(adj_list: &Vec<Vec<Edge>>, start: usize, goal: usize) -> usize {
 //!     // dist[node] = current shortest distance from `start` to `node`
-//!     let mut dist: Vec<_> = (0..adj_list.len()).map(|_| uint::MAX).collect();
+//!     let mut dist: Vec<_> = (0..adj_list.len()).map(|_| usize::MAX).collect();
 //!
 //!     let mut heap = BinaryHeap::new();
 //!
@@ -98,7 +98,7 @@
 //!     }
 //!
 //!     // Goal not reachable
-//!     uint::MAX
+//!     usize::MAX
 //! }
 //!
 //! fn main() {
@@ -143,7 +143,7 @@
 //!     assert_eq!(shortest_path(&graph, 0, 3), 3);
 //!     assert_eq!(shortest_path(&graph, 3, 0), 7);
 //!     assert_eq!(shortest_path(&graph, 0, 4), 5);
-//!     assert_eq!(shortest_path(&graph, 4, 0), uint::MAX);
+//!     assert_eq!(shortest_path(&graph, 4, 0), usize::MAX);
 //! }
 //! ```
 
@@ -201,7 +201,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// heap.push(4u);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_capacity(capacity: uint) -> BinaryHeap<T> {
+    pub fn with_capacity(capacity: usize) -> BinaryHeap<T> {
         BinaryHeap { data: Vec::with_capacity(capacity) }
     }
 
@@ -295,7 +295,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// heap.push(4u);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn capacity(&self) -> uint { self.data.capacity() }
+    pub fn capacity(&self) -> usize { self.data.capacity() }
 
     /// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the
     /// given `BinaryHeap`. Does nothing if the capacity is already sufficient.
@@ -306,7 +306,7 @@ impl<T: Ord> BinaryHeap<T> {
     ///
     /// # Panics
     ///
-    /// Panics if the new capacity overflows `uint`.
+    /// Panics if the new capacity overflows `usize`.
     ///
     /// # Examples
     ///
@@ -318,7 +318,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// heap.push(4u);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_exact(&mut self, additional: uint) {
+    pub fn reserve_exact(&mut self, additional: usize) {
         self.data.reserve_exact(additional);
     }
 
@@ -327,7 +327,7 @@ impl<T: Ord> BinaryHeap<T> {
     ///
     /// # Panics
     ///
-    /// Panics if the new capacity overflows `uint`.
+    /// Panics if the new capacity overflows `usize`.
     ///
     /// # Examples
     ///
@@ -339,7 +339,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// heap.push(4u);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve(&mut self, additional: uint) {
+    pub fn reserve(&mut self, additional: usize) {
         self.data.reserve(additional);
     }
 
@@ -497,7 +497,7 @@ impl<T: Ord> BinaryHeap<T> {
     // zeroed element), shift along the others and move it back into the
     // vector over the junk element. This reduces the constant factor
     // compared to using swaps, which involves twice as many moves.
-    fn sift_up(&mut self, start: uint, mut pos: uint) {
+    fn sift_up(&mut self, start: usize, mut pos: usize) {
         unsafe {
             let new = replace(&mut self.data[pos], zeroed());
 
@@ -514,7 +514,7 @@ impl<T: Ord> BinaryHeap<T> {
         }
     }
 
-    fn sift_down_range(&mut self, mut pos: uint, end: uint) {
+    fn sift_down_range(&mut self, mut pos: usize, end: usize) {
         unsafe {
             let start = pos;
             let new = replace(&mut self.data[pos], zeroed());
@@ -536,14 +536,14 @@ impl<T: Ord> BinaryHeap<T> {
         }
     }
 
-    fn sift_down(&mut self, pos: uint) {
+    fn sift_down(&mut self, pos: usize) {
         let len = self.len();
         self.sift_down_range(pos, len);
     }
 
     /// Returns the length of the binary heap.
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> uint { self.data.len() }
+    pub fn len(&self) -> usize { self.data.len() }
 
     /// Checks if the binary heap is empty.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -584,7 +584,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
     fn next(&mut self) -> Option<&'a T> { self.iter.next() }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -610,7 +610,7 @@ impl<T> Iterator for IntoIter<T> {
     fn next(&mut self) -> Option<T> { self.iter.next() }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -636,7 +636,7 @@ impl<'a, T: 'a> Iterator for Drain<'a, T> {
     fn next(&mut self) -> Option<T> { self.iter.next() }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -692,7 +692,7 @@ mod tests {
 
     #[test]
     fn test_iterator() {
-        let data = vec!(5, 9, 3);
+        let data = vec![5, 9, 3];
         let iterout = [9, 5, 3];
         let heap = BinaryHeap::from_vec(data);
         let mut i = 0;
@@ -704,27 +704,27 @@ mod tests {
 
     #[test]
     fn test_iterator_reverse() {
-        let data = vec!(5, 9, 3);
-        let iterout = vec!(3, 5, 9);
+        let data = vec![5, 9, 3];
+        let iterout = vec![3, 5, 9];
         let pq = BinaryHeap::from_vec(data);
 
-        let v: Vec<int> = pq.iter().rev().map(|&x| x).collect();
+        let v: Vec<_> = pq.iter().rev().cloned().collect();
         assert_eq!(v, iterout);
     }
 
     #[test]
     fn test_move_iter() {
-        let data = vec!(5, 9, 3);
-        let iterout = vec!(9, 5, 3);
+        let data = vec![5, 9, 3];
+        let iterout = vec![9, 5, 3];
         let pq = BinaryHeap::from_vec(data);
 
-        let v: Vec<int> = pq.into_iter().collect();
+        let v: Vec<_> = pq.into_iter().collect();
         assert_eq!(v, iterout);
     }
 
     #[test]
     fn test_move_iter_size_hint() {
-        let data = vec!(5, 9);
+        let data = vec![5, 9];
         let pq = BinaryHeap::from_vec(data);
 
         let mut it = pq.into_iter();
@@ -741,17 +741,17 @@ mod tests {
 
     #[test]
     fn test_move_iter_reverse() {
-        let data = vec!(5, 9, 3);
-        let iterout = vec!(3, 5, 9);
+        let data = vec![5, 9, 3];
+        let iterout = vec![3, 5, 9];
         let pq = BinaryHeap::from_vec(data);
 
-        let v: Vec<int> = pq.into_iter().rev().collect();
+        let v: Vec<_> = pq.into_iter().rev().collect();
         assert_eq!(v, iterout);
     }
 
     #[test]
     fn test_peek_and_pop() {
-        let data = vec!(2u, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1);
+        let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
         let mut sorted = data.clone();
         sorted.sort();
         let mut heap = BinaryHeap::from_vec(data);
@@ -763,7 +763,7 @@ mod tests {
 
     #[test]
     fn test_push() {
-        let mut heap = BinaryHeap::from_vec(vec!(2, 4, 9));
+        let mut heap = BinaryHeap::from_vec(vec![2, 4, 9]);
         assert_eq!(heap.len(), 3);
         assert!(*heap.peek().unwrap() == 9);
         heap.push(11);
@@ -785,7 +785,7 @@ mod tests {
 
     #[test]
     fn test_push_unique() {
-        let mut heap = BinaryHeap::from_vec(vec!(box 2, box 4, box 9));
+        let mut heap = BinaryHeap::from_vec(vec![box 2, box 4, box 9]);
         assert_eq!(heap.len(), 3);
         assert!(*heap.peek().unwrap() == box 9);
         heap.push(box 11);
@@ -807,7 +807,7 @@ mod tests {
 
     #[test]
     fn test_push_pop() {
-        let mut heap = BinaryHeap::from_vec(vec!(5, 5, 2, 1, 3));
+        let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
         assert_eq!(heap.len(), 5);
         assert_eq!(heap.push_pop(6), 6);
         assert_eq!(heap.len(), 5);
@@ -821,7 +821,7 @@ mod tests {
 
     #[test]
     fn test_replace() {
-        let mut heap = BinaryHeap::from_vec(vec!(5, 5, 2, 1, 3));
+        let mut heap = BinaryHeap::from_vec(vec![5, 5, 2, 1, 3]);
         assert_eq!(heap.len(), 5);
         assert_eq!(heap.replace(6).unwrap(), 5);
         assert_eq!(heap.len(), 5);
@@ -833,7 +833,7 @@ mod tests {
         assert_eq!(heap.len(), 5);
     }
 
-    fn check_to_vec(mut data: Vec<int>) {
+    fn check_to_vec(mut data: Vec<i32>) {
         let heap = BinaryHeap::from_vec(data.clone());
         let mut v = heap.clone().into_vec();
         v.sort();
@@ -845,44 +845,44 @@ mod tests {
 
     #[test]
     fn test_to_vec() {
-        check_to_vec(vec!());
-        check_to_vec(vec!(5));
-        check_to_vec(vec!(3, 2));
-        check_to_vec(vec!(2, 3));
-        check_to_vec(vec!(5, 1, 2));
-        check_to_vec(vec!(1, 100, 2, 3));
-        check_to_vec(vec!(1, 3, 5, 7, 9, 2, 4, 6, 8, 0));
-        check_to_vec(vec!(2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1));
-        check_to_vec(vec!(9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0));
-        check_to_vec(vec!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
-        check_to_vec(vec!(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0));
-        check_to_vec(vec!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2));
-        check_to_vec(vec!(5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1));
+        check_to_vec(vec![]);
+        check_to_vec(vec![5]);
+        check_to_vec(vec![3, 2]);
+        check_to_vec(vec![2, 3]);
+        check_to_vec(vec![5, 1, 2]);
+        check_to_vec(vec![1, 100, 2, 3]);
+        check_to_vec(vec![1, 3, 5, 7, 9, 2, 4, 6, 8, 0]);
+        check_to_vec(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]);
+        check_to_vec(vec![9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0]);
+        check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+        check_to_vec(vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]);
+        check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2]);
+        check_to_vec(vec![5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1]);
     }
 
     #[test]
     fn test_empty_pop() {
-        let mut heap = BinaryHeap::<int>::new();
+        let mut heap = BinaryHeap::<i32>::new();
         assert!(heap.pop().is_none());
     }
 
     #[test]
     fn test_empty_peek() {
-        let empty = BinaryHeap::<int>::new();
+        let empty = BinaryHeap::<i32>::new();
         assert!(empty.peek().is_none());
     }
 
     #[test]
     fn test_empty_replace() {
-        let mut heap = BinaryHeap::<int>::new();
+        let mut heap = BinaryHeap::new();
         assert!(heap.replace(5).is_none());
     }
 
     #[test]
     fn test_from_iter() {
-        let xs = vec!(9u, 8, 7, 6, 5, 4, 3, 2, 1);
+        let xs = vec![9, 8, 7, 6, 5, 4, 3, 2, 1];
 
-        let mut q: BinaryHeap<uint> = xs.iter().rev().map(|&x| x).collect();
+        let mut q: BinaryHeap<_> = xs.iter().rev().cloned().collect();
 
         for &x in &xs {
             assert_eq!(q.pop().unwrap(), x);
@@ -891,8 +891,7 @@ mod tests {
 
     #[test]
     fn test_drain() {
-        let mut q: BinaryHeap<_> =
-            [9u, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
+        let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
 
         assert_eq!(q.drain().take(5).count(), 5);
 
diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs
index c9b3f72526f..8ba0eb9b7ef 100644
--- a/src/libcollections/bit.rs
+++ b/src/libcollections/bit.rs
@@ -18,7 +18,7 @@
 // rather `or` and `and`.
 
 // (1) Be careful, most things can overflow here because the amount of bits in
-//     memory can overflow `uint`.
+//     memory can overflow `usize`.
 // (2) Make sure that the underlying vector has no excess length:
 //     E. g. `nbits == 16`, `storage.len() == 2` would be excess length,
 //     because the last word isn't used at all. This is important because some
@@ -54,7 +54,7 @@
 //!     bv.set(0, false);
 //!     bv.set(1, false);
 //!
-//!     for i in iter::range_inclusive(2, (max_prime as f64).sqrt() as uint) {
+//!     for i in iter::range_inclusive(2, (max_prime as f64).sqrt() as usize) {
 //!         // if i is a prime
 //!         if bv[i] {
 //!             // Mark all multiples of i as non-prime (any multiples below i * i
@@ -66,7 +66,7 @@
 //! };
 //!
 //! // Simple primality tests below our max bound
-//! let print_primes = 20u;
+//! let print_primes = 20;
 //! print!("The primes below {} are: ", print_primes);
 //! for x in 0..print_primes {
 //!     if primes.contains(&x) {
@@ -93,7 +93,7 @@ use core::iter::{self, FromIterator, IntoIterator};
 use core::num::Int;
 use core::ops::Index;
 use core::slice;
-use core::{u8, u32, uint};
+use core::{u8, u32, usize};
 use bitv_set; //so meta
 
 use Vec;
@@ -162,15 +162,15 @@ pub struct Bitv {
     /// Internal representation of the bit vector
     storage: Vec<u32>,
     /// The number of valid bits in the internal representation
-    nbits: uint
+    nbits: usize
 }
 
 // FIXME(Gankro): NopeNopeNopeNopeNope (wait for IndexGet to be a thing)
-impl Index<uint> for Bitv {
+impl Index<usize> for Bitv {
     type Output = bool;
 
     #[inline]
-    fn index(&self, i: &uint) -> &bool {
+    fn index(&self, i: &usize) -> &bool {
         if self.get(*i).expect("index out of bounds") {
             &TRUE
         } else {
@@ -180,7 +180,7 @@ impl Index<uint> for Bitv {
 }
 
 /// Computes how many blocks are needed to store that many bits
-fn blocks_for_bits(bits: uint) -> uint {
+fn blocks_for_bits(bits: usize) -> usize {
     // If we want 17 bits, dividing by 32 will produce 0. So we add 1 to make sure we
     // reserve enough. But if we want exactly a multiple of 32, this will actually allocate
     // one too many. So we need to check if that's the case. We can do that by computing if
@@ -188,7 +188,7 @@ fn blocks_for_bits(bits: uint) -> uint {
     // superior modulo operator on a power of two to this.
     //
     // Note that we can technically avoid this branch with the expression
-    // `(nbits + u32::BITS - 1) / 32::BITS`, but if nbits is almost uint::MAX this will overflow.
+    // `(nbits + u32::BITS - 1) / 32::BITS`, but if nbits is almost usize::MAX this will overflow.
     if bits % u32::BITS == 0 {
         bits / u32::BITS
     } else {
@@ -197,7 +197,7 @@ fn blocks_for_bits(bits: uint) -> uint {
 }
 
 /// Computes the bitmask for the final word of the vector
-fn mask_for_bits(bits: uint) -> u32 {
+fn mask_for_bits(bits: usize) -> u32 {
     // Note especially that a perfect multiple of u32::BITS should mask all 1s.
     !0u32 >> (u32::BITS - bits % u32::BITS) % u32::BITS
 }
@@ -266,13 +266,13 @@ impl Bitv {
     /// ```
     /// use std::collections::Bitv;
     ///
-    /// let mut bv = Bitv::from_elem(10u, false);
-    /// assert_eq!(bv.len(), 10u);
+    /// let mut bv = Bitv::from_elem(10, false);
+    /// assert_eq!(bv.len(), 10);
     /// for x in bv.iter() {
     ///     assert_eq!(x, false);
     /// }
     /// ```
-    pub fn from_elem(nbits: uint, bit: bool) -> Bitv {
+    pub fn from_elem(nbits: usize, bit: bool) -> Bitv {
         let nblocks = blocks_for_bits(nbits);
         let mut bitv = Bitv {
             storage: repeat(if bit { !0u32 } else { 0u32 }).take(nblocks).collect(),
@@ -290,7 +290,7 @@ impl Bitv {
     /// It is important to note that this function does not specify the
     /// *length* of the returned bitvector, but only the *capacity*.
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_capacity(nbits: uint) -> Bitv {
+    pub fn with_capacity(nbits: usize) -> Bitv {
         Bitv {
             storage: Vec::with_capacity(blocks_for_bits(nbits)),
             nbits: 0,
@@ -351,9 +351,9 @@ impl Bitv {
     /// let bv = Bitv::from_fn(5, |i| { i % 2 == 0 });
     /// assert!(bv.eq_vec(&[true, false, true, false, true]));
     /// ```
-    pub fn from_fn<F>(len: uint, mut f: F) -> Bitv where F: FnMut(uint) -> bool {
+    pub fn from_fn<F>(len: usize, mut f: F) -> Bitv where F: FnMut(usize) -> bool {
         let mut bitv = Bitv::from_elem(len, false);
-        for i in 0u..len {
+        for i in 0..len {
             bitv.set(i, f(i));
         }
         bitv
@@ -376,7 +376,7 @@ impl Bitv {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get(&self, i: uint) -> Option<bool> {
+    pub fn get(&self, i: usize) -> Option<bool> {
         if i >= self.nbits {
             return None;
         }
@@ -405,7 +405,7 @@ impl Bitv {
     #[inline]
     #[unstable(feature = "collections",
                reason = "panic semantics are likely to change in the future")]
-    pub fn set(&mut self, i: uint, x: bool) {
+    pub fn set(&mut self, i: usize, x: bool) {
         assert!(i < self.nbits);
         let w = i / u32::BITS;
         let b = i % u32::BITS;
@@ -649,7 +649,7 @@ impl Bitv {
     /// assert_eq!(bv.to_bytes(), vec!(0b00100000, 0b10000000));
     /// ```
     pub fn to_bytes(&self) -> Vec<u8> {
-        fn bit(bitv: &Bitv, byte: uint, bit: uint) -> u8 {
+        fn bit(bitv: &Bitv, byte: usize, bit: usize) -> u8 {
             let offset = byte * 8 + bit;
             if offset >= bitv.nbits {
                 0
@@ -709,7 +709,7 @@ impl Bitv {
     /// assert!(bv.eq_vec(&[false, true]));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn truncate(&mut self, len: uint) {
+    pub fn truncate(&mut self, len: usize) {
         if len < self.len() {
             self.nbits = len;
             // This fixes (2).
@@ -723,7 +723,7 @@ impl Bitv {
     ///
     /// # Panics
     ///
-    /// Panics if the new capacity overflows `uint`.
+    /// Panics if the new capacity overflows `usize`.
     ///
     /// # Examples
     ///
@@ -736,7 +736,7 @@ impl Bitv {
     /// assert!(bv.capacity() >= 13);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve(&mut self, additional: uint) {
+    pub fn reserve(&mut self, additional: usize) {
         let desired_cap = self.len().checked_add(additional).expect("capacity overflow");
         let storage_len = self.storage.len();
         if desired_cap > self.capacity() {
@@ -753,7 +753,7 @@ impl Bitv {
     ///
     /// # Panics
     ///
-    /// Panics if the new capacity overflows `uint`.
+    /// Panics if the new capacity overflows `usize`.
     ///
     /// # Examples
     ///
@@ -766,7 +766,7 @@ impl Bitv {
     /// assert!(bv.capacity() >= 13);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_exact(&mut self, additional: uint) {
+    pub fn reserve_exact(&mut self, additional: usize) {
         let desired_cap = self.len().checked_add(additional).expect("capacity overflow");
         let storage_len = self.storage.len();
         if desired_cap > self.capacity() {
@@ -788,15 +788,15 @@ impl Bitv {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn capacity(&self) -> uint {
-        self.storage.capacity().checked_mul(u32::BITS).unwrap_or(uint::MAX)
+    pub fn capacity(&self) -> usize {
+        self.storage.capacity().checked_mul(u32::BITS).unwrap_or(usize::MAX)
     }
 
     /// Grows the `Bitv` in-place, adding `n` copies of `value` to the `Bitv`.
     ///
     /// # Panics
     ///
-    /// Panics if the new len overflows a `uint`.
+    /// Panics if the new len overflows a `usize`.
     ///
     /// # Examples
     ///
@@ -808,7 +808,7 @@ impl Bitv {
     /// assert_eq!(bv.len(), 10);
     /// assert_eq!(bv.to_bytes(), vec!(0b01001011, 0b11000000));
     /// ```
-    pub fn grow(&mut self, n: uint, value: bool) {
+    pub fn grow(&mut self, n: usize, value: bool) {
         // Note: we just bulk set all the bits in the last word in this fn in multiple places
         // which is technically wrong if not all of these bits are to be used. However, at the end
         // of this fn we call `fix_last_block` at the end of this fn, which should fix this.
@@ -901,7 +901,7 @@ impl Bitv {
     /// Return the total number of bits in this vector
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> uint { self.nbits }
+    pub fn len(&self) -> usize { self.nbits }
 
     /// Returns true if there are no bits in this vector
     #[inline]
@@ -1012,8 +1012,8 @@ impl cmp::Eq for Bitv {}
 #[derive(Clone)]
 pub struct Iter<'a> {
     bitv: &'a Bitv,
-    next_idx: uint,
-    end_idx: uint,
+    next_idx: usize,
+    end_idx: usize,
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1031,7 +1031,7 @@ impl<'a> Iterator for Iter<'a> {
         }
     }
 
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         let rem = self.end_idx - self.next_idx;
         (rem, Some(rem))
     }
@@ -1056,12 +1056,12 @@ impl<'a> ExactSizeIterator for Iter<'a> {}
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> RandomAccessIterator for Iter<'a> {
     #[inline]
-    fn indexable(&self) -> uint {
+    fn indexable(&self) -> usize {
         self.end_idx - self.next_idx
     }
 
     #[inline]
-    fn idx(&mut self, index: uint) -> Option<bool> {
+    fn idx(&mut self, index: usize) -> Option<bool> {
         if index >= self.indexable() {
             None
         } else {
@@ -1083,7 +1083,7 @@ impl<'a> IntoIterator for &'a Bitv {
 ///
 /// It should also be noted that the amount of storage necessary for holding a
 /// set of objects is proportional to the maximum of the objects when viewed
-/// as a `uint`.
+/// as a `usize`.
 ///
 /// # Examples
 ///
@@ -1130,8 +1130,8 @@ impl Default for BitvSet {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl FromIterator<uint> for BitvSet {
-    fn from_iter<I:Iterator<Item=uint>>(iterator: I) -> BitvSet {
+impl FromIterator<usize> for BitvSet {
+    fn from_iter<I:Iterator<Item=usize>>(iterator: I) -> BitvSet {
         let mut ret = BitvSet::new();
         ret.extend(iterator);
         ret
@@ -1139,9 +1139,9 @@ impl FromIterator<uint> for BitvSet {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl Extend<uint> for BitvSet {
+impl Extend<usize> for BitvSet {
     #[inline]
-    fn extend<I: Iterator<Item=uint>>(&mut self, iterator: I) {
+    fn extend<I: Iterator<Item=usize>>(&mut self, iterator: I) {
         for i in iterator {
             self.insert(i);
         }
@@ -1207,7 +1207,7 @@ impl BitvSet {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_capacity(nbits: uint) -> BitvSet {
+    pub fn with_capacity(nbits: usize) -> BitvSet {
         let bitv = Bitv::from_elem(nbits, false);
         BitvSet::from_bitv(bitv)
     }
@@ -1245,7 +1245,7 @@ impl BitvSet {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn capacity(&self) -> uint {
+    pub fn capacity(&self) -> usize {
         self.bitv.capacity()
     }
 
@@ -1266,7 +1266,7 @@ impl BitvSet {
     /// assert!(s.capacity() >= 10);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_len(&mut self, len: uint) {
+    pub fn reserve_len(&mut self, len: usize) {
         let cur_len = self.bitv.len();
         if len >= cur_len {
             self.bitv.reserve(len - cur_len);
@@ -1292,7 +1292,7 @@ impl BitvSet {
     /// assert!(s.capacity() >= 10);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_len_exact(&mut self, len: uint) {
+    pub fn reserve_len_exact(&mut self, len: usize) {
         let cur_len = self.bitv.len();
         if len >= cur_len {
             self.bitv.reserve_exact(len - cur_len);
@@ -1415,7 +1415,7 @@ impl BitvSet {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn iter(&self) -> bitv_set::Iter {
-        SetIter {set: self, next_idx: 0u}
+        SetIter {set: self, next_idx: 0}
     }
 
     /// Iterator over each u32 stored in `self` union `other`.
@@ -1443,12 +1443,12 @@ impl BitvSet {
             set: self,
             other: other,
             merge: or,
-            current_word: 0u32,
-            next_idx: 0u
+            current_word: 0,
+            next_idx: 0
         })
     }
 
-    /// Iterator over each uint stored in `self` intersect `other`.
+    /// Iterator over each usize stored in `self` intersect `other`.
     /// See [intersect_with](#method.intersect_with) for an efficient in-place version.
     ///
     /// # Examples
@@ -1473,12 +1473,12 @@ impl BitvSet {
             set: self,
             other: other,
             merge: bitand,
-            current_word: 0u32,
+            current_word: 0,
             next_idx: 0
         }.take(min))
     }
 
-    /// Iterator over each uint stored in the `self` setminus `other`.
+    /// Iterator over each usize stored in the `self` setminus `other`.
     /// See [difference_with](#method.difference_with) for an efficient in-place version.
     ///
     /// # Examples
@@ -1510,7 +1510,7 @@ impl BitvSet {
             set: self,
             other: other,
             merge: diff,
-            current_word: 0u32,
+            current_word: 0,
             next_idx: 0
         })
     }
@@ -1541,7 +1541,7 @@ impl BitvSet {
             set: self,
             other: other,
             merge: bitxor,
-            current_word: 0u32,
+            current_word: 0,
             next_idx: 0
         })
     }
@@ -1651,7 +1651,7 @@ impl BitvSet {
     /// Return the number of set bits in this set.
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> uint  {
+    pub fn len(&self) -> usize  {
         self.bitv.blocks().fold(0, |acc, n| acc + n.count_ones())
     }
 
@@ -1672,7 +1672,7 @@ impl BitvSet {
     /// Returns `true` if this set contains the specified integer.
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn contains(&self, value: &uint) -> bool {
+    pub fn contains(&self, value: &usize) -> bool {
         let bitv = &self.bitv;
         *value < bitv.nbits && bitv[*value]
     }
@@ -1709,7 +1709,7 @@ impl BitvSet {
     /// Adds a value to the set. Returns `true` if the value was not already
     /// present in the set.
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn insert(&mut self, value: uint) -> bool {
+    pub fn insert(&mut self, value: usize) -> bool {
         if self.contains(&value) {
             return false;
         }
@@ -1727,7 +1727,7 @@ impl BitvSet {
     /// Removes a value from the set. Returns `true` if the value was
     /// present in the set.
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn remove(&mut self, value: &uint) -> bool {
+    pub fn remove(&mut self, value: &usize) -> bool {
         if !self.contains(value) {
             return false;
         }
@@ -1767,7 +1767,7 @@ impl<S: hash::Writer + hash::Hasher> hash::Hash<S> for BitvSet {
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct SetIter<'a> {
     set: &'a BitvSet,
-    next_idx: uint
+    next_idx: usize
 }
 
 /// An iterator combining two `BitvSet` iterators.
@@ -1777,7 +1777,7 @@ struct TwoBitPositions<'a> {
     other: &'a BitvSet,
     merge: fn(u32, u32) -> u32,
     current_word: u32,
-    next_idx: uint
+    next_idx: usize
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1791,9 +1791,9 @@ pub struct SymmetricDifference<'a>(TwoBitPositions<'a>);
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> Iterator for SetIter<'a> {
-    type Item = uint;
+    type Item = usize;
 
-    fn next(&mut self) -> Option<uint> {
+    fn next(&mut self) -> Option<usize> {
         while self.next_idx < self.set.bitv.len() {
             let idx = self.next_idx;
             self.next_idx += 1;
@@ -1807,16 +1807,16 @@ impl<'a> Iterator for SetIter<'a> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         (0, Some(self.set.bitv.len() - self.next_idx))
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> Iterator for TwoBitPositions<'a> {
-    type Item = uint;
+    type Item = usize;
 
-    fn next(&mut self) -> Option<uint> {
+    fn next(&mut self) -> Option<usize> {
         while self.next_idx < self.set.bitv.len() ||
               self.next_idx < self.other.bitv.len() {
             let bit_idx = self.next_idx % u32::BITS;
@@ -1844,7 +1844,7 @@ impl<'a> Iterator for TwoBitPositions<'a> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         let cap = cmp::max(self.set.bitv.len(), self.other.bitv.len());
         (0, Some(cap - self.next_idx))
     }
@@ -1852,34 +1852,34 @@ impl<'a> Iterator for TwoBitPositions<'a> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> Iterator for Union<'a> {
-    type Item = uint;
+    type Item = usize;
 
-    #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
-    #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
+    #[inline] fn next(&mut self) -> Option<usize> { self.0.next() }
+    #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> Iterator for Intersection<'a> {
-    type Item = uint;
+    type Item = usize;
 
-    #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
-    #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
+    #[inline] fn next(&mut self) -> Option<usize> { self.0.next() }
+    #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> Iterator for Difference<'a> {
-    type Item = uint;
+    type Item = usize;
 
-    #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
-    #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
+    #[inline] fn next(&mut self) -> Option<usize> { self.0.next() }
+    #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> Iterator for SymmetricDifference<'a> {
-    type Item = uint;
+    type Item = usize;
 
-    #[inline] fn next(&mut self) -> Option<uint> { self.0.next() }
-    #[inline] fn size_hint(&self) -> (uint, Option<uint>) { self.0.size_hint() }
+    #[inline] fn next(&mut self) -> Option<usize> { self.0.next() }
+    #[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }
 }
 
 impl<'a> IntoIterator for &'a BitvSet {
@@ -1902,7 +1902,7 @@ mod tests {
         let zerolen = Bitv::new();
         assert_eq!(format!("{:?}", zerolen), "");
 
-        let eightbits = Bitv::from_elem(8u, false);
+        let eightbits = Bitv::from_elem(8, false);
         assert_eq!(format!("{:?}", eightbits), "00000000")
     }
 
@@ -1916,10 +1916,10 @@ mod tests {
 
     #[test]
     fn test_1_element() {
-        let mut act = Bitv::from_elem(1u, false);
+        let mut act = Bitv::from_elem(1, false);
         assert!(act.eq_vec(&[false]));
         assert!(act.none() && !act.all());
-        act = Bitv::from_elem(1u, true);
+        act = Bitv::from_elem(1, true);
         assert!(act.eq_vec(&[true]));
         assert!(!act.none() && act.all());
     }
@@ -1938,42 +1938,42 @@ mod tests {
         let mut act;
         // all 0
 
-        act = Bitv::from_elem(10u, false);
+        act = Bitv::from_elem(10, false);
         assert!((act.eq_vec(
                     &[false, false, false, false, false, false, false, false, false, false])));
         assert!(act.none() && !act.all());
         // all 1
 
-        act = Bitv::from_elem(10u, true);
+        act = Bitv::from_elem(10, true);
         assert!((act.eq_vec(&[true, true, true, true, true, true, true, true, true, true])));
         assert!(!act.none() && act.all());
         // mixed
 
-        act = Bitv::from_elem(10u, false);
-        act.set(0u, true);
-        act.set(1u, true);
-        act.set(2u, true);
-        act.set(3u, true);
-        act.set(4u, true);
+        act = Bitv::from_elem(10, false);
+        act.set(0, true);
+        act.set(1, true);
+        act.set(2, true);
+        act.set(3, true);
+        act.set(4, true);
         assert!((act.eq_vec(&[true, true, true, true, true, false, false, false, false, false])));
         assert!(!act.none() && !act.all());
         // mixed
 
-        act = Bitv::from_elem(10u, false);
-        act.set(5u, true);
-        act.set(6u, true);
-        act.set(7u, true);
-        act.set(8u, true);
-        act.set(9u, true);
+        act = Bitv::from_elem(10, false);
+        act.set(5, true);
+        act.set(6, true);
+        act.set(7, true);
+        act.set(8, true);
+        act.set(9, true);
         assert!((act.eq_vec(&[false, false, false, false, false, true, true, true, true, true])));
         assert!(!act.none() && !act.all());
         // mixed
 
-        act = Bitv::from_elem(10u, false);
-        act.set(0u, true);
-        act.set(3u, true);
-        act.set(6u, true);
-        act.set(9u, true);
+        act = Bitv::from_elem(10, false);
+        act.set(0, true);
+        act.set(3, true);
+        act.set(6, true);
+        act.set(9, true);
         assert!((act.eq_vec(&[true, false, false, true, false, false, true, false, false, true])));
         assert!(!act.none() && !act.all());
     }
@@ -1983,7 +1983,7 @@ mod tests {
         let mut act;
         // all 0
 
-        act = Bitv::from_elem(31u, false);
+        act = Bitv::from_elem(31, false);
         assert!(act.eq_vec(
                 &[false, false, false, false, false, false, false, false, false, false, false,
                   false, false, false, false, false, false, false, false, false, false, false,
@@ -1991,7 +1991,7 @@ mod tests {
         assert!(act.none() && !act.all());
         // all 1
 
-        act = Bitv::from_elem(31u, true);
+        act = Bitv::from_elem(31, true);
         assert!(act.eq_vec(
                 &[true, true, true, true, true, true, true, true, true, true, true, true, true,
                   true, true, true, true, true, true, true, true, true, true, true, true, true,
@@ -1999,15 +1999,15 @@ mod tests {
         assert!(!act.none() && act.all());
         // mixed
 
-        act = Bitv::from_elem(31u, false);
-        act.set(0u, true);
-        act.set(1u, true);
-        act.set(2u, true);
-        act.set(3u, true);
-        act.set(4u, true);
-        act.set(5u, true);
-        act.set(6u, true);
-        act.set(7u, true);
+        act = Bitv::from_elem(31, false);
+        act.set(0, true);
+        act.set(1, true);
+        act.set(2, true);
+        act.set(3, true);
+        act.set(4, true);
+        act.set(5, true);
+        act.set(6, true);
+        act.set(7, true);
         assert!(act.eq_vec(
                 &[true, true, true, true, true, true, true, true, false, false, false, false, false,
                   false, false, false, false, false, false, false, false, false, false, false,
@@ -2015,15 +2015,15 @@ mod tests {
         assert!(!act.none() && !act.all());
         // mixed
 
-        act = Bitv::from_elem(31u, false);
-        act.set(16u, true);
-        act.set(17u, true);
-        act.set(18u, true);
-        act.set(19u, true);
-        act.set(20u, true);
-        act.set(21u, true);
-        act.set(22u, true);
-        act.set(23u, true);
+        act = Bitv::from_elem(31, false);
+        act.set(16, true);
+        act.set(17, true);
+        act.set(18, true);
+        act.set(19, true);
+        act.set(20, true);
+        act.set(21, true);
+        act.set(22, true);
+        act.set(23, true);
         assert!(act.eq_vec(
                 &[false, false, false, false, false, false, false, false, false, false, false,
                   false, false, false, false, false, true, true, true, true, true, true, true, true,
@@ -2031,14 +2031,14 @@ mod tests {
         assert!(!act.none() && !act.all());
         // mixed
 
-        act = Bitv::from_elem(31u, false);
-        act.set(24u, true);
-        act.set(25u, true);
-        act.set(26u, true);
-        act.set(27u, true);
-        act.set(28u, true);
-        act.set(29u, true);
-        act.set(30u, true);
+        act = Bitv::from_elem(31, false);
+        act.set(24, true);
+        act.set(25, true);
+        act.set(26, true);
+        act.set(27, true);
+        act.set(28, true);
+        act.set(29, true);
+        act.set(30, true);
         assert!(act.eq_vec(
                 &[false, false, false, false, false, false, false, false, false, false, false,
                   false, false, false, false, false, false, false, false, false, false, false,
@@ -2046,10 +2046,10 @@ mod tests {
         assert!(!act.none() && !act.all());
         // mixed
 
-        act = Bitv::from_elem(31u, false);
-        act.set(3u, true);
-        act.set(17u, true);
-        act.set(30u, true);
+        act = Bitv::from_elem(31, false);
+        act.set(3, true);
+        act.set(17, true);
+        act.set(30, true);
         assert!(act.eq_vec(
                 &[false, false, false, true, false, false, false, false, false, false, false, false,
                   false, false, false, false, false, true, false, false, false, false, false, false,
@@ -2062,7 +2062,7 @@ mod tests {
         let mut act;
         // all 0
 
-        act = Bitv::from_elem(32u, false);
+        act = Bitv::from_elem(32, false);
         assert!(act.eq_vec(
                 &[false, false, false, false, false, false, false, false, false, false, false,
                   false, false, false, false, false, false, false, false, false, false, false,
@@ -2070,7 +2070,7 @@ mod tests {
         assert!(act.none() && !act.all());
         // all 1
 
-        act = Bitv::from_elem(32u, true);
+        act = Bitv::from_elem(32, true);
         assert!(act.eq_vec(
                 &[true, true, true, true, true, true, true, true, true, true, true, true, true,
                   true, true, true, true, true, true, true, true, true, true, true, true, true,
@@ -2078,15 +2078,15 @@ mod tests {
         assert!(!act.none() && act.all());
         // mixed
 
-        act = Bitv::from_elem(32u, false);
-        act.set(0u, true);
-        act.set(1u, true);
-        act.set(2u, true);
-        act.set(3u, true);
-        act.set(4u, true);
-        act.set(5u, true);
-        act.set(6u, true);
-        act.set(7u, true);
+        act = Bitv::from_elem(32, false);
+        act.set(0, true);
+        act.set(1, true);
+        act.set(2, true);
+        act.set(3, true);
+        act.set(4, true);
+        act.set(5, true);
+        act.set(6, true);
+        act.set(7, true);
         assert!(act.eq_vec(
                 &[true, true, true, true, true, true, true, true, false, false, false, false, false,
                   false, false, false, false, false, false, false, false, false, false, false,
@@ -2094,15 +2094,15 @@ mod tests {
         assert!(!act.none() && !act.all());
         // mixed
 
-        act = Bitv::from_elem(32u, false);
-        act.set(16u, true);
-        act.set(17u, true);
-        act.set(18u, true);
-        act.set(19u, true);
-        act.set(20u, true);
-        act.set(21u, true);
-        act.set(22u, true);
-        act.set(23u, true);
+        act = Bitv::from_elem(32, false);
+        act.set(16, true);
+        act.set(17, true);
+        act.set(18, true);
+        act.set(19, true);
+        act.set(20, true);
+        act.set(21, true);
+        act.set(22, true);
+        act.set(23, true);
         assert!(act.eq_vec(
                 &[false, false, false, false, false, false, false, false, false, false, false,
                   false, false, false, false, false, true, true, true, true, true, true, true, true,
@@ -2110,15 +2110,15 @@ mod tests {
         assert!(!act.none() && !act.all());
         // mixed
 
-        act = Bitv::from_elem(32u, false);
-        act.set(24u, true);
-        act.set(25u, true);
-        act.set(26u, true);
-        act.set(27u, true);
-        act.set(28u, true);
-        act.set(29u, true);
-        act.set(30u, true);
-        act.set(31u, true);
+        act = Bitv::from_elem(32, false);
+        act.set(24, true);
+        act.set(25, true);
+        act.set(26, true);
+        act.set(27, true);
+        act.set(28, true);
+        act.set(29, true);
+        act.set(30, true);
+        act.set(31, true);
         assert!(act.eq_vec(
                 &[false, false, false, false, false, false, false, false, false, false, false,
                   false, false, false, false, false, false, false, false, false, false, false,
@@ -2126,11 +2126,11 @@ mod tests {
         assert!(!act.none() && !act.all());
         // mixed
 
-        act = Bitv::from_elem(32u, false);
-        act.set(3u, true);
-        act.set(17u, true);
-        act.set(30u, true);
-        act.set(31u, true);
+        act = Bitv::from_elem(32, false);
+        act.set(3, true);
+        act.set(17, true);
+        act.set(30, true);
+        act.set(31, true);
         assert!(act.eq_vec(
                 &[false, false, false, true, false, false, false, false, false, false, false, false,
                   false, false, false, false, false, true, false, false, false, false, false, false,
@@ -2143,7 +2143,7 @@ mod tests {
         let mut act;
         // all 0
 
-        act = Bitv::from_elem(33u, false);
+        act = Bitv::from_elem(33, false);
         assert!(act.eq_vec(
                 &[false, false, false, false, false, false, false, false, false, false, false,
                   false, false, false, false, false, false, false, false, false, false, false,
@@ -2151,7 +2151,7 @@ mod tests {
         assert!(act.none() && !act.all());
         // all 1
 
-        act = Bitv::from_elem(33u, true);
+        act = Bitv::from_elem(33, true);
         assert!(act.eq_vec(
                 &[true, true, true, true, true, true, true, true, true, true, true, true, true,
                   true, true, true, true, true, true, true, true, true, true, true, true, true,
@@ -2159,15 +2159,15 @@ mod tests {
         assert!(!act.none() && act.all());
         // mixed
 
-        act = Bitv::from_elem(33u, false);
-        act.set(0u, true);
-        act.set(1u, true);
-        act.set(2u, true);
-        act.set(3u, true);
-        act.set(4u, true);
-        act.set(5u, true);
-        act.set(6u, true);
-        act.set(7u, true);
+        act = Bitv::from_elem(33, false);
+        act.set(0, true);
+        act.set(1, true);
+        act.set(2, true);
+        act.set(3, true);
+        act.set(4, true);
+        act.set(5, true);
+        act.set(6, true);
+        act.set(7, true);
         assert!(act.eq_vec(
                 &[true, true, true, true, true, true, true, true, false, false, false, false, false,
                   false, false, false, false, false, false, false, false, false, false, false,
@@ -2175,15 +2175,15 @@ mod tests {
         assert!(!act.none() && !act.all());
         // mixed
 
-        act = Bitv::from_elem(33u, false);
-        act.set(16u, true);
-        act.set(17u, true);
-        act.set(18u, true);
-        act.set(19u, true);
-        act.set(20u, true);
-        act.set(21u, true);
-        act.set(22u, true);
-        act.set(23u, true);
+        act = Bitv::from_elem(33, false);
+        act.set(16, true);
+        act.set(17, true);
+        act.set(18, true);
+        act.set(19, true);
+        act.set(20, true);
+        act.set(21, true);
+        act.set(22, true);
+        act.set(23, true);
         assert!(act.eq_vec(
                 &[false, false, false, false, false, false, false, false, false, false, false,
                   false, false, false, false, false, true, true, true, true, true, true, true, true,
@@ -2191,15 +2191,15 @@ mod tests {
         assert!(!act.none() && !act.all());
         // mixed
 
-        act = Bitv::from_elem(33u, false);
-        act.set(24u, true);
-        act.set(25u, true);
-        act.set(26u, true);
-        act.set(27u, true);
-        act.set(28u, true);
-        act.set(29u, true);
-        act.set(30u, true);
-        act.set(31u, true);
+        act = Bitv::from_elem(33, false);
+        act.set(24, true);
+        act.set(25, true);
+        act.set(26, true);
+        act.set(27, true);
+        act.set(28, true);
+        act.set(29, true);
+        act.set(30, true);
+        act.set(31, true);
         assert!(act.eq_vec(
                 &[false, false, false, false, false, false, false, false, false, false, false,
                   false, false, false, false, false, false, false, false, false, false, false,
@@ -2207,12 +2207,12 @@ mod tests {
         assert!(!act.none() && !act.all());
         // mixed
 
-        act = Bitv::from_elem(33u, false);
-        act.set(3u, true);
-        act.set(17u, true);
-        act.set(30u, true);
-        act.set(31u, true);
-        act.set(32u, true);
+        act = Bitv::from_elem(33, false);
+        act.set(3, true);
+        act.set(17, true);
+        act.set(30, true);
+        act.set(31, true);
+        act.set(32, true);
         assert!(act.eq_vec(
                 &[false, false, false, true, false, false, false, false, false, false, false, false,
                   false, false, false, false, false, true, false, false, false, false, false, false,
@@ -2222,15 +2222,15 @@ mod tests {
 
     #[test]
     fn test_equal_differing_sizes() {
-        let v0 = Bitv::from_elem(10u, false);
-        let v1 = Bitv::from_elem(11u, false);
+        let v0 = Bitv::from_elem(10, false);
+        let v1 = Bitv::from_elem(11, false);
         assert!(v0 != v1);
     }
 
     #[test]
     fn test_equal_greatly_differing_sizes() {
-        let v0 = Bitv::from_elem(10u, false);
-        let v1 = Bitv::from_elem(110u, false);
+        let v0 = Bitv::from_elem(10, false);
+        let v1 = Bitv::from_elem(110, false);
         assert!(v0 != v1);
     }
 
@@ -2248,12 +2248,12 @@ mod tests {
     #[test]
     fn test_equal_sneaky_big() {
         let mut a = Bitv::from_elem(100, false);
-        for i in 0u..100 {
+        for i in 0..100 {
             a.set(i, true);
         }
 
         let mut b = Bitv::from_elem(100, true);
-        for i in 0u..100 {
+        for i in 0..100 {
             b.set(i, true);
         }
 
@@ -2288,7 +2288,7 @@ mod tests {
 
     #[test]
     fn test_to_bools() {
-        let bools = vec!(false, false, true, false, false, true, true, false);
+        let bools = vec![false, false, true, false, false, true, true, false];
         assert_eq!(Bitv::from_bytes(&[0b00100110]).iter().collect::<Vec<bool>>(), bools);
     }
 
@@ -2299,7 +2299,7 @@ mod tests {
 
         assert_eq!(bitv.iter().collect::<Vec<bool>>(), bools);
 
-        let long = (0i32..10000).map(|i| i % 2 == 0).collect::<Vec<_>>();
+        let long: Vec<_> = (0i32..10000).map(|i| i % 2 == 0).collect();
         let bitv: Bitv = long.iter().map(|n| *n).collect();
         assert_eq!(bitv.iter().collect::<Vec<bool>>(), long)
     }
@@ -2350,8 +2350,8 @@ mod tests {
 
     #[test]
     fn test_bitv_lt() {
-        let mut a = Bitv::from_elem(5u, false);
-        let mut b = Bitv::from_elem(5u, false);
+        let mut a = Bitv::from_elem(5, false);
+        let mut b = Bitv::from_elem(5, false);
 
         assert!(!(a < b) && !(b < a));
         b.set(2, true);
@@ -2366,8 +2366,8 @@ mod tests {
 
     #[test]
     fn test_ord() {
-        let mut a = Bitv::from_elem(5u, false);
-        let mut b = Bitv::from_elem(5u, false);
+        let mut a = Bitv::from_elem(5, false);
+        let mut b = Bitv::from_elem(5, false);
 
         assert!(a <= b && a >= b);
         a.set(1, true);
@@ -2530,7 +2530,7 @@ mod bitv_bench {
 
     use super::Bitv;
 
-    static BENCH_BITS : uint = 1 << 14;
+    static BENCH_BITS : usize = 1 << 14;
 
     fn rng() -> rand::IsaacRng {
         let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
@@ -2538,12 +2538,12 @@ mod bitv_bench {
     }
 
     #[bench]
-    fn bench_uint_small(b: &mut Bencher) {
+    fn bench_usize_small(b: &mut Bencher) {
         let mut r = rng();
-        let mut bitv = 0 as uint;
+        let mut bitv = 0 as usize;
         b.iter(|| {
-            for _ in 0u..100 {
-                bitv |= 1 << ((r.next_u32() as uint) % u32::BITS);
+            for _ in 0..100 {
+                bitv |= 1 << ((r.next_u32() as usize) % u32::BITS);
             }
             black_box(&bitv);
         });
@@ -2554,8 +2554,8 @@ mod bitv_bench {
         let mut r = rng();
         let mut bitv = Bitv::from_elem(BENCH_BITS, false);
         b.iter(|| {
-            for _ in 0u..100 {
-                bitv.set((r.next_u32() as uint) % BENCH_BITS, true);
+            for _ in 0..100 {
+                bitv.set((r.next_u32() as usize) % BENCH_BITS, true);
             }
             black_box(&bitv);
         });
@@ -2566,8 +2566,8 @@ mod bitv_bench {
         let mut r = rng();
         let mut bitv = Bitv::from_elem(BENCH_BITS, false);
         b.iter(|| {
-            for _ in 0u..100 {
-                bitv.set((r.next_u32() as uint) % BENCH_BITS, r.gen());
+            for _ in 0..100 {
+                bitv.set((r.next_u32() as usize) % BENCH_BITS, r.gen());
             }
             black_box(&bitv);
         });
@@ -2578,8 +2578,8 @@ mod bitv_bench {
         let mut r = rng();
         let mut bitv = Bitv::from_elem(u32::BITS, false);
         b.iter(|| {
-            for _ in 0u..100 {
-                bitv.set((r.next_u32() as uint) % u32::BITS, true);
+            for _ in 0..100 {
+                bitv.set((r.next_u32() as usize) % u32::BITS, true);
             }
             black_box(&bitv);
         });
@@ -2598,10 +2598,10 @@ mod bitv_bench {
     fn bench_bitv_small_iter(b: &mut Bencher) {
         let bitv = Bitv::from_elem(u32::BITS, false);
         b.iter(|| {
-            let mut sum = 0u;
-            for _ in 0u..10 {
+            let mut sum = 0;
+            for _ in 0..10 {
                 for pres in &bitv {
-                    sum += pres as uint;
+                    sum += pres as usize;
                 }
             }
             sum
@@ -2612,9 +2612,9 @@ mod bitv_bench {
     fn bench_bitv_big_iter(b: &mut Bencher) {
         let bitv = Bitv::from_elem(BENCH_BITS, false);
         b.iter(|| {
-            let mut sum = 0u;
+            let mut sum = 0;
             for pres in &bitv {
-                sum += pres as uint;
+                sum += pres as usize;
             }
             sum
         })
@@ -2645,9 +2645,9 @@ mod bitv_set_test {
     }
 
     #[test]
-    fn test_bitv_set_from_uints() {
-        let uints = vec![0, 2, 2, 3];
-        let a: BitvSet = uints.into_iter().collect();
+    fn test_bitv_set_from_usizes() {
+        let usizes = vec![0, 2, 2, 3];
+        let a: BitvSet = usizes.into_iter().collect();
         let mut b = BitvSet::new();
         b.insert(0);
         b.insert(2);
@@ -2657,16 +2657,16 @@ mod bitv_set_test {
 
     #[test]
     fn test_bitv_set_iterator() {
-        let uints = vec![0, 2, 2, 3];
-        let bitv: BitvSet = uints.into_iter().collect();
+        let usizes = vec![0, 2, 2, 3];
+        let bitv: BitvSet = usizes.into_iter().collect();
 
-        let idxs: Vec<uint> = bitv.iter().collect();
+        let idxs: Vec<_> = bitv.iter().collect();
         assert_eq!(idxs, vec![0, 2, 3]);
 
-        let long: BitvSet = (0u..10000).filter(|&n| n % 2 == 0).collect();
-        let real = range_step(0, 10000, 2).collect::<Vec<uint>>();
+        let long: BitvSet = (0..10000).filter(|&n| n % 2 == 0).collect();
+        let real: Vec<_> = range_step(0, 10000, 2).collect();
 
-        let idxs: Vec<uint> = long.iter().collect();
+        let idxs: Vec<_> = long.iter().collect();
         assert_eq!(idxs, real);
     }
 
@@ -2677,8 +2677,8 @@ mod bitv_set_test {
         for &b in &bools {
             for &l in &lengths {
                 let bitset = BitvSet::from_bitv(Bitv::from_elem(l, b));
-                assert_eq!(bitset.contains(&1u), b);
-                assert_eq!(bitset.contains(&(l-1u)), b);
+                assert_eq!(bitset.contains(&1), b);
+                assert_eq!(bitset.contains(&(l-1)), b);
                 assert!(!bitset.contains(&l));
             }
         }
@@ -2731,7 +2731,7 @@ mod bitv_set_test {
         assert!(b.insert(3));
 
         let expected = [3, 5, 11, 77];
-        let actual = a.intersection(&b).collect::<Vec<uint>>();
+        let actual: Vec<_> = a.intersection(&b).collect();
         assert_eq!(actual, expected);
     }
 
@@ -2750,7 +2750,7 @@ mod bitv_set_test {
         assert!(b.insert(200));
 
         let expected = [1, 5, 500];
-        let actual = a.difference(&b).collect::<Vec<uint>>();
+        let actual: Vec<_> = a.difference(&b).collect();
         assert_eq!(actual, expected);
     }
 
@@ -2771,7 +2771,7 @@ mod bitv_set_test {
         assert!(b.insert(220));
 
         let expected = [1, 5, 11, 14, 220];
-        let actual = a.symmetric_difference(&b).collect::<Vec<uint>>();
+        let actual: Vec<_> = a.symmetric_difference(&b).collect();
         assert_eq!(actual, expected);
     }
 
@@ -2796,7 +2796,7 @@ mod bitv_set_test {
         assert!(b.insert(19));
 
         let expected = [1, 3, 5, 9, 11, 13, 19, 24, 160, 200];
-        let actual = a.union(&b).collect::<Vec<uint>>();
+        let actual: Vec<_> = a.union(&b).collect();
         assert_eq!(actual, expected);
     }
 
@@ -3025,7 +3025,7 @@ mod bitv_set_bench {
 
     use super::{Bitv, BitvSet};
 
-    static BENCH_BITS : uint = 1 << 14;
+    static BENCH_BITS : usize = 1 << 14;
 
     fn rng() -> rand::IsaacRng {
         let seed: &[_] = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
@@ -3037,8 +3037,8 @@ mod bitv_set_bench {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
-            for _ in 0u..100 {
-                bitv.insert((r.next_u32() as uint) % u32::BITS);
+            for _ in 0..100 {
+                bitv.insert((r.next_u32() as usize) % u32::BITS);
             }
             black_box(&bitv);
         });
@@ -3049,8 +3049,8 @@ mod bitv_set_bench {
         let mut r = rng();
         let mut bitv = BitvSet::new();
         b.iter(|| {
-            for _ in 0u..100 {
-                bitv.insert((r.next_u32() as uint) % BENCH_BITS);
+            for _ in 0..100 {
+                bitv.insert((r.next_u32() as usize) % BENCH_BITS);
             }
             black_box(&bitv);
         });
@@ -3061,9 +3061,9 @@ mod bitv_set_bench {
         let bitv = BitvSet::from_bitv(Bitv::from_fn(BENCH_BITS,
                                               |idx| {idx % 3 == 0}));
         b.iter(|| {
-            let mut sum = 0u;
+            let mut sum = 0;
             for idx in &bitv {
-                sum += idx as uint;
+                sum += idx as usize;
             }
             sum
         })
diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs
index d7f89b0cc72..fdabec9eaf0 100644
--- a/src/libcollections/btree/map.rs
+++ b/src/libcollections/btree/map.rs
@@ -63,36 +63,20 @@ use super::node::{self, Node, Found, GoDown};
 /// would like to further explore choosing the optimal search strategy based on the choice of B,
 /// and possibly other factors. Using linear search, searching for a random element is expected
 /// to take O(B log<sub>B</sub>n) comparisons, which is generally worse than a BST. In practice,
-/// however, performance is excellent. `BTreeMap` is able to readily outperform `TreeMap` under
-/// many workloads, and is competitive where it doesn't. BTreeMap also generally *scales* better
-/// than TreeMap, making it more appropriate for large datasets.
-///
-/// However, `TreeMap` may still be more appropriate to use in many contexts. If elements are very
-/// large or expensive to compare, `TreeMap` may be more appropriate. It won't allocate any
-/// more space than is needed, and will perform the minimal number of comparisons necessary.
-/// `TreeMap` also provides much better performance stability guarantees. Generally, very few
-/// changes need to be made to update a BST, and two updates are expected to take about the same
-/// amount of time on roughly equal sized BSTs. However a B-Tree's performance is much more
-/// amortized. If a node is overfull, it must be split into two nodes. If a node is underfull, it
-/// may be merged with another. Both of these operations are relatively expensive to perform, and
-/// it's possible to force one to occur at every single level of the tree in a single insertion or
-/// deletion. In fact, a malicious or otherwise unlucky sequence of insertions and deletions can
-/// force this degenerate behaviour to occur on every operation. While the total amount of work
-/// done on each operation isn't *catastrophic*, and *is* still bounded by O(B log<sub>B</sub>n),
-/// it is certainly much slower when it does.
+/// however, performance is excellent.
 #[derive(Clone)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct BTreeMap<K, V> {
     root: Node<K, V>,
-    length: uint,
-    depth: uint,
-    b: uint,
+    length: usize,
+    depth: usize,
+    b: usize,
 }
 
 /// An abstract base over-which all other BTree iterators are built.
 struct AbsIter<T> {
     traversals: RingBuf<T>,
-    size: uint,
+    size: usize,
 }
 
 /// An iterator over a BTreeMap's entries.
@@ -171,7 +155,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
     /// Makes a new empty BTreeMap with the given B.
     ///
     /// B cannot be less than 2.
-    pub fn with_b(b: uint) -> BTreeMap<K, V> {
+    pub fn with_b(b: usize) -> BTreeMap<K, V> {
         assert!(b > 1, "B must be greater than 1");
         BTreeMap {
             length: 0,
@@ -1001,7 +985,7 @@ impl<K, V, E, T> Iterator for AbsIter<T> where
         }
     }
 
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         (self.size, Some(self.size))
     }
 }
@@ -1038,7 +1022,7 @@ impl<'a, K, V> Iterator for Iter<'a, K, V> {
     type Item = (&'a K, &'a V);
 
     fn next(&mut self) -> Option<(&'a K, &'a V)> { self.inner.next() }
-    fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V> {
@@ -1052,7 +1036,7 @@ impl<'a, K, V> Iterator for IterMut<'a, K, V> {
     type Item = (&'a K, &'a mut V);
 
     fn next(&mut self) -> Option<(&'a K, &'a mut V)> { self.inner.next() }
-    fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, K, V> DoubleEndedIterator for IterMut<'a, K, V> {
@@ -1066,7 +1050,7 @@ impl<K, V> Iterator for IntoIter<K, V> {
     type Item = (K, V);
 
     fn next(&mut self) -> Option<(K, V)> { self.inner.next() }
-    fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<K, V> DoubleEndedIterator for IntoIter<K, V> {
@@ -1080,7 +1064,7 @@ impl<'a, K, V> Iterator for Keys<'a, K, V> {
     type Item = &'a K;
 
     fn next(&mut self) -> Option<(&'a K)> { self.inner.next() }
-    fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {
@@ -1095,7 +1079,7 @@ impl<'a, K, V> Iterator for Values<'a, K, V> {
     type Item = &'a V;
 
     fn next(&mut self) -> Option<(&'a V)> { self.inner.next() }
-    fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
@@ -1283,7 +1267,7 @@ impl<K, V> BTreeMap<K, V> {
     /// a.insert(1u, "a");
     /// a.insert(2u, "b");
     ///
-    /// let keys: Vec<uint> = a.keys().cloned().collect();
+    /// let keys: Vec<usize> = a.keys().cloned().collect();
     /// assert_eq!(keys, vec![1u,2,]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -1329,7 +1313,7 @@ impl<K, V> BTreeMap<K, V> {
     /// assert_eq!(a.len(), 1);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> uint { self.length }
+    pub fn len(&self) -> usize { self.length }
 
     /// Return true if the map contains no elements.
     ///
@@ -1540,7 +1524,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
     /// use std::collections::BTreeMap;
     /// use std::collections::btree_map::Entry;
     ///
-    /// let mut count: BTreeMap<&str, uint> = BTreeMap::new();
+    /// let mut count: BTreeMap<&str, usize> = BTreeMap::new();
     ///
     /// // count the number of occurrences of letters in the vec
     /// for x in vec!["a","b","a","c","a","b"].iter() {
@@ -1614,7 +1598,7 @@ mod test {
     #[test]
     fn test_basic_large() {
         let mut map = BTreeMap::new();
-        let size = 10000u;
+        let size = 10000;
         assert_eq!(map.len(), 0);
 
         for i in 0..size {
@@ -1661,7 +1645,7 @@ mod test {
         let mut map = BTreeMap::new();
         assert_eq!(map.remove(&1), None);
         assert_eq!(map.get(&1), None);
-        assert_eq!(map.insert(1u, 1u), None);
+        assert_eq!(map.insert(1, 1), None);
         assert_eq!(map.get(&1), Some(&1));
         assert_eq!(map.insert(1, 2), Some(1));
         assert_eq!(map.get(&1), Some(&2));
@@ -1674,12 +1658,12 @@ mod test {
 
     #[test]
     fn test_iter() {
-        let size = 10000u;
+        let size = 10000;
 
         // Forwards
-        let mut map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+        let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
 
-        fn test<T>(size: uint, mut iter: T) where T: Iterator<Item=(uint, uint)> {
+        fn test<T>(size: usize, mut iter: T) where T: Iterator<Item=(usize, usize)> {
             for i in 0..size {
                 assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
                 assert_eq!(iter.next().unwrap(), (i, i));
@@ -1694,12 +1678,12 @@ mod test {
 
     #[test]
     fn test_iter_rev() {
-        let size = 10000u;
+        let size = 10000;
 
         // Forwards
-        let mut map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+        let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
 
-        fn test<T>(size: uint, mut iter: T) where T: Iterator<Item=(uint, uint)> {
+        fn test<T>(size: usize, mut iter: T) where T: Iterator<Item=(usize, usize)> {
             for i in 0..size {
                 assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
                 assert_eq!(iter.next().unwrap(), (size - i - 1, size - i - 1));
@@ -1714,13 +1698,13 @@ mod test {
 
     #[test]
     fn test_iter_mixed() {
-        let size = 10000u;
+        let size = 10000;
 
         // Forwards
-        let mut map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+        let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
 
-        fn test<T>(size: uint, mut iter: T)
-                where T: Iterator<Item=(uint, uint)> + DoubleEndedIterator {
+        fn test<T>(size: usize, mut iter: T)
+                where T: Iterator<Item=(usize, usize)> + DoubleEndedIterator {
             for i in 0..size / 4 {
                 assert_eq!(iter.size_hint(), (size - i * 2, Some(size - i * 2)));
                 assert_eq!(iter.next().unwrap(), (i, i));
@@ -1740,13 +1724,13 @@ mod test {
 
     #[test]
     fn test_range_small() {
-        let size = 5u;
+        let size = 5;
 
         // Forwards
-        let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+        let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
 
-        let mut j = 0u;
-        for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(2u..size) {
+        let mut j = 0;
+        for ((&k, &v), i) in map.range(Included(&2), Unbounded).zip(2..size) {
             assert_eq!(k, i);
             assert_eq!(v, i);
             j += 1;
@@ -1756,10 +1740,10 @@ mod test {
 
     #[test]
     fn test_range_1000() {
-        let size = 1000u;
-        let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+        let size = 1000;
+        let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
 
-        fn test(map: &BTreeMap<uint, uint>, size: uint, min: Bound<&uint>, max: Bound<&uint>) {
+        fn test(map: &BTreeMap<u32, u32>, size: u32, min: Bound<&u32>, max: Bound<&u32>) {
             let mut kvs = map.range(min, max).map(|(&k, &v)| (k, v));
             let mut pairs = (0..size).map(|i| (i, i));
 
@@ -1779,8 +1763,8 @@ mod test {
 
     #[test]
     fn test_range() {
-        let size = 200u;
-        let map: BTreeMap<uint, uint> = (0..size).map(|i| (i, i)).collect();
+        let size = 200;
+        let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
 
         for i in 0..size {
             for j in i..size {
@@ -1800,7 +1784,7 @@ mod test {
     fn test_entry(){
         let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
 
-        let mut map: BTreeMap<int, int> = xs.iter().map(|&x| x).collect();
+        let mut map: BTreeMap<_, _> = xs.iter().map(|&x| x).collect();
 
         // Existing key (insert)
         match map.entry(1) {
@@ -1864,7 +1848,7 @@ mod bench {
 
     #[bench]
     pub fn insert_rand_100(b: &mut Bencher) {
-        let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+        let mut m = BTreeMap::new();
         insert_rand_n(100, &mut m, b,
                       |m, i| { m.insert(i, 1); },
                       |m, i| { m.remove(&i); });
@@ -1872,7 +1856,7 @@ mod bench {
 
     #[bench]
     pub fn insert_rand_10_000(b: &mut Bencher) {
-        let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+        let mut m = BTreeMap::new();
         insert_rand_n(10_000, &mut m, b,
                       |m, i| { m.insert(i, 1); },
                       |m, i| { m.remove(&i); });
@@ -1881,7 +1865,7 @@ mod bench {
     // Insert seq
     #[bench]
     pub fn insert_seq_100(b: &mut Bencher) {
-        let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+        let mut m = BTreeMap::new();
         insert_seq_n(100, &mut m, b,
                      |m, i| { m.insert(i, 1); },
                      |m, i| { m.remove(&i); });
@@ -1889,7 +1873,7 @@ mod bench {
 
     #[bench]
     pub fn insert_seq_10_000(b: &mut Bencher) {
-        let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+        let mut m = BTreeMap::new();
         insert_seq_n(10_000, &mut m, b,
                      |m, i| { m.insert(i, 1); },
                      |m, i| { m.remove(&i); });
@@ -1898,7 +1882,7 @@ mod bench {
     // Find rand
     #[bench]
     pub fn find_rand_100(b: &mut Bencher) {
-        let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+        let mut m = BTreeMap::new();
         find_rand_n(100, &mut m, b,
                     |m, i| { m.insert(i, 1); },
                     |m, i| { m.get(&i); });
@@ -1906,7 +1890,7 @@ mod bench {
 
     #[bench]
     pub fn find_rand_10_000(b: &mut Bencher) {
-        let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+        let mut m = BTreeMap::new();
         find_rand_n(10_000, &mut m, b,
                     |m, i| { m.insert(i, 1); },
                     |m, i| { m.get(&i); });
@@ -1915,7 +1899,7 @@ mod bench {
     // Find seq
     #[bench]
     pub fn find_seq_100(b: &mut Bencher) {
-        let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+        let mut m = BTreeMap::new();
         find_seq_n(100, &mut m, b,
                    |m, i| { m.insert(i, 1); },
                    |m, i| { m.get(&i); });
@@ -1923,14 +1907,14 @@ mod bench {
 
     #[bench]
     pub fn find_seq_10_000(b: &mut Bencher) {
-        let mut m : BTreeMap<uint,uint> = BTreeMap::new();
+        let mut m = BTreeMap::new();
         find_seq_n(10_000, &mut m, b,
                    |m, i| { m.insert(i, 1); },
                    |m, i| { m.get(&i); });
     }
 
-    fn bench_iter(b: &mut Bencher, size: uint) {
-        let mut map = BTreeMap::<uint, uint>::new();
+    fn bench_iter(b: &mut Bencher, size: i32) {
+        let mut map = BTreeMap::<i32, i32>::new();
         let mut rng = weak_rng();
 
         for _ in 0..size {
diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs
index 7f6eee343b9..bfe74cc6fb4 100644
--- a/src/libcollections/btree/node.rs
+++ b/src/libcollections/btree/node.rs
@@ -65,7 +65,7 @@ pub struct Node<K, V> {
     //
     // Note: instead of accessing this field directly, please call the `len()` method, which should
     // be more stable in the face of representation changes.
-    _len: uint,
+    _len: usize,
 
     // FIXME(gereeter) It shouldn't be necessary to store the capacity in every node, as it should
     // be constant throughout the tree. Once a solution to this is found, it might be possible to
@@ -74,7 +74,7 @@ pub struct Node<K, V> {
     //
     // Note: instead of accessing this field directly, please call the `capacity()` method, which
     // should be more stable in the face of representation changes.
-    _capacity: uint,
+    _capacity: usize,
 }
 
 struct NodeSlice<'a, K: 'a, V: 'a> {
@@ -102,7 +102,7 @@ struct MutNodeSlice<'a, K: 'a, V: 'a> {
 ///
 /// Fails if `target_alignment` is not a power of two.
 #[inline]
-fn round_up_to_next(unrounded: uint, target_alignment: uint) -> uint {
+fn round_up_to_next(unrounded: usize, target_alignment: usize) -> usize {
     assert!(num::UnsignedInt::is_power_of_two(target_alignment));
     (unrounded + target_alignment - 1) & !(target_alignment - 1)
 }
@@ -120,10 +120,10 @@ fn test_rounding() {
 // Returns a tuple of (val_offset, edge_offset),
 // from the start of a mallocated array.
 #[inline]
-fn calculate_offsets(keys_size: uint,
-                     vals_size: uint, vals_align: uint,
-                     edges_align: uint)
-                     -> (uint, uint) {
+fn calculate_offsets(keys_size: usize,
+                     vals_size: usize, vals_align: usize,
+                     edges_align: usize)
+                     -> (usize, usize) {
     let vals_offset = round_up_to_next(keys_size, vals_align);
     let end_of_vals = vals_offset + vals_size;
 
@@ -135,10 +135,10 @@ fn calculate_offsets(keys_size: uint,
 // Returns a tuple of (minimum required alignment, array_size),
 // from the start of a mallocated array.
 #[inline]
-fn calculate_allocation(keys_size: uint, keys_align: uint,
-                        vals_size: uint, vals_align: uint,
-                        edges_size: uint, edges_align: uint)
-                        -> (uint, uint) {
+fn calculate_allocation(keys_size: usize, keys_align: usize,
+                        vals_size: usize, vals_align: usize,
+                        edges_size: usize, edges_align: usize)
+                        -> (usize, usize) {
     let (_, edges_offset) = calculate_offsets(keys_size,
                                               vals_size, vals_align,
                                                          edges_align);
@@ -159,7 +159,7 @@ fn test_offset_calculation() {
     assert_eq!(calculate_offsets(6, 12, 4, 8), (8, 24));
 }
 
-fn calculate_allocation_generic<K, V>(capacity: uint, is_leaf: bool) -> (uint, uint) {
+fn calculate_allocation_generic<K, V>(capacity: usize, is_leaf: bool) -> (usize, usize) {
     let (keys_size, keys_align) = (capacity * mem::size_of::<K>(), mem::min_align_of::<K>());
     let (vals_size, vals_align) = (capacity * mem::size_of::<V>(), mem::min_align_of::<V>());
     let (edges_size, edges_align) = if is_leaf {
@@ -175,7 +175,7 @@ fn calculate_allocation_generic<K, V>(capacity: uint, is_leaf: bool) -> (uint, u
     )
 }
 
-fn calculate_offsets_generic<K, V>(capacity: uint, is_leaf: bool) -> (uint, uint) {
+fn calculate_offsets_generic<K, V>(capacity: usize, is_leaf: bool) -> (usize, usize) {
     let keys_size = capacity * mem::size_of::<K>();
     let vals_size = capacity * mem::size_of::<V>();
     let vals_align = mem::min_align_of::<V>();
@@ -203,16 +203,16 @@ impl<T> RawItems<T> {
         RawItems::from_parts(slice.as_ptr(), slice.len())
     }
 
-    unsafe fn from_parts(ptr: *const T, len: uint) -> RawItems<T> {
+    unsafe fn from_parts(ptr: *const T, len: usize) -> RawItems<T> {
         if mem::size_of::<T>() == 0 {
             RawItems {
                 head: ptr,
-                tail: (ptr as uint + len) as *const T,
+                tail: (ptr as usize + len) as *const T,
             }
         } else {
             RawItems {
                 head: ptr,
-                tail: ptr.offset(len as int),
+                tail: ptr.offset(len as isize),
             }
         }
     }
@@ -221,7 +221,7 @@ impl<T> RawItems<T> {
         ptr::write(self.tail as *mut T, val);
 
         if mem::size_of::<T>() == 0 {
-            self.tail = (self.tail as uint + 1) as *const T;
+            self.tail = (self.tail as usize + 1) as *const T;
         } else {
             self.tail = self.tail.offset(1);
         }
@@ -239,7 +239,7 @@ impl<T> Iterator for RawItems<T> {
                 let ret = Some(ptr::read(self.head));
 
                 if mem::size_of::<T>() == 0 {
-                    self.head = (self.head as uint + 1) as *const T;
+                    self.head = (self.head as usize + 1) as *const T;
                 } else {
                     self.head = self.head.offset(1);
                 }
@@ -257,7 +257,7 @@ impl<T> DoubleEndedIterator for RawItems<T> {
         } else {
             unsafe {
                 if mem::size_of::<T>() == 0 {
-                    self.tail = (self.tail as uint - 1) as *const T;
+                    self.tail = (self.tail as usize - 1) as *const T;
                 } else {
                     self.tail = self.tail.offset(-1);
                 }
@@ -299,7 +299,7 @@ impl<K, V> Drop for Node<K, V> {
 impl<K, V> Node<K, V> {
     /// Make a new internal node. The caller must initialize the result to fix the invariant that
     /// there are `len() + 1` edges.
-    unsafe fn new_internal(capacity: uint) -> Node<K, V> {
+    unsafe fn new_internal(capacity: usize) -> Node<K, V> {
         let (alignment, size) = calculate_allocation_generic::<K, V>(capacity, false);
 
         let buffer = heap::allocate(size, alignment);
@@ -309,15 +309,15 @@ impl<K, V> Node<K, V> {
 
         Node {
             keys: Unique(buffer as *mut K),
-            vals: Unique(buffer.offset(vals_offset as int) as *mut V),
-            edges: Unique(buffer.offset(edges_offset as int) as *mut Node<K, V>),
+            vals: Unique(buffer.offset(vals_offset as isize) as *mut V),
+            edges: Unique(buffer.offset(edges_offset as isize) as *mut Node<K, V>),
             _len: 0,
             _capacity: capacity,
         }
     }
 
     /// Make a new leaf node
-    fn new_leaf(capacity: uint) -> Node<K, V> {
+    fn new_leaf(capacity: usize) -> Node<K, V> {
         let (alignment, size) = calculate_allocation_generic::<K, V>(capacity, true);
 
         let buffer = unsafe { heap::allocate(size, alignment) };
@@ -327,7 +327,7 @@ impl<K, V> Node<K, V> {
 
         Node {
             keys: Unique(buffer as *mut K),
-            vals: Unique(unsafe { buffer.offset(vals_offset as int) as *mut V }),
+            vals: Unique(unsafe { buffer.offset(vals_offset as isize) as *mut V }),
             edges: Unique(ptr::null_mut()),
             _len: 0,
             _capacity: capacity,
@@ -479,15 +479,15 @@ impl<K: Clone, V: Clone> Clone for Node<K, V> {
 ///
 /// ```rust,ignore
 /// struct Nasty<'a> {
-///     first: &'a Node<uint, uint>,
-///     second: &'a Node<uint, uint>,
+///     first: &'a Node<usize, usize>,
+///     second: &'a Node<usize, usize>,
 ///     flag: &'a Cell<bool>,
 /// }
 ///
 /// impl<'a> Deref for Nasty<'a> {
-///     type Target = Node<uint, uint>;
+///     type Target = Node<usize, usize>;
 ///
-///     fn deref(&self) -> &Node<uint, uint> {
+///     fn deref(&self) -> &Node<usize, usize> {
 ///         if self.flag.get() {
 ///             &*self.second
 ///         } else {
@@ -524,7 +524,7 @@ impl<K: Clone, V: Clone> Clone for Node<K, V> {
 #[derive(Copy)]
 pub struct Handle<NodeRef, Type, NodeType> {
     node: NodeRef,
-    index: uint
+    index: usize
 }
 
 pub mod handle {
@@ -546,7 +546,7 @@ impl<K: Ord, V> Node<K, V> {
                   -> SearchResult<NodeRef> where Q: BorrowFrom<K> + Ord {
         // FIXME(Gankro): Tune when to search linear or binary based on B (and maybe K/V).
         // For the B configured as of this writing (B = 6), binary search was *significantly*
-        // worse for uints.
+        // worse for usizes.
         match node.as_slices_internal().search_linear(key) {
             (index, true) => Found(Handle { node: node, index: index }),
             (index, false) => GoDown(Handle { node: node, index: index }),
@@ -557,12 +557,12 @@ impl<K: Ord, V> Node<K, V> {
 // Public interface
 impl <K, V> Node<K, V> {
     /// Make a leaf root from scratch
-    pub fn make_leaf_root(b: uint) -> Node<K, V> {
+    pub fn make_leaf_root(b: usize) -> Node<K, V> {
         Node::new_leaf(capacity_from_b(b))
     }
 
     /// Make an internal root and swap it with an old root
-    pub fn make_internal_root(left_and_out: &mut Node<K,V>, b: uint, key: K, value: V,
+    pub fn make_internal_root(left_and_out: &mut Node<K,V>, b: usize, key: K, value: V,
             right: Node<K,V>) {
         let node = mem::replace(left_and_out, unsafe { Node::new_internal(capacity_from_b(b)) });
         left_and_out._len = 1;
@@ -575,12 +575,12 @@ impl <K, V> Node<K, V> {
     }
 
     /// How many key-value pairs the node contains
-    pub fn len(&self) -> uint {
+    pub fn len(&self) -> usize {
         self._len
     }
 
     /// How many key-value pairs the node can fit
-    pub fn capacity(&self) -> uint {
+    pub fn capacity(&self) -> usize {
         self._capacity
     }
 
@@ -1038,7 +1038,7 @@ impl<K, V> Node<K, V> {
     /// # Panics (in debug build)
     ///
     /// Panics if the given index is out of bounds.
-    pub fn kv_handle(&mut self, index: uint) -> Handle<&mut Node<K, V>, handle::KV,
+    pub fn kv_handle(&mut self, index: usize) -> Handle<&mut Node<K, V>, handle::KV,
                                                        handle::LeafOrInternal> {
         // Necessary for correctness, but in a private module
         debug_assert!(index < self.len(), "kv_handle index out of bounds");
@@ -1114,15 +1114,15 @@ impl<K, V> Node<K, V> {
 
     // This must be followed by insert_edge on an internal node.
     #[inline]
-    unsafe fn insert_kv(&mut self, index: uint, key: K, val: V) -> &mut V {
+    unsafe fn insert_kv(&mut self, index: usize, key: K, val: V) -> &mut V {
         ptr::copy_memory(
-            self.keys_mut().as_mut_ptr().offset(index as int + 1),
-            self.keys().as_ptr().offset(index as int),
+            self.keys_mut().as_mut_ptr().offset(index as isize + 1),
+            self.keys().as_ptr().offset(index as isize),
             self.len() - index
         );
         ptr::copy_memory(
-            self.vals_mut().as_mut_ptr().offset(index as int + 1),
-            self.vals().as_ptr().offset(index as int),
+            self.vals_mut().as_mut_ptr().offset(index as isize + 1),
+            self.vals().as_ptr().offset(index as isize),
             self.len() - index
         );
 
@@ -1136,10 +1136,10 @@ impl<K, V> Node<K, V> {
 
     // This can only be called immediately after a call to insert_kv.
     #[inline]
-    unsafe fn insert_edge(&mut self, index: uint, edge: Node<K, V>) {
+    unsafe fn insert_edge(&mut self, index: usize, edge: Node<K, V>) {
         ptr::copy_memory(
-            self.edges_mut().as_mut_ptr().offset(index as int + 1),
-            self.edges().as_ptr().offset(index as int),
+            self.edges_mut().as_mut_ptr().offset(index as isize + 1),
+            self.edges().as_ptr().offset(index as isize),
             self.len() - index
         );
         ptr::write(self.edges_mut().get_unchecked_mut(index), edge);
@@ -1166,18 +1166,18 @@ impl<K, V> Node<K, V> {
 
     // This must be followed by remove_edge on an internal node.
     #[inline]
-    unsafe fn remove_kv(&mut self, index: uint) -> (K, V) {
+    unsafe fn remove_kv(&mut self, index: usize) -> (K, V) {
         let key = ptr::read(self.keys().get_unchecked(index));
         let val = ptr::read(self.vals().get_unchecked(index));
 
         ptr::copy_memory(
-            self.keys_mut().as_mut_ptr().offset(index as int),
-            self.keys().as_ptr().offset(index as int + 1),
+            self.keys_mut().as_mut_ptr().offset(index as isize),
+            self.keys().as_ptr().offset(index as isize + 1),
             self.len() - index - 1
         );
         ptr::copy_memory(
-            self.vals_mut().as_mut_ptr().offset(index as int),
-            self.vals().as_ptr().offset(index as int + 1),
+            self.vals_mut().as_mut_ptr().offset(index as isize),
+            self.vals().as_ptr().offset(index as isize + 1),
             self.len() - index - 1
         );
 
@@ -1188,12 +1188,12 @@ impl<K, V> Node<K, V> {
 
     // This can only be called immediately after a call to remove_kv.
     #[inline]
-    unsafe fn remove_edge(&mut self, index: uint) -> Node<K, V> {
+    unsafe fn remove_edge(&mut self, index: usize) -> Node<K, V> {
         let edge = ptr::read(self.edges().get_unchecked(index));
 
         ptr::copy_memory(
-            self.edges_mut().as_mut_ptr().offset(index as int),
-            self.edges().as_ptr().offset(index as int + 1),
+            self.edges_mut().as_mut_ptr().offset(index as isize),
+            self.edges().as_ptr().offset(index as isize + 1),
             self.len() - index + 1
         );
 
@@ -1220,18 +1220,18 @@ impl<K, V> Node<K, V> {
             let right_offset = self.len() - right.len();
             ptr::copy_nonoverlapping_memory(
                 right.keys_mut().as_mut_ptr(),
-                self.keys().as_ptr().offset(right_offset as int),
+                self.keys().as_ptr().offset(right_offset as isize),
                 right.len()
             );
             ptr::copy_nonoverlapping_memory(
                 right.vals_mut().as_mut_ptr(),
-                self.vals().as_ptr().offset(right_offset as int),
+                self.vals().as_ptr().offset(right_offset as isize),
                 right.len()
             );
             if !self.is_leaf() {
                 ptr::copy_nonoverlapping_memory(
                     right.edges_mut().as_mut_ptr(),
-                    self.edges().as_ptr().offset(right_offset as int),
+                    self.edges().as_ptr().offset(right_offset as isize),
                     right.len() + 1
                 );
             }
@@ -1260,18 +1260,18 @@ impl<K, V> Node<K, V> {
             ptr::write(self.vals_mut().get_unchecked_mut(old_len), val);
 
             ptr::copy_nonoverlapping_memory(
-                self.keys_mut().as_mut_ptr().offset(old_len as int + 1),
+                self.keys_mut().as_mut_ptr().offset(old_len as isize + 1),
                 right.keys().as_ptr(),
                 right.len()
             );
             ptr::copy_nonoverlapping_memory(
-                self.vals_mut().as_mut_ptr().offset(old_len as int + 1),
+                self.vals_mut().as_mut_ptr().offset(old_len as isize + 1),
                 right.vals().as_ptr(),
                 right.len()
             );
             if !self.is_leaf() {
                 ptr::copy_nonoverlapping_memory(
-                    self.edges_mut().as_mut_ptr().offset(old_len as int + 1),
+                    self.edges_mut().as_mut_ptr().offset(old_len as isize + 1),
                     right.edges().as_ptr(),
                     right.len() + 1
                 );
@@ -1284,12 +1284,12 @@ impl<K, V> Node<K, V> {
 }
 
 /// Get the capacity of a node from the order of the parent B-Tree
-fn capacity_from_b(b: uint) -> uint {
+fn capacity_from_b(b: usize) -> usize {
     2 * b - 1
 }
 
 /// Get the minimum load of a node from its capacity
-fn min_load_from_capacity(cap: uint) -> uint {
+fn min_load_from_capacity(cap: usize) -> usize {
     // B - 1
     cap / 2
 }
@@ -1334,7 +1334,7 @@ struct MoveTraversalImpl<K, V> {
 
     // For deallocation when we are done iterating.
     ptr: *mut u8,
-    capacity: uint,
+    capacity: usize,
     is_leaf: bool
 }
 
@@ -1490,7 +1490,7 @@ macro_rules! node_slice_impl {
      $as_slices_internal:ident, $index:ident, $iter:ident) => {
         impl<'a, K: Ord + 'a, V: 'a> $NodeSlice<'a, K, V> {
             /// Performs linear search in a slice. Returns a tuple of (index, is_exact_match).
-            fn search_linear<Q: ?Sized>(&self, key: &Q) -> (uint, bool)
+            fn search_linear<Q: ?Sized>(&self, key: &Q) -> (usize, bool)
                     where Q: BorrowFrom<K> + Ord {
                 for (i, k) in self.keys.iter().enumerate() {
                     match key.cmp(BorrowFrom::borrow_from(k)) {
diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs
index 1997fe189be..b02c522f86d 100644
--- a/src/libcollections/btree/set.rs
+++ b/src/libcollections/btree/set.rs
@@ -101,7 +101,7 @@ impl<T: Ord> BTreeSet<T> {
     /// B cannot be less than 2.
     #[unstable(feature = "collections",
                reason = "probably want this to be on the type, eventually")]
-    pub fn with_b(b: uint) -> BTreeSet<T> {
+    pub fn with_b(b: usize) -> BTreeSet<T> {
         BTreeSet { map: BTreeMap::with_b(b) }
     }
 }
@@ -114,13 +114,13 @@ impl<T> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let set: BTreeSet<uint> = [1u, 2, 3, 4].iter().map(|&x| x).collect();
+    /// let set: BTreeSet<usize> = [1u, 2, 3, 4].iter().map(|&x| x).collect();
     ///
     /// for x in set.iter() {
     ///     println!("{}", x);
     /// }
     ///
-    /// let v: Vec<uint> = set.iter().map(|&x| x).collect();
+    /// let v: Vec<usize> = set.iter().map(|&x| x).collect();
     /// assert_eq!(v, vec![1u,2,3,4]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -135,9 +135,9 @@ impl<T> BTreeSet<T> {
     /// ```
     /// use std::collections::BTreeSet;
     ///
-    /// let set: BTreeSet<uint> = [1u, 2, 3, 4].iter().map(|&x| x).collect();
+    /// let set: BTreeSet<usize> = [1u, 2, 3, 4].iter().map(|&x| x).collect();
     ///
-    /// let v: Vec<uint> = set.into_iter().collect();
+    /// let v: Vec<usize> = set.into_iter().collect();
     /// assert_eq!(v, vec![1u,2,3,4]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -196,7 +196,7 @@ impl<T: Ord> BTreeSet<T> {
     /// b.insert(2u);
     /// b.insert(3u);
     ///
-    /// let diff: Vec<uint> = a.difference(&b).cloned().collect();
+    /// let diff: Vec<usize> = a.difference(&b).cloned().collect();
     /// assert_eq!(diff, vec![1u]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -219,7 +219,7 @@ impl<T: Ord> BTreeSet<T> {
     /// b.insert(2u);
     /// b.insert(3u);
     ///
-    /// let sym_diff: Vec<uint> = a.symmetric_difference(&b).cloned().collect();
+    /// let sym_diff: Vec<usize> = a.symmetric_difference(&b).cloned().collect();
     /// assert_eq!(sym_diff, vec![1u,3]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -243,7 +243,7 @@ impl<T: Ord> BTreeSet<T> {
     /// b.insert(2u);
     /// b.insert(3u);
     ///
-    /// let intersection: Vec<uint> = a.intersection(&b).cloned().collect();
+    /// let intersection: Vec<usize> = a.intersection(&b).cloned().collect();
     /// assert_eq!(intersection, vec![2u]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -265,7 +265,7 @@ impl<T: Ord> BTreeSet<T> {
     /// let mut b = BTreeSet::new();
     /// b.insert(2u);
     ///
-    /// let union: Vec<uint> = a.union(&b).cloned().collect();
+    /// let union: Vec<usize> = a.union(&b).cloned().collect();
     /// assert_eq!(union, vec![1u,2]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -286,7 +286,7 @@ impl<T: Ord> BTreeSet<T> {
     /// assert_eq!(v.len(), 1);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> uint { self.map.len() }
+    pub fn len(&self) -> usize { self.map.len() }
 
     /// Returns true if the set contains no elements
     ///
@@ -625,7 +625,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
     type Item = &'a T;
 
     fn next(&mut self) -> Option<&'a T> { self.iter.next() }
-    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
@@ -640,7 +640,7 @@ impl<T> Iterator for IntoIter<T> {
     type Item = T;
 
     fn next(&mut self) -> Option<T> { self.iter.next() }
-    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> DoubleEndedIterator for IntoIter<T> {
@@ -770,23 +770,23 @@ mod test {
     }
 
     struct Counter<'a, 'b> {
-        i: &'a mut uint,
-        expected: &'b [int],
+        i: &'a mut usize,
+        expected: &'b [i32],
     }
 
-    impl<'a, 'b, 'c> FnMut<(&'c int,)> for Counter<'a, 'b> {
+    impl<'a, 'b, 'c> FnMut<(&'c i32,)> for Counter<'a, 'b> {
         type Output = bool;
 
-        extern "rust-call" fn call_mut(&mut self, (&x,): (&'c int,)) -> bool {
+        extern "rust-call" fn call_mut(&mut self, (&x,): (&'c i32,)) -> bool {
             assert_eq!(x, self.expected[*self.i]);
             *self.i += 1;
             true
         }
     }
 
-    fn check<F>(a: &[int], b: &[int], expected: &[int], f: F) where
+    fn check<F>(a: &[i32], b: &[i32], expected: &[i32], f: F) where
         // FIXME Replace Counter with `Box<FnMut(_) -> _>`
-        F: FnOnce(&BTreeSet<int>, &BTreeSet<int>, Counter) -> bool,
+        F: FnOnce(&BTreeSet<i32>, &BTreeSet<i32>, Counter) -> bool,
     {
         let mut set_a = BTreeSet::new();
         let mut set_b = BTreeSet::new();
@@ -801,7 +801,7 @@ mod test {
 
     #[test]
     fn test_intersection() {
-        fn check_intersection(a: &[int], b: &[int], expected: &[int]) {
+        fn check_intersection(a: &[i32], b: &[i32], expected: &[i32]) {
             check(a, b, expected, |x, y, f| x.intersection(y).all(f))
         }
 
@@ -817,7 +817,7 @@ mod test {
 
     #[test]
     fn test_difference() {
-        fn check_difference(a: &[int], b: &[int], expected: &[int]) {
+        fn check_difference(a: &[i32], b: &[i32], expected: &[i32]) {
             check(a, b, expected, |x, y, f| x.difference(y).all(f))
         }
 
@@ -834,8 +834,7 @@ mod test {
 
     #[test]
     fn test_symmetric_difference() {
-        fn check_symmetric_difference(a: &[int], b: &[int],
-                                      expected: &[int]) {
+        fn check_symmetric_difference(a: &[i32], b: &[i32], expected: &[i32]) {
             check(a, b, expected, |x, y, f| x.symmetric_difference(y).all(f))
         }
 
@@ -849,8 +848,7 @@ mod test {
 
     #[test]
     fn test_union() {
-        fn check_union(a: &[int], b: &[int],
-                                      expected: &[int]) {
+        fn check_union(a: &[i32], b: &[i32], expected: &[i32]) {
             check(a, b, expected, |x, y, f| x.union(y).all(f))
         }
 
@@ -865,9 +863,9 @@ mod test {
     #[test]
     fn test_zip() {
         let mut x = BTreeSet::new();
-        x.insert(5u);
-        x.insert(12u);
-        x.insert(11u);
+        x.insert(5);
+        x.insert(12);
+        x.insert(11);
 
         let mut y = BTreeSet::new();
         y.insert("foo");
@@ -878,13 +876,13 @@ mod test {
         let mut z = x.iter().zip(y.iter());
 
         // FIXME: #5801: this needs a type hint to compile...
-        let result: Option<(&uint, & &'static str)> = z.next();
-        assert_eq!(result.unwrap(), (&5u, &("bar")));
+        let result: Option<(&usize, & &'static str)> = z.next();
+        assert_eq!(result.unwrap(), (&5, &("bar")));
 
-        let result: Option<(&uint, & &'static str)> = z.next();
-        assert_eq!(result.unwrap(), (&11u, &("foo")));
+        let result: Option<(&usize, & &'static str)> = z.next();
+        assert_eq!(result.unwrap(), (&11, &("foo")));
 
-        let result: Option<(&uint, & &'static str)> = z.next();
+        let result: Option<(&usize, & &'static str)> = z.next();
         assert!(result.is_none());
     }
 
diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
index d93e61b91f2..748230c5d24 100644
--- a/src/libcollections/dlist.rs
+++ b/src/libcollections/dlist.rs
@@ -35,7 +35,7 @@ use core::ptr;
 /// A doubly-linked list.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct DList<T> {
-    length: uint,
+    length: usize,
     list_head: Link<T>,
     list_tail: Rawlink<Node<T>>,
 }
@@ -61,7 +61,7 @@ struct Node<T> {
 pub struct Iter<'a, T:'a> {
     head: &'a Link<T>,
     tail: Rawlink<Node<T>>,
-    nelem: uint,
+    nelem: usize,
 }
 
 // FIXME #19839: deriving is too aggressive on the bounds (T doesn't need to be Clone).
@@ -82,7 +82,7 @@ pub struct IterMut<'a, T:'a> {
     list: &'a mut DList<T>,
     head: Rawlink<Node<T>>,
     tail: Rawlink<Node<T>>,
-    nelem: uint,
+    nelem: usize,
 }
 
 /// An iterator over mutable references to the items of a `DList`.
@@ -345,7 +345,7 @@ impl<T> DList<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> uint {
+    pub fn len(&self) -> usize {
         self.length
     }
 
@@ -578,7 +578,7 @@ impl<T> DList<T> {
     /// assert_eq!(splitted.pop_front(), None);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn split_off(&mut self, at: uint) -> DList<T> {
+    pub fn split_off(&mut self, at: usize) -> DList<T> {
         let len = self.len();
         assert!(at < len, "Cannot split off at a nonexistent index");
         if at == 0 {
@@ -659,7 +659,7 @@ impl<'a, A> Iterator for Iter<'a, A> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         (self.nelem, Some(self.nelem))
     }
 }
@@ -701,7 +701,7 @@ impl<'a, A> Iterator for IterMut<'a, A> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         (self.nelem, Some(self.nelem))
     }
 }
@@ -810,7 +810,7 @@ impl<A> Iterator for IntoIter<A> {
     fn next(&mut self) -> Option<A> { self.list.pop_front() }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         (self.list.length, Some(self.list.length))
     }
 }
@@ -935,11 +935,11 @@ mod tests {
     use super::{DList, Node};
 
     pub fn check_links<T>(list: &DList<T>) {
-        let mut len = 0u;
+        let mut len = 0;
         let mut last_ptr: Option<&Node<T>> = None;
         let mut node_ptr: &Node<T>;
         match list.list_head {
-            None => { assert_eq!(0u, list.length); return }
+            None => { assert_eq!(0, list.length); return }
             Some(ref node) => node_ptr = &**node,
         }
         loop {
@@ -968,7 +968,7 @@ mod tests {
 
     #[test]
     fn test_basic() {
-        let mut m: DList<Box<int>> = DList::new();
+        let mut m = DList::new();
         assert_eq!(m.pop_front(), None);
         assert_eq!(m.pop_back(), None);
         assert_eq!(m.pop_front(), None);
@@ -1007,7 +1007,7 @@ mod tests {
     }
 
     #[cfg(test)]
-    fn generate_test() -> DList<int> {
+    fn generate_test() -> DList<i32> {
         list_from(&[0,1,2,3,4,5,6])
     }
 
@@ -1020,7 +1020,7 @@ mod tests {
     fn test_append() {
         // Empty to empty
         {
-            let mut m: DList<int> = DList::new();
+            let mut m = DList::<i32>::new();
             let mut n = DList::new();
             m.append(&mut n);
             check_links(&m);
@@ -1122,7 +1122,7 @@ mod tests {
     fn test_iterator() {
         let m = generate_test();
         for (i, elt) in m.iter().enumerate() {
-            assert_eq!(i as int, *elt);
+            assert_eq!(i as i32, *elt);
         }
         let mut n = DList::new();
         assert_eq!(n.iter().next(), None);
@@ -1170,7 +1170,7 @@ mod tests {
     fn test_rev_iter() {
         let m = generate_test();
         for (i, elt) in m.iter().rev().enumerate() {
-            assert_eq!((6 - i) as int, *elt);
+            assert_eq!((6 - i) as i32, *elt);
         }
         let mut n = DList::new();
         assert_eq!(n.iter().rev().next(), None);
@@ -1187,7 +1187,7 @@ mod tests {
         let mut m = generate_test();
         let mut len = m.len();
         for (i, elt) in m.iter_mut().enumerate() {
-            assert_eq!(i as int, *elt);
+            assert_eq!(i as i32, *elt);
             len -= 1;
         }
         assert_eq!(len, 0);
@@ -1245,14 +1245,14 @@ mod tests {
         }
         check_links(&m);
         assert_eq!(m.len(), 3 + len * 2);
-        assert_eq!(m.into_iter().collect::<Vec<int>>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]);
+        assert_eq!(m.into_iter().collect::<Vec<_>>(), vec![-2,0,1,2,3,4,5,6,7,8,9,0,1]);
     }
 
     #[test]
     fn test_mut_rev_iter() {
         let mut m = generate_test();
         for (i, elt) in m.iter_mut().rev().enumerate() {
-            assert_eq!((6-i) as int, *elt);
+            assert_eq!((6 - i) as i32, *elt);
         }
         let mut n = DList::new();
         assert!(n.iter_mut().rev().next().is_none());
@@ -1268,13 +1268,13 @@ mod tests {
         Thread::scoped(move || {
             check_links(&n);
             let a: &[_] = &[&1,&2,&3];
-            assert_eq!(a, n.iter().collect::<Vec<&int>>());
+            assert_eq!(a, n.iter().collect::<Vec<_>>());
         }).join().ok().unwrap();
     }
 
     #[test]
     fn test_eq() {
-        let mut n: DList<u8> = list_from(&[]);
+        let mut n = list_from(&[]);
         let mut m = list_from(&[]);
         assert!(n == m);
         n.push_front(1);
@@ -1307,7 +1307,7 @@ mod tests {
 
     #[test]
     fn test_ord() {
-        let n: DList<int> = list_from(&[]);
+        let n = list_from(&[]);
         let m = list_from(&[1,2,3]);
         assert!(n < m);
         assert!(m > n);
@@ -1349,7 +1349,7 @@ mod tests {
 
     #[test]
     fn test_fuzz() {
-        for _ in 0u..25 {
+        for _ in 0..25 {
             fuzz_test(3);
             fuzz_test(16);
             fuzz_test(189);
@@ -1358,18 +1358,16 @@ mod tests {
 
     #[test]
     fn test_show() {
-        let list: DList<i32> = (0..10).collect();
+        let list: DList<_> = (0..10).collect();
         assert_eq!(format!("{:?}", list), "DList [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
 
-        let list: DList<&str> = vec!["just", "one", "test", "more"].iter()
-                                                                   .map(|&s| s)
-                                                                   .collect();
+        let list: DList<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
         assert_eq!(format!("{:?}", list), "DList [\"just\", \"one\", \"test\", \"more\"]");
     }
 
     #[cfg(test)]
-    fn fuzz_test(sz: int) {
-        let mut m: DList<int> = DList::new();
+    fn fuzz_test(sz: i32) {
+        let mut m: DList<_> = DList::new();
         let mut v = vec![];
         for i in 0..sz {
             check_links(&m);
@@ -1398,7 +1396,7 @@ mod tests {
 
         check_links(&m);
 
-        let mut i = 0u;
+        let mut i = 0;
         for (a, &b) in m.into_iter().zip(v.iter()) {
             i += 1;
             assert_eq!(a, b);
@@ -1410,13 +1408,13 @@ mod tests {
     fn bench_collect_into(b: &mut test::Bencher) {
         let v = &[0; 64];
         b.iter(|| {
-            let _: DList<int> = v.iter().map(|x| *x).collect();
+            let _: DList<_> = v.iter().cloned().collect();
         })
     }
 
     #[bench]
     fn bench_push_front(b: &mut test::Bencher) {
-        let mut m: DList<int> = DList::new();
+        let mut m: DList<_> = DList::new();
         b.iter(|| {
             m.push_front(0);
         })
@@ -1424,7 +1422,7 @@ mod tests {
 
     #[bench]
     fn bench_push_back(b: &mut test::Bencher) {
-        let mut m: DList<int> = DList::new();
+        let mut m: DList<_> = DList::new();
         b.iter(|| {
             m.push_back(0);
         })
@@ -1432,7 +1430,7 @@ mod tests {
 
     #[bench]
     fn bench_push_back_pop_back(b: &mut test::Bencher) {
-        let mut m: DList<int> = DList::new();
+        let mut m: DList<_> = DList::new();
         b.iter(|| {
             m.push_back(0);
             m.pop_back();
@@ -1441,7 +1439,7 @@ mod tests {
 
     #[bench]
     fn bench_push_front_pop_front(b: &mut test::Bencher) {
-        let mut m: DList<int> = DList::new();
+        let mut m: DList<_> = DList::new();
         b.iter(|| {
             m.push_front(0);
             m.pop_front();
@@ -1451,7 +1449,7 @@ mod tests {
     #[bench]
     fn bench_iter(b: &mut test::Bencher) {
         let v = &[0; 128];
-        let m: DList<int> = v.iter().map(|&x|x).collect();
+        let m: DList<_> = v.iter().cloned().collect();
         b.iter(|| {
             assert!(m.iter().count() == 128);
         })
@@ -1459,7 +1457,7 @@ mod tests {
     #[bench]
     fn bench_iter_mut(b: &mut test::Bencher) {
         let v = &[0; 128];
-        let mut m: DList<int> = v.iter().map(|&x|x).collect();
+        let mut m: DList<_> = v.iter().cloned().collect();
         b.iter(|| {
             assert!(m.iter_mut().count() == 128);
         })
@@ -1467,7 +1465,7 @@ mod tests {
     #[bench]
     fn bench_iter_rev(b: &mut test::Bencher) {
         let v = &[0; 128];
-        let m: DList<int> = v.iter().map(|&x|x).collect();
+        let m: DList<_> = v.iter().cloned().collect();
         b.iter(|| {
             assert!(m.iter().rev().count() == 128);
         })
@@ -1475,7 +1473,7 @@ mod tests {
     #[bench]
     fn bench_iter_mut_rev(b: &mut test::Bencher) {
         let v = &[0; 128];
-        let mut m: DList<int> = v.iter().map(|&x|x).collect();
+        let mut m: DList<_> = v.iter().cloned().collect();
         b.iter(|| {
             assert!(m.iter_mut().rev().count() == 128);
         })
diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs
index 8cbf50d29f2..da146506077 100644
--- a/src/libcollections/enum_set.rs
+++ b/src/libcollections/enum_set.rs
@@ -26,7 +26,7 @@ use core::ops::{Sub, BitOr, BitAnd, BitXor};
 pub struct EnumSet<E> {
     // We must maintain the invariant that no bits are set
     // for which no variant exists
-    bits: uint
+    bits: usize
 }
 
 impl<E> Copy for EnumSet<E> {}
@@ -47,37 +47,37 @@ impl<E:CLike + fmt::Debug> fmt::Debug for EnumSet<E> {
     }
 }
 
-/// An interface for casting C-like enum to uint and back.
+/// An interface for casting C-like enum to usize and back.
 /// A typically implementation is as below.
 ///
 /// ```{rust,ignore}
-/// #[repr(uint)]
+/// #[repr(usize)]
 /// enum Foo {
 ///     A, B, C
 /// }
 ///
 /// impl CLike for Foo {
-///     fn to_uint(&self) -> uint {
-///         *self as uint
+///     fn to_usize(&self) -> usize {
+///         *self as usize
 ///     }
 ///
-///     fn from_uint(v: uint) -> Foo {
+///     fn from_usize(v: usize) -> Foo {
 ///         unsafe { mem::transmute(v) }
 ///     }
 /// }
 /// ```
 pub trait CLike {
-    /// Converts a C-like enum to a `uint`.
-    fn to_uint(&self) -> uint;
-    /// Converts a `uint` to a C-like enum.
-    fn from_uint(uint) -> Self;
+    /// Converts a C-like enum to a `usize`.
+    fn to_usize(&self) -> usize;
+    /// Converts a `usize` to a C-like enum.
+    fn from_usize(usize) -> Self;
 }
 
-fn bit<E:CLike>(e: &E) -> uint {
-    use core::uint;
-    let value = e.to_uint();
-    assert!(value < uint::BITS,
-            "EnumSet only supports up to {} variants.", uint::BITS - 1);
+fn bit<E:CLike>(e: &E) -> usize {
+    use core::usize;
+    let value = e.to_usize();
+    assert!(value < usize::BITS,
+            "EnumSet only supports up to {} variants.", usize::BITS - 1);
     1 << value
 }
 
@@ -92,7 +92,7 @@ impl<E:CLike> EnumSet<E> {
     /// Returns the number of elements in the given `EnumSet`.
     #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
-    pub fn len(&self) -> uint {
+    pub fn len(&self) -> usize {
         self.bits.count_ones()
     }
 
@@ -205,8 +205,8 @@ impl<E:CLike> BitXor for EnumSet<E> {
 
 /// An iterator over an EnumSet
 pub struct Iter<E> {
-    index: uint,
-    bits: uint,
+    index: usize,
+    bits: usize,
 }
 
 // FIXME(#19839) Remove in favor of `#[derive(Clone)]`
@@ -220,7 +220,7 @@ impl<E> Clone for Iter<E> {
 }
 
 impl<E:CLike> Iter<E> {
-    fn new(bits: uint) -> Iter<E> {
+    fn new(bits: usize) -> Iter<E> {
         Iter { index: 0, bits: bits }
     }
 }
@@ -237,13 +237,13 @@ impl<E:CLike> Iterator for Iter<E> {
             self.index += 1;
             self.bits >>= 1;
         }
-        let elem = CLike::from_uint(self.index);
+        let elem = CLike::from_usize(self.index);
         self.index += 1;
         self.bits >>= 1;
         Some(elem)
     }
 
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         let exact = self.bits.count_ones();
         (exact, Some(exact))
     }
@@ -282,17 +282,17 @@ mod test {
     use super::{EnumSet, CLike};
 
     #[derive(Copy, PartialEq, Debug)]
-    #[repr(uint)]
+    #[repr(usize)]
     enum Foo {
         A, B, C
     }
 
     impl CLike for Foo {
-        fn to_uint(&self) -> uint {
-            *self as uint
+        fn to_usize(&self) -> usize {
+            *self as usize
         }
 
-        fn from_uint(v: uint) -> Foo {
+        fn from_usize(v: usize) -> Foo {
             unsafe { mem::transmute(v) }
         }
     }
@@ -486,7 +486,7 @@ mod test {
     fn test_overflow() {
         #[allow(dead_code)]
         #[derive(Copy)]
-        #[repr(uint)]
+        #[repr(usize)]
         enum Bar {
             V00, V01, V02, V03, V04, V05, V06, V07, V08, V09,
             V10, V11, V12, V13, V14, V15, V16, V17, V18, V19,
@@ -498,11 +498,11 @@ mod test {
         }
 
         impl CLike for Bar {
-            fn to_uint(&self) -> uint {
-                *self as uint
+            fn to_usize(&self) -> usize {
+                *self as usize
             }
 
-            fn from_uint(v: uint) -> Bar {
+            fn from_usize(v: usize) -> Bar {
                 unsafe { mem::transmute(v) }
             }
         }
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
index f44141fe0f4..57c799785e8 100644
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@@ -26,7 +26,6 @@
 #![feature(box_syntax)]
 #![feature(core)]
 #![feature(hash)]
-#![feature(int_uint)]
 #![feature(staged_api)]
 #![feature(unboxed_closures)]
 #![feature(unicode)]
diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs
index 18021dea9f2..83828940ab8 100644
--- a/src/libcollections/ring_buf.rs
+++ b/src/libcollections/ring_buf.rs
@@ -32,8 +32,8 @@ use std::cmp;
 
 use alloc::heap;
 
-static INITIAL_CAPACITY: uint = 7u; // 2^3 - 1
-static MINIMUM_CAPACITY: uint = 1u; // 2 - 1
+static INITIAL_CAPACITY: usize = 7; // 2^3 - 1
+static MINIMUM_CAPACITY: usize = 1; // 2 - 1
 
 /// `RingBuf` is a circular buffer, which can be used as a double-ended queue efficiently.
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -44,9 +44,9 @@ pub struct RingBuf<T> {
     // If tail == head the buffer is empty. The length of the ringbuf
     // is defined as the distance between the two.
 
-    tail: uint,
-    head: uint,
-    cap: uint,
+    tail: usize,
+    head: usize,
+    cap: usize,
     ptr: *mut T
 }
 
@@ -59,7 +59,7 @@ unsafe impl<T: Sync> Sync for RingBuf<T> {}
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Clone> Clone for RingBuf<T> {
     fn clone(&self) -> RingBuf<T> {
-        self.iter().map(|t| t.clone()).collect()
+        self.iter().cloned().collect()
     }
 }
 
@@ -99,14 +99,14 @@ impl<T> RingBuf<T> {
 
     /// Moves an element out of the buffer
     #[inline]
-    unsafe fn buffer_read(&mut self, off: uint) -> T {
-        ptr::read(self.ptr.offset(off as int))
+    unsafe fn buffer_read(&mut self, off: usize) -> T {
+        ptr::read(self.ptr.offset(off as isize))
     }
 
     /// Writes an element into the buffer, moving it.
     #[inline]
-    unsafe fn buffer_write(&mut self, off: uint, t: T) {
-        ptr::write(self.ptr.offset(off as int), t);
+    unsafe fn buffer_write(&mut self, off: usize, t: T) {
+        ptr::write(self.ptr.offset(off as isize), t);
     }
 
     /// Returns true iff the buffer is at capacity
@@ -115,31 +115,31 @@ impl<T> RingBuf<T> {
 
     /// Returns the index in the underlying buffer for a given logical element index.
     #[inline]
-    fn wrap_index(&self, idx: uint) -> uint { wrap_index(idx, self.cap) }
+    fn wrap_index(&self, idx: usize) -> usize { wrap_index(idx, self.cap) }
 
     /// Copies a contiguous block of memory len long from src to dst
     #[inline]
-    unsafe fn copy(&self, dst: uint, src: uint, len: uint) {
+    unsafe fn copy(&self, dst: usize, src: usize, len: usize) {
         debug_assert!(dst + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
                       self.cap);
         debug_assert!(src + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
                       self.cap);
         ptr::copy_memory(
-            self.ptr.offset(dst as int),
-            self.ptr.offset(src as int),
+            self.ptr.offset(dst as isize),
+            self.ptr.offset(src as isize),
             len);
     }
 
     /// Copies a contiguous block of memory len long from src to dst
     #[inline]
-    unsafe fn copy_nonoverlapping(&self, dst: uint, src: uint, len: uint) {
+    unsafe fn copy_nonoverlapping(&self, dst: usize, src: usize, len: usize) {
         debug_assert!(dst + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
                       self.cap);
         debug_assert!(src + len <= self.cap, "dst={} src={} len={} cap={}", dst, src, len,
                       self.cap);
         ptr::copy_nonoverlapping_memory(
-            self.ptr.offset(dst as int),
-            self.ptr.offset(src as int),
+            self.ptr.offset(dst as isize),
+            self.ptr.offset(src as isize),
             len);
     }
 }
@@ -153,7 +153,7 @@ impl<T> RingBuf<T> {
 
     /// Creates an empty `RingBuf` with space for at least `n` elements.
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_capacity(n: uint) -> RingBuf<T> {
+    pub fn with_capacity(n: usize) -> RingBuf<T> {
         // +1 since the ringbuffer always leaves one space empty
         let cap = cmp::max(n + 1, MINIMUM_CAPACITY + 1).next_power_of_two();
         assert!(cap > n, "capacity overflow");
@@ -192,10 +192,10 @@ impl<T> RingBuf<T> {
     /// assert_eq!(buf.get(1).unwrap(), &4);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get(&self, i: uint) -> Option<&T> {
+    pub fn get(&self, i: usize) -> Option<&T> {
         if i < self.len() {
             let idx = self.wrap_index(self.tail + i);
-            unsafe { Some(&*self.ptr.offset(idx as int)) }
+            unsafe { Some(&*self.ptr.offset(idx as isize)) }
         } else {
             None
         }
@@ -222,10 +222,10 @@ impl<T> RingBuf<T> {
     /// assert_eq!(buf[1], 7);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get_mut(&mut self, i: uint) -> Option<&mut T> {
+    pub fn get_mut(&mut self, i: usize) -> Option<&mut T> {
         if i < self.len() {
             let idx = self.wrap_index(self.tail + i);
-            unsafe { Some(&mut *self.ptr.offset(idx as int)) }
+            unsafe { Some(&mut *self.ptr.offset(idx as isize)) }
         } else {
             None
         }
@@ -251,13 +251,13 @@ impl<T> RingBuf<T> {
     /// assert_eq!(buf[2], 3);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn swap(&mut self, i: uint, j: uint) {
+    pub fn swap(&mut self, i: usize, j: usize) {
         assert!(i < self.len());
         assert!(j < self.len());
         let ri = self.wrap_index(self.tail + i);
         let rj = self.wrap_index(self.tail + j);
         unsafe {
-            ptr::swap(self.ptr.offset(ri as int), self.ptr.offset(rj as int))
+            ptr::swap(self.ptr.offset(ri as isize), self.ptr.offset(rj as isize))
         }
     }
 
@@ -274,7 +274,7 @@ impl<T> RingBuf<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn capacity(&self) -> uint { self.cap - 1 }
+    pub fn capacity(&self) -> usize { self.cap - 1 }
 
     /// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the
     /// given `RingBuf`. Does nothing if the capacity is already sufficient.
@@ -285,7 +285,7 @@ impl<T> RingBuf<T> {
     ///
     /// # Panics
     ///
-    /// Panics if the new capacity overflows `uint`.
+    /// Panics if the new capacity overflows `usize`.
     ///
     /// # Examples
     ///
@@ -297,7 +297,7 @@ impl<T> RingBuf<T> {
     /// assert!(buf.capacity() >= 11);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_exact(&mut self, additional: uint) {
+    pub fn reserve_exact(&mut self, additional: usize) {
         self.reserve(additional);
     }
 
@@ -306,7 +306,7 @@ impl<T> RingBuf<T> {
     ///
     /// # Panics
     ///
-    /// Panics if the new capacity overflows `uint`.
+    /// Panics if the new capacity overflows `usize`.
     ///
     /// # Examples
     ///
@@ -318,7 +318,7 @@ impl<T> RingBuf<T> {
     /// assert!(buf.capacity() >= 11);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve(&mut self, additional: uint) {
+    pub fn reserve(&mut self, additional: usize) {
         let new_len = self.len() + additional;
         assert!(new_len + 1 > self.len(), "capacity overflow");
         if new_len > self.capacity() {
@@ -482,7 +482,7 @@ impl<T> RingBuf<T> {
     /// ```
     #[unstable(feature = "collections",
                reason = "matches collection reform specification; waiting on panic semantics")]
-    pub fn truncate(&mut self, len: uint) {
+    pub fn truncate(&mut self, len: usize) {
         for _ in len..self.len() {
             self.pop_back();
         }
@@ -529,13 +529,13 @@ impl<T> RingBuf<T> {
     /// assert_eq!(&buf.iter_mut().collect::<Vec<&mut i32>>()[], b);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> {
+    pub fn iter_mut(&mut self) -> IterMut<T> {
         IterMut {
             tail: self.tail,
             head: self.head,
             cap: self.cap,
             ptr: self.ptr,
-            marker: marker::ContravariantLifetime::<'a>,
+            marker: marker::ContravariantLifetime,
         }
     }
 
@@ -552,7 +552,7 @@ impl<T> RingBuf<T> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
-    pub fn as_slices<'a>(&'a self) -> (&'a [T], &'a [T]) {
+    pub fn as_slices(&self) -> (&[T], &[T]) {
         unsafe {
             let contiguous = self.is_contiguous();
             let buf = self.buffer_as_slice();
@@ -572,7 +572,7 @@ impl<T> RingBuf<T> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
-    pub fn as_mut_slices<'a>(&'a mut self) -> (&'a mut [T], &'a mut [T]) {
+    pub fn as_mut_slices(&mut self) -> (&mut [T], &mut [T]) {
         unsafe {
             let contiguous = self.is_contiguous();
             let head = self.head;
@@ -604,7 +604,7 @@ impl<T> RingBuf<T> {
     /// assert_eq!(v.len(), 1);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> uint { count(self.tail, self.head, self.cap) }
+    pub fn len(&self) -> usize { count(self.tail, self.head, self.cap) }
 
     /// Returns true if the buffer contains no elements
     ///
@@ -878,7 +878,7 @@ impl<T> RingBuf<T> {
     /// ```
     #[unstable(feature = "collections",
                reason = "the naming of this function may be altered")]
-    pub fn swap_back_remove(&mut self, index: uint) -> Option<T> {
+    pub fn swap_back_remove(&mut self, index: usize) -> Option<T> {
         let length = self.len();
         if length > 0 && index < length - 1 {
             self.swap(index, length - 1);
@@ -911,7 +911,7 @@ impl<T> RingBuf<T> {
     /// ```
     #[unstable(feature = "collections",
                reason = "the naming of this function may be altered")]
-    pub fn swap_front_remove(&mut self, index: uint) -> Option<T> {
+    pub fn swap_front_remove(&mut self, index: usize) -> Option<T> {
         let length = self.len();
         if length > 0 && index < length && index != 0 {
             self.swap(index, 0);
@@ -939,7 +939,7 @@ impl<T> RingBuf<T> {
     /// buf.insert(1,11);
     /// assert_eq!(Some(&11), buf.get(1));
     /// ```
-    pub fn insert(&mut self, i: uint, t: T) {
+    pub fn insert(&mut self, i: usize, t: T) {
         assert!(i <= self.len(), "index out of bounds");
         if self.is_full() {
             self.reserve(1);
@@ -1144,7 +1144,7 @@ impl<T> RingBuf<T> {
     /// assert_eq!(Some(&15), buf.get(2));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn remove(&mut self, i: uint) -> Option<T> {
+    pub fn remove(&mut self, i: usize) -> Option<T> {
         if self.is_empty() || self.len() <= i {
             return None;
         }
@@ -1312,7 +1312,7 @@ impl<T: Clone> RingBuf<T> {
     /// ```
     #[unstable(feature = "collections",
                reason = "matches collection reform specification; waiting on panic semantics")]
-    pub fn resize(&mut self, new_len: uint, value: T) {
+    pub fn resize(&mut self, new_len: usize, value: T) {
         let len = self.len();
 
         if new_len > len {
@@ -1325,14 +1325,14 @@ impl<T: Clone> RingBuf<T> {
 
 /// Returns the index in the underlying buffer for a given logical element index.
 #[inline]
-fn wrap_index(index: uint, size: uint) -> uint {
+fn wrap_index(index: usize, size: usize) -> usize {
     // size is always a power of 2
     index & (size - 1)
 }
 
 /// Calculate the number of elements left to be read in the buffer
 #[inline]
-fn count(tail: uint, head: uint, size: uint) -> uint {
+fn count(tail: usize, head: usize, size: usize) -> usize {
     // size is always a power of 2
     (head - tail) & (size - 1)
 }
@@ -1341,8 +1341,8 @@ fn count(tail: uint, head: uint, size: uint) -> uint {
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Iter<'a, T:'a> {
     ring: &'a [T],
-    tail: uint,
-    head: uint
+    tail: usize,
+    head: usize
 }
 
 // FIXME(#19839) Remove in favor of `#[derive(Clone)]`
@@ -1371,7 +1371,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         let len = count(self.tail, self.head, self.ring.len());
         (len, Some(len))
     }
@@ -1395,13 +1395,13 @@ impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T> RandomAccessIterator for Iter<'a, T> {
     #[inline]
-    fn indexable(&self) -> uint {
+    fn indexable(&self) -> usize {
         let (len, _) = self.size_hint();
         len
     }
 
     #[inline]
-    fn idx(&mut self, j: uint) -> Option<&'a T> {
+    fn idx(&mut self, j: usize) -> Option<&'a T> {
         if j >= self.indexable() {
             None
         } else {
@@ -1418,9 +1418,9 @@ impl<'a, T> RandomAccessIterator for Iter<'a, T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct IterMut<'a, T:'a> {
     ptr: *mut T,
-    tail: uint,
-    head: uint,
-    cap: uint,
+    tail: usize,
+    head: usize,
+    cap: usize,
     marker: marker::ContravariantLifetime<'a>,
 }
 
@@ -1437,12 +1437,12 @@ impl<'a, T> Iterator for IterMut<'a, T> {
         self.tail = wrap_index(self.tail + 1, self.cap);
 
         unsafe {
-            Some(&mut *self.ptr.offset(tail as int))
+            Some(&mut *self.ptr.offset(tail as isize))
         }
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         let len = count(self.tail, self.head, self.cap);
         (len, Some(len))
     }
@@ -1458,7 +1458,7 @@ impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
         self.head = wrap_index(self.head - 1, self.cap);
 
         unsafe {
-            Some(&mut *self.ptr.offset(self.head as int))
+            Some(&mut *self.ptr.offset(self.head as isize))
         }
     }
 }
@@ -1482,7 +1482,7 @@ impl<T> Iterator for IntoIter<T> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         let len = self.inner.len();
         (len, Some(len))
     }
@@ -1526,7 +1526,7 @@ impl<'a, T: 'a> Iterator for Drain<'a, T> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         let len = self.inner.len();
         (len, Some(len))
     }
@@ -1580,21 +1580,21 @@ impl<S: Writer + Hasher, A: Hash<S>> Hash<S> for RingBuf<A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<A> Index<uint> for RingBuf<A> {
+impl<A> Index<usize> for RingBuf<A> {
     type Output = A;
 
     #[inline]
-    fn index<'a>(&'a self, i: &uint) -> &'a A {
+    fn index(&self, i: &usize) -> &A {
         self.get(*i).expect("Out of bounds access")
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<A> IndexMut<uint> for RingBuf<A> {
+impl<A> IndexMut<usize> for RingBuf<A> {
     type Output = A;
 
     #[inline]
-    fn index_mut<'a>(&'a mut self, i: &uint) -> &'a mut A {
+    fn index_mut(&mut self, i: &usize) -> &mut A {
         self.get_mut(*i).expect("Out of bounds access")
     }
 }
@@ -1673,13 +1673,13 @@ mod tests {
     #[allow(deprecated)]
     fn test_simple() {
         let mut d = RingBuf::new();
-        assert_eq!(d.len(), 0u);
+        assert_eq!(d.len(), 0);
         d.push_front(17);
         d.push_front(42);
         d.push_back(137);
-        assert_eq!(d.len(), 3u);
+        assert_eq!(d.len(), 3);
         d.push_back(137);
-        assert_eq!(d.len(), 4u);
+        assert_eq!(d.len(), 4);
         assert_eq!(*d.front().unwrap(), 42);
         assert_eq!(*d.back().unwrap(), 137);
         let mut i = d.pop_front();
@@ -1690,15 +1690,15 @@ mod tests {
         assert_eq!(i, Some(137));
         i = d.pop_back();
         assert_eq!(i, Some(17));
-        assert_eq!(d.len(), 0u);
+        assert_eq!(d.len(), 0);
         d.push_back(3);
-        assert_eq!(d.len(), 1u);
+        assert_eq!(d.len(), 1);
         d.push_front(2);
-        assert_eq!(d.len(), 2u);
+        assert_eq!(d.len(), 2);
         d.push_back(4);
-        assert_eq!(d.len(), 3u);
+        assert_eq!(d.len(), 3);
         d.push_front(1);
-        assert_eq!(d.len(), 4u);
+        assert_eq!(d.len(), 4);
         debug!("{}", d[0]);
         debug!("{}", d[1]);
         debug!("{}", d[2]);
@@ -1743,21 +1743,21 @@ mod tests {
     #[test]
     fn test_push_front_grow() {
         let mut deq = RingBuf::new();
-        for i in 0u..66 {
+        for i in 0..66 {
             deq.push_front(i);
         }
         assert_eq!(deq.len(), 66);
 
-        for i in 0u..66 {
+        for i in 0..66 {
             assert_eq!(deq[i], 65 - i);
         }
 
         let mut deq = RingBuf::new();
-        for i in 0u..66 {
+        for i in 0..66 {
             deq.push_back(i);
         }
 
-        for i in 0u..66 {
+        for i in 0..66 {
             assert_eq!(deq[i], i);
         }
     }
@@ -1765,7 +1765,7 @@ mod tests {
     #[test]
     fn test_index() {
         let mut deq = RingBuf::new();
-        for i in 1u..4 {
+        for i in 1..4 {
             deq.push_front(i);
         }
         assert_eq!(deq[1], 2);
@@ -1775,7 +1775,7 @@ mod tests {
     #[should_fail]
     fn test_index_out_of_bounds() {
         let mut deq = RingBuf::new();
-        for i in 1u..4 {
+        for i in 1..4 {
             deq.push_front(i);
         }
         deq[3];
@@ -1784,7 +1784,7 @@ mod tests {
     #[bench]
     fn bench_new(b: &mut test::Bencher) {
         b.iter(|| {
-            let ring: RingBuf<u64> = RingBuf::new();
+            let ring: RingBuf<i32> = RingBuf::new();
             test::black_box(ring);
         })
     }
@@ -1815,7 +1815,7 @@ mod tests {
 
     #[bench]
     fn bench_pop_back_100(b: &mut test::Bencher) {
-        let mut deq: RingBuf<i32> = RingBuf::with_capacity(101);
+        let mut deq= RingBuf::<i32>::with_capacity(101);
 
         b.iter(|| {
             deq.head = 100;
@@ -1828,7 +1828,7 @@ mod tests {
 
     #[bench]
     fn bench_pop_front_100(b: &mut test::Bencher) {
-        let mut deq: RingBuf<i32> = RingBuf::with_capacity(101);
+        let mut deq = RingBuf::<i32>::with_capacity(101);
 
         b.iter(|| {
             deq.head = 100;
@@ -1852,7 +1852,7 @@ mod tests {
 
     #[bench]
     fn bench_iter_1000(b: &mut test::Bencher) {
-        let ring: RingBuf<i32> = (0..1000).collect();
+        let ring: RingBuf<_> = (0..1000).collect();
 
         b.iter(|| {
             let mut sum = 0;
@@ -1865,7 +1865,7 @@ mod tests {
 
     #[bench]
     fn bench_mut_iter_1000(b: &mut test::Bencher) {
-        let mut ring: RingBuf<i32> = (0..1000).collect();
+        let mut ring: RingBuf<_> = (0..1000).collect();
 
         b.iter(|| {
             let mut sum = 0;
@@ -1978,11 +1978,7 @@ mod tests {
     #[test]
     fn test_reserve_exact() {
         let mut d = RingBuf::new();
-        d.push_back(0u64);
-        d.reserve_exact(50);
-        assert!(d.capacity() >= 51);
-        let mut d = RingBuf::new();
-        d.push_back(0u32);
+        d.push_back(0);
         d.reserve_exact(50);
         assert!(d.capacity() >= 51);
     }
@@ -1990,21 +1986,17 @@ mod tests {
     #[test]
     fn test_reserve() {
         let mut d = RingBuf::new();
-        d.push_back(0u64);
-        d.reserve(50);
-        assert!(d.capacity() >= 51);
-        let mut d = RingBuf::new();
-        d.push_back(0u32);
+        d.push_back(0);
         d.reserve(50);
         assert!(d.capacity() >= 51);
     }
 
     #[test]
     fn test_swap() {
-        let mut d: RingBuf<i32> = (0..5).collect();
+        let mut d: RingBuf<_> = (0..5).collect();
         d.pop_front();
         d.swap(0, 3);
-        assert_eq!(d.iter().map(|&x|x).collect::<Vec<i32>>(), vec!(4, 2, 3, 1));
+        assert_eq!(d.iter().cloned().collect::<Vec<_>>(), vec!(4, 2, 3, 1));
     }
 
     #[test]
@@ -2018,7 +2010,7 @@ mod tests {
         }
         {
             let b: &[_] = &[&0,&1,&2,&3,&4];
-            assert_eq!(d.iter().collect::<Vec<&i32>>(), b);
+            assert_eq!(d.iter().collect::<Vec<_>>(), b);
         }
 
         for i in 6..9 {
@@ -2026,7 +2018,7 @@ mod tests {
         }
         {
             let b: &[_] = &[&8,&7,&6,&0,&1,&2,&3,&4];
-            assert_eq!(d.iter().collect::<Vec<&i32>>(), b);
+            assert_eq!(d.iter().collect::<Vec<_>>(), b);
         }
 
         let mut it = d.iter();
@@ -2049,14 +2041,14 @@ mod tests {
         }
         {
             let b: &[_] = &[&4,&3,&2,&1,&0];
-            assert_eq!(d.iter().rev().collect::<Vec<&i32>>(), b);
+            assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
         }
 
         for i in 6..9 {
             d.push_front(i);
         }
         let b: &[_] = &[&4,&3,&2,&1,&0,&6,&7,&8];
-        assert_eq!(d.iter().rev().collect::<Vec<&i32>>(), b);
+        assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
     }
 
     #[test]
@@ -2070,8 +2062,8 @@ mod tests {
         assert_eq!(d.pop_front(), Some(1));
         d.push_back(4);
 
-        assert_eq!(d.iter_mut().rev().map(|x| *x).collect::<Vec<i32>>(),
-                   vec!(4, 3, 2));
+        assert_eq!(d.iter_mut().rev().cloned().collect::<Vec<_>>(),
+                   vec![4, 3, 2]);
     }
 
     #[test]
@@ -2079,7 +2071,7 @@ mod tests {
         let mut d = RingBuf::new();
         assert!(d.iter_mut().next().is_none());
 
-        for i in 0u..3 {
+        for i in 0..3 {
             d.push_front(i);
         }
 
@@ -2102,7 +2094,7 @@ mod tests {
         let mut d = RingBuf::new();
         assert!(d.iter_mut().rev().next().is_none());
 
-        for i in 0u..3 {
+        for i in 0..3 {
             d.push_front(i);
         }
 
@@ -2141,7 +2133,7 @@ mod tests {
             }
 
             let b = vec![0,1,2,3,4];
-            assert_eq!(d.into_iter().collect::<Vec<i32>>(), b);
+            assert_eq!(d.into_iter().collect::<Vec<_>>(), b);
         }
 
         // wrapped iter
@@ -2155,7 +2147,7 @@ mod tests {
             }
 
             let b = vec![8,7,6,0,1,2,3,4];
-            assert_eq!(d.into_iter().collect::<Vec<i32>>(), b);
+            assert_eq!(d.into_iter().collect::<Vec<_>>(), b);
         }
 
         // partially used
@@ -2224,7 +2216,7 @@ mod tests {
 
         // partially used
         {
-            let mut d: RingBuf<i32> = RingBuf::new();
+            let mut d: RingBuf<_> = RingBuf::new();
             for i in 0..5 {
                 d.push_back(i);
             }
@@ -2250,12 +2242,12 @@ mod tests {
     fn test_from_iter() {
         use core::iter;
         let v = vec!(1,2,3,4,5,6,7);
-        let deq: RingBuf<i32> = v.iter().map(|&x| x).collect();
-        let u: Vec<i32> = deq.iter().map(|&x| x).collect();
+        let deq: RingBuf<_> = v.iter().cloned().collect();
+        let u: Vec<_> = deq.iter().cloned().collect();
         assert_eq!(u, v);
 
-        let seq = iter::count(0u, 2).take(256);
-        let deq: RingBuf<uint> = seq.collect();
+        let seq = iter::count(0, 2).take(256);
+        let deq: RingBuf<_> = seq.collect();
         for (i, &x) in deq.iter().enumerate() {
             assert_eq!(2*i, x);
         }
@@ -2269,14 +2261,14 @@ mod tests {
         d.push_front(42);
         d.push_back(137);
         d.push_back(137);
-        assert_eq!(d.len(), 4u);
+        assert_eq!(d.len(), 4);
         let mut e = d.clone();
-        assert_eq!(e.len(), 4u);
+        assert_eq!(e.len(), 4);
         while !d.is_empty() {
             assert_eq!(d.pop_back(), e.pop_back());
         }
-        assert_eq!(d.len(), 0u);
-        assert_eq!(e.len(), 0u);
+        assert_eq!(d.len(), 0);
+        assert_eq!(e.len(), 0);
     }
 
     #[test]
@@ -2333,18 +2325,18 @@ mod tests {
 
     #[test]
     fn test_show() {
-        let ringbuf: RingBuf<i32> = (0..10).collect();
+        let ringbuf: RingBuf<_> = (0..10).collect();
         assert_eq!(format!("{:?}", ringbuf), "RingBuf [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
 
-        let ringbuf: RingBuf<&str> = vec!["just", "one", "test", "more"].iter()
-                                                                        .map(|&s| s)
+        let ringbuf: RingBuf<_> = vec!["just", "one", "test", "more"].iter()
+                                                                        .cloned()
                                                                         .collect();
         assert_eq!(format!("{:?}", ringbuf), "RingBuf [\"just\", \"one\", \"test\", \"more\"]");
     }
 
     #[test]
     fn test_drop() {
-        static mut drops: uint = 0;
+        static mut drops: i32 = 0;
         struct Elem;
         impl Drop for Elem {
             fn drop(&mut self) {
@@ -2364,7 +2356,7 @@ mod tests {
 
     #[test]
     fn test_drop_with_pop() {
-        static mut drops: uint = 0;
+        static mut drops: i32 = 0;
         struct Elem;
         impl Drop for Elem {
             fn drop(&mut self) {
@@ -2388,7 +2380,7 @@ mod tests {
 
     #[test]
     fn test_drop_clear() {
-        static mut drops: uint = 0;
+        static mut drops: i32 = 0;
         struct Elem;
         impl Drop for Elem {
             fn drop(&mut self) {
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index 8721de1299f..ddbc86506b8 100644
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -26,7 +26,7 @@
 //! block of memory that a mutable slice points to:
 //!
 //! ```rust
-//! let x: &mut[int] = &mut [1, 2, 3];
+//! let x: &mut[i32] = &mut [1, 2, 3];
 //! x[1] = 7;
 //! assert_eq!(x[0], 1);
 //! assert_eq!(x[1], 7);
@@ -168,25 +168,25 @@ pub trait SliceExt {
     /// ```
     #[unstable(feature = "collections",
                reason = "uncertain about this API approach")]
-    fn move_from(&mut self, src: Vec<Self::Item>, start: uint, end: uint) -> uint;
+    fn move_from(&mut self, src: Vec<Self::Item>, start: usize, end: usize) -> usize;
 
     /// Deprecated: use `&s[start .. end]` notation instead.
     #[unstable(feature = "collections",
                reason = "will be replaced by slice syntax")]
     #[deprecated(since = "1.0.0", reason = "use &s[start .. end] instead")]
-    fn slice(&self, start: uint, end: uint) -> &[Self::Item];
+    fn slice(&self, start: usize, end: usize) -> &[Self::Item];
 
     /// Deprecated: use `&s[start..]` notation instead.
     #[unstable(feature = "collections",
                reason = "will be replaced by slice syntax")]
     #[deprecated(since = "1.0.0", reason = "use &s[start..] instead")]
-    fn slice_from(&self, start: uint) -> &[Self::Item];
+    fn slice_from(&self, start: usize) -> &[Self::Item];
 
     /// Deprecated: use `&s[..end]` notation instead.
     #[unstable(feature = "collections",
                reason = "will be replaced by slice syntax")]
     #[deprecated(since = "1.0.0", reason = "use &s[..end] instead")]
-    fn slice_to(&self, end: uint) -> &[Self::Item];
+    fn slice_to(&self, end: usize) -> &[Self::Item];
 
     /// Divides one slice into two at an index.
     ///
@@ -205,7 +205,7 @@ pub trait SliceExt {
     /// assert_eq!([30, 20, 50], v2);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn split_at(&self, mid: uint) -> (&[Self::Item], &[Self::Item]);
+    fn split_at(&self, mid: usize) -> (&[Self::Item], &[Self::Item]);
 
     /// Returns an iterator over the slice.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -245,7 +245,7 @@ pub trait SliceExt {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn splitn<F>(&self, n: uint, pred: F) -> SplitN<Self::Item, F>
+    fn splitn<F>(&self, n: usize, pred: F) -> SplitN<Self::Item, F>
                  where F: FnMut(&Self::Item) -> bool;
 
     /// Returns an iterator over subslices separated by elements that match
@@ -265,7 +265,7 @@ pub trait SliceExt {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn rsplitn<F>(&self, n: uint, pred: F) -> RSplitN<Self::Item, F>
+    fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<Self::Item, F>
                   where F: FnMut(&Self::Item) -> bool;
 
     /// Returns an iterator over all contiguous windows of length
@@ -288,7 +288,7 @@ pub trait SliceExt {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn windows(&self, size: uint) -> Windows<Self::Item>;
+    fn windows(&self, size: usize) -> Windows<Self::Item>;
 
     /// Returns an iterator over `size` elements of the slice at a
     /// time. The chunks do not overlap. If `size` does not divide the
@@ -311,7 +311,7 @@ pub trait SliceExt {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn chunks(&self, size: uint) -> Chunks<Self::Item>;
+    fn chunks(&self, size: usize) -> Chunks<Self::Item>;
 
     /// Returns the element of a slice at the given index, or `None` if the
     /// index is out of bounds.
@@ -324,7 +324,7 @@ pub trait SliceExt {
     /// assert_eq!(None, v.get(3));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn get(&self, index: uint) -> Option<&Self::Item>;
+    fn get(&self, index: usize) -> Option<&Self::Item>;
 
     /// Returns the first element of a slice, or `None` if it is empty.
     ///
@@ -365,7 +365,7 @@ pub trait SliceExt {
     /// Returns a pointer to the element at the given index, without doing
     /// bounds checking.
     #[stable(feature = "rust1", since = "1.0.0")]
-    unsafe fn get_unchecked(&self, index: uint) -> &Self::Item;
+    unsafe fn get_unchecked(&self, index: usize) -> &Self::Item;
 
     /// Returns an unsafe pointer to the slice's buffer
     ///
@@ -410,7 +410,7 @@ pub trait SliceExt {
     /// assert!(match r { Ok(1...4) => true, _ => false, });
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn binary_search_by<F>(&self, f: F) -> Result<uint, uint> where
+    fn binary_search_by<F>(&self, f: F) -> Result<usize, usize> where
         F: FnMut(&Self::Item) -> Ordering;
 
     /// Return the number of elements in the slice
@@ -422,7 +422,7 @@ pub trait SliceExt {
     /// assert_eq!(a.len(), 3);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn len(&self) -> uint;
+    fn len(&self) -> usize;
 
     /// Returns true if the slice has a length of 0
     ///
@@ -438,7 +438,7 @@ pub trait SliceExt {
     /// Returns a mutable reference to the element at the given index,
     /// or `None` if the index is out of bounds
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn get_mut(&mut self, index: uint) -> Option<&mut Self::Item>;
+    fn get_mut(&mut self, index: usize) -> Option<&mut Self::Item>;
 
     /// Work with `self` as a mut slice.
     /// Primarily intended for getting a &mut [T] from a [T; N].
@@ -449,19 +449,19 @@ pub trait SliceExt {
     #[unstable(feature = "collections",
                reason = "will be replaced by slice syntax")]
     #[deprecated(since = "1.0.0", reason = "use &mut s[start .. end] instead")]
-    fn slice_mut(&mut self, start: uint, end: uint) -> &mut [Self::Item];
+    fn slice_mut(&mut self, start: usize, end: usize) -> &mut [Self::Item];
 
     /// Deprecated: use `&mut s[start ..]` instead.
     #[unstable(feature = "collections",
                reason = "will be replaced by slice syntax")]
     #[deprecated(since = "1.0.0", reason = "use &mut s[start ..] instead")]
-    fn slice_from_mut(&mut self, start: uint) -> &mut [Self::Item];
+    fn slice_from_mut(&mut self, start: usize) -> &mut [Self::Item];
 
     /// Deprecated: use `&mut s[.. end]` instead.
     #[unstable(feature = "collections",
                reason = "will be replaced by slice syntax")]
     #[deprecated(since = "1.0.0", reason = "use &mut s[.. end] instead")]
-    fn slice_to_mut(&mut self, end: uint) -> &mut [Self::Item];
+    fn slice_to_mut(&mut self, end: usize) -> &mut [Self::Item];
 
     /// Returns an iterator that allows modifying each value
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -495,7 +495,7 @@ pub trait SliceExt {
     /// `pred`, limited to splitting at most `n` times.  The matched element is
     /// not contained in the subslices.
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn splitn_mut<F>(&mut self, n: uint, pred: F) -> SplitNMut<Self::Item, F>
+    fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<Self::Item, F>
                      where F: FnMut(&Self::Item) -> bool;
 
     /// Returns an iterator over subslices separated by elements that match
@@ -503,7 +503,7 @@ pub trait SliceExt {
     /// the slice and works backwards.  The matched element is not contained in
     /// the subslices.
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn rsplitn_mut<F>(&mut self,  n: uint, pred: F) -> RSplitNMut<Self::Item, F>
+    fn rsplitn_mut<F>(&mut self,  n: usize, pred: F) -> RSplitNMut<Self::Item, F>
                       where F: FnMut(&Self::Item) -> bool;
 
     /// Returns an iterator over `chunk_size` elements of the slice at a time.
@@ -515,7 +515,7 @@ pub trait SliceExt {
     ///
     /// Panics if `chunk_size` is 0.
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn chunks_mut(&mut self, chunk_size: uint) -> ChunksMut<Self::Item>;
+    fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<Self::Item>;
 
     /// Swaps two elements in a slice.
     ///
@@ -536,7 +536,7 @@ pub trait SliceExt {
     /// assert!(v == ["a", "d", "c", "b"]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn swap(&mut self, a: uint, b: uint);
+    fn swap(&mut self, a: usize, b: usize);
 
     /// Divides one `&mut` into two at an index.
     ///
@@ -573,7 +573,7 @@ pub trait SliceExt {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn split_at_mut(&mut self, mid: uint) -> (&mut [Self::Item], &mut [Self::Item]);
+    fn split_at_mut(&mut self, mid: usize) -> (&mut [Self::Item], &mut [Self::Item]);
 
     /// Reverse the order of elements in a slice, in place.
     ///
@@ -589,7 +589,7 @@ pub trait SliceExt {
 
     /// Returns an unsafe mutable pointer to the element in index
     #[stable(feature = "rust1", since = "1.0.0")]
-    unsafe fn get_unchecked_mut(&mut self, index: uint) -> &mut Self::Item;
+    unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut Self::Item;
 
     /// Return an unsafe mutable pointer to the slice's buffer.
     ///
@@ -651,7 +651,7 @@ pub trait SliceExt {
     /// assert!(dst == [3, 4, 5]);
     /// ```
     #[unstable(feature = "collections")]
-    fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone;
+    fn clone_from_slice(&mut self, &[Self::Item]) -> usize where Self::Item: Clone;
 
     /// Sorts the slice, in place.
     ///
@@ -692,12 +692,12 @@ pub trait SliceExt {
     /// assert!(match r { Ok(1...4) => true, _ => false, });
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn binary_search(&self, x: &Self::Item) -> Result<uint, uint> where Self::Item: Ord;
+    fn binary_search(&self, x: &Self::Item) -> Result<usize, usize> where Self::Item: Ord;
 
     /// Deprecated: use `binary_search` instead.
     #[unstable(feature = "collections")]
     #[deprecated(since = "1.0.0", reason = "use binary_search instead")]
-    fn binary_search_elem(&self, x: &Self::Item) -> Result<uint, uint> where Self::Item: Ord {
+    fn binary_search_elem(&self, x: &Self::Item) -> Result<usize, usize> where Self::Item: Ord {
         self.binary_search(x)
     }
 
@@ -743,11 +743,11 @@ pub trait SliceExt {
 
     /// Find the first index containing a matching value.
     #[unstable(feature = "collections")]
-    fn position_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq;
+    fn position_elem(&self, t: &Self::Item) -> Option<usize> where Self::Item: PartialEq;
 
     /// Find the last index containing a matching value.
     #[unstable(feature = "collections")]
-    fn rposition_elem(&self, t: &Self::Item) -> Option<uint> where Self::Item: PartialEq;
+    fn rposition_elem(&self, t: &Self::Item) -> Option<usize> where Self::Item: PartialEq;
 
     /// Returns true if the slice contains an element with the given value.
     ///
@@ -804,7 +804,7 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    fn move_from(&mut self, mut src: Vec<T>, start: uint, end: uint) -> uint {
+    fn move_from(&mut self, mut src: Vec<T>, start: usize, end: usize) -> usize {
         for (a, b) in self.iter_mut().zip(src[start .. end].iter_mut()) {
             mem::swap(a, b);
         }
@@ -812,27 +812,27 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    fn slice<'a>(&'a self, start: uint, end: uint) -> &'a [T] {
+    fn slice(&self, start: usize, end: usize) -> &[T] {
         &self[start .. end]
     }
 
     #[inline]
-    fn slice_from<'a>(&'a self, start: uint) -> &'a [T] {
+    fn slice_from(&self, start: usize) -> &[T] {
         &self[start ..]
     }
 
     #[inline]
-    fn slice_to<'a>(&'a self, end: uint) -> &'a [T] {
+    fn slice_to(&self, end: usize) -> &[T] {
         &self[.. end]
     }
 
     #[inline]
-    fn split_at<'a>(&'a self, mid: uint) -> (&'a [T], &'a [T]) {
+    fn split_at(&self, mid: usize) -> (&[T], &[T]) {
         core_slice::SliceExt::split_at(self, mid)
     }
 
     #[inline]
-    fn iter<'a>(&'a self) -> Iter<'a, T> {
+    fn iter(&self) -> Iter<T> {
         core_slice::SliceExt::iter(self)
     }
 
@@ -843,54 +843,54 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    fn splitn<F>(&self, n: uint, pred: F) -> SplitN<T, F>
+    fn splitn<F>(&self, n: usize, pred: F) -> SplitN<T, F>
                  where F: FnMut(&T) -> bool {
         core_slice::SliceExt::splitn(self, n, pred)
     }
 
     #[inline]
-    fn rsplitn<F>(&self, n: uint, pred: F) -> RSplitN<T, F>
+    fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<T, F>
                   where F: FnMut(&T) -> bool {
         core_slice::SliceExt::rsplitn(self, n, pred)
     }
 
     #[inline]
-    fn windows<'a>(&'a self, size: uint) -> Windows<'a, T> {
+    fn windows(&self, size: usize) -> Windows<T> {
         core_slice::SliceExt::windows(self, size)
     }
 
     #[inline]
-    fn chunks<'a>(&'a self, size: uint) -> Chunks<'a, T> {
+    fn chunks(&self, size: usize) -> Chunks<T> {
         core_slice::SliceExt::chunks(self, size)
     }
 
     #[inline]
-    fn get<'a>(&'a self, index: uint) -> Option<&'a T> {
+    fn get(&self, index: usize) -> Option<&T> {
         core_slice::SliceExt::get(self, index)
     }
 
     #[inline]
-    fn first<'a>(&'a self) -> Option<&'a T> {
+    fn first(&self) -> Option<&T> {
         core_slice::SliceExt::first(self)
     }
 
     #[inline]
-    fn tail<'a>(&'a self) -> &'a [T] {
+    fn tail(&self) -> &[T] {
         core_slice::SliceExt::tail(self)
     }
 
     #[inline]
-    fn init<'a>(&'a self) -> &'a [T] {
+    fn init(&self) -> &[T] {
         core_slice::SliceExt::init(self)
     }
 
     #[inline]
-    fn last<'a>(&'a self) -> Option<&'a T> {
+    fn last(&self) -> Option<&T> {
         core_slice::SliceExt::last(self)
     }
 
     #[inline]
-    unsafe fn get_unchecked<'a>(&'a self, index: uint) -> &'a T {
+    unsafe fn get_unchecked(&self, index: usize) -> &T {
         core_slice::SliceExt::get_unchecked(self, index)
     }
 
@@ -900,13 +900,13 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    fn binary_search_by<F>(&self, f: F) -> Result<uint, uint>
+    fn binary_search_by<F>(&self, f: F) -> Result<usize, usize>
                         where F: FnMut(&T) -> Ordering {
         core_slice::SliceExt::binary_search_by(self, f)
     }
 
     #[inline]
-    fn len(&self) -> uint {
+    fn len(&self) -> usize {
         core_slice::SliceExt::len(self)
     }
 
@@ -916,52 +916,52 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    fn get_mut<'a>(&'a mut self, index: uint) -> Option<&'a mut T> {
+    fn get_mut(&mut self, index: usize) -> Option<&mut T> {
         core_slice::SliceExt::get_mut(self, index)
     }
 
     #[inline]
-    fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {
+    fn as_mut_slice(&mut self) -> &mut [T] {
         core_slice::SliceExt::as_mut_slice(self)
     }
 
     #[inline]
-    fn slice_mut<'a>(&'a mut self, start: uint, end: uint) -> &'a mut [T] {
+    fn slice_mut(&mut self, start: usize, end: usize) -> &mut [T] {
         &mut self[start .. end]
     }
 
     #[inline]
-    fn slice_from_mut<'a>(&'a mut self, start: uint) -> &'a mut [T] {
+    fn slice_from_mut(&mut self, start: usize) -> &mut [T] {
         &mut self[start ..]
     }
 
     #[inline]
-    fn slice_to_mut<'a>(&'a mut self, end: uint) -> &'a mut [T] {
+    fn slice_to_mut(&mut self, end: usize) -> &mut [T] {
         &mut self[.. end]
     }
 
     #[inline]
-    fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> {
+    fn iter_mut(&mut self) -> IterMut<T> {
         core_slice::SliceExt::iter_mut(self)
     }
 
     #[inline]
-    fn first_mut<'a>(&'a mut self) -> Option<&'a mut T> {
+    fn first_mut(&mut self) -> Option<&mut T> {
         core_slice::SliceExt::first_mut(self)
     }
 
     #[inline]
-    fn tail_mut<'a>(&'a mut self) -> &'a mut [T] {
+    fn tail_mut(&mut self) -> &mut [T] {
         core_slice::SliceExt::tail_mut(self)
     }
 
     #[inline]
-    fn init_mut<'a>(&'a mut self) -> &'a mut [T] {
+    fn init_mut(&mut self) -> &mut [T] {
         core_slice::SliceExt::init_mut(self)
     }
 
     #[inline]
-    fn last_mut<'a>(&'a mut self) -> Option<&'a mut T> {
+    fn last_mut(&mut self) -> Option<&mut T> {
         core_slice::SliceExt::last_mut(self)
     }
 
@@ -972,29 +972,29 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    fn splitn_mut<F>(&mut self, n: uint, pred: F) -> SplitNMut<T, F>
+    fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<T, F>
                      where F: FnMut(&T) -> bool {
         core_slice::SliceExt::splitn_mut(self, n, pred)
     }
 
     #[inline]
-    fn rsplitn_mut<F>(&mut self,  n: uint, pred: F) -> RSplitNMut<T, F>
+    fn rsplitn_mut<F>(&mut self,  n: usize, pred: F) -> RSplitNMut<T, F>
                       where F: FnMut(&T) -> bool {
         core_slice::SliceExt::rsplitn_mut(self, n, pred)
     }
 
     #[inline]
-    fn chunks_mut<'a>(&'a mut self, chunk_size: uint) -> ChunksMut<'a, T> {
+    fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T> {
         core_slice::SliceExt::chunks_mut(self, chunk_size)
     }
 
     #[inline]
-    fn swap(&mut self, a: uint, b: uint) {
+    fn swap(&mut self, a: usize, b: usize) {
         core_slice::SliceExt::swap(self, a, b)
     }
 
     #[inline]
-    fn split_at_mut<'a>(&'a mut self, mid: uint) -> (&'a mut [T], &'a mut [T]) {
+    fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
         core_slice::SliceExt::split_at_mut(self, mid)
     }
 
@@ -1004,7 +1004,7 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    unsafe fn get_unchecked_mut<'a>(&'a mut self, index: uint) -> &'a mut T {
+    unsafe fn get_unchecked_mut(&mut self, index: usize) -> &mut T {
         core_slice::SliceExt::get_unchecked_mut(self, index)
     }
 
@@ -1029,7 +1029,7 @@ impl<T> SliceExt for [T] {
         }
     }
 
-    fn clone_from_slice(&mut self, src: &[T]) -> uint where T: Clone {
+    fn clone_from_slice(&mut self, src: &[T]) -> usize where T: Clone {
         core_slice::SliceExt::clone_from_slice(self, src)
     }
 
@@ -1038,7 +1038,7 @@ impl<T> SliceExt for [T] {
         self.sort_by(|a, b| a.cmp(b))
     }
 
-    fn binary_search(&self, x: &T) -> Result<uint, uint> where T: Ord {
+    fn binary_search(&self, x: &T) -> Result<usize, usize> where T: Ord {
         core_slice::SliceExt::binary_search(self, x)
     }
 
@@ -1050,11 +1050,11 @@ impl<T> SliceExt for [T] {
         core_slice::SliceExt::prev_permutation(self)
     }
 
-    fn position_elem(&self, t: &T) -> Option<uint> where T: PartialEq {
+    fn position_elem(&self, t: &T) -> Option<usize> where T: PartialEq {
         core_slice::SliceExt::position_elem(self, t)
     }
 
-    fn rposition_elem(&self, t: &T) -> Option<uint> where T: PartialEq {
+    fn rposition_elem(&self, t: &T) -> Option<usize> where T: PartialEq {
         core_slice::SliceExt::rposition_elem(self, t)
     }
 
@@ -1116,7 +1116,7 @@ pub trait SliceConcatExt<T: ?Sized, U> {
 
 impl<T: Clone, V: AsSlice<T>> SliceConcatExt<T, Vec<T>> for [V] {
     fn concat(&self) -> Vec<T> {
-        let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len());
+        let size = self.iter().fold(0, |acc, v| acc + v.as_slice().len());
         let mut result = Vec::with_capacity(size);
         for v in self {
             result.push_all(v.as_slice())
@@ -1125,7 +1125,7 @@ impl<T: Clone, V: AsSlice<T>> SliceConcatExt<T, Vec<T>> for [V] {
     }
 
     fn connect(&self, sep: &T) -> Vec<T> {
-        let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len());
+        let size = self.iter().fold(0, |acc, v| acc + v.as_slice().len());
         let mut result = Vec::with_capacity(size + self.len());
         let mut first = true;
         for v in self {
@@ -1153,13 +1153,13 @@ pub struct ElementSwaps {
     /// If `true`, emit the last swap that returns the sequence to initial
     /// state.
     emit_reset: bool,
-    swaps_made : uint,
+    swaps_made : usize,
 }
 
 impl ElementSwaps {
     /// Creates an `ElementSwaps` iterator for a sequence of `length` elements.
     #[unstable(feature = "collections")]
-    pub fn new(length: uint) -> ElementSwaps {
+    pub fn new(length: usize) -> ElementSwaps {
         // Initialize `sdir` with a direction that position should move in
         // (all negative at the beginning) and the `size` of the
         // element (equal to the original index).
@@ -1200,17 +1200,17 @@ enum Direction { Pos, Neg }
 /// An `Index` and `Direction` together.
 #[derive(Copy, Clone)]
 struct SizeDirection {
-    size: uint,
+    size: usize,
     dir: Direction,
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Iterator for ElementSwaps {
-    type Item = (uint, uint);
+    type Item = (usize, usize);
 
     #[inline]
-    fn next(&mut self) -> Option<(uint, uint)> {
-        fn new_pos(i: uint, s: Direction) -> uint {
+    fn next(&mut self) -> Option<(usize, usize)> {
+        fn new_pos(i: usize, s: Direction) -> usize {
             i + match s { Pos => 1, Neg => -1 }
         }
 
@@ -1252,7 +1252,7 @@ impl Iterator for ElementSwaps {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         // For a vector of size n, there are exactly n! permutations.
         let n = (2..self.sdir.len() + 1).product();
         (n - self.swaps_made, Some(n - self.swaps_made))
@@ -1291,7 +1291,7 @@ impl<T: Clone> Iterator for Permutations<T> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         self.swaps.size_hint()
     }
 }
@@ -1301,7 +1301,7 @@ impl<T: Clone> Iterator for Permutations<T> {
 ////////////////////////////////////////////////////////////////////////////////
 
 fn insertion_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Ordering {
-    let len = v.len() as int;
+    let len = v.len() as isize;
     let buf_v = v.as_mut_ptr();
 
     // 1 <= i < len;
@@ -1332,7 +1332,7 @@ fn insertion_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> O
                 let tmp = ptr::read(read_ptr);
                 ptr::copy_memory(buf_v.offset(j + 1),
                                  &*buf_v.offset(j),
-                                 (i - j) as uint);
+                                 (i - j) as usize);
                 ptr::copy_nonoverlapping_memory(buf_v.offset(j),
                                                 &tmp,
                                                 1);
@@ -1344,8 +1344,8 @@ fn insertion_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> O
 
 fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Ordering {
     // warning: this wildly uses unsafe.
-    static BASE_INSERTION: uint = 32;
-    static LARGE_INSERTION: uint = 16;
+    static BASE_INSERTION: usize = 32;
+    static LARGE_INSERTION: usize = 16;
 
     // FIXME #12092: smaller insertion runs seems to make sorting
     // vectors of large elements a little faster on some platforms,
@@ -1371,7 +1371,7 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
     let mut working_space = Vec::with_capacity(2 * len);
     // these both are buffers of length `len`.
     let mut buf_dat = working_space.as_mut_ptr();
-    let mut buf_tmp = unsafe {buf_dat.offset(len as int)};
+    let mut buf_tmp = unsafe {buf_dat.offset(len as isize)};
 
     // length `len`.
     let buf_v = v.as_ptr();
@@ -1387,17 +1387,17 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
         // start <= i < len;
         for i in start..cmp::min(start + insertion, len) {
             // j satisfies: start <= j <= i;
-            let mut j = i as int;
+            let mut j = i as isize;
             unsafe {
                 // `i` is in bounds.
-                let read_ptr = buf_v.offset(i as int);
+                let read_ptr = buf_v.offset(i as isize);
 
                 // find where to insert, we need to do strict <,
                 // rather than <=, to maintain stability.
 
                 // start <= j - 1 < len, so .offset(j - 1) is in
                 // bounds.
-                while j > start as int &&
+                while j > start as isize &&
                         compare(&*read_ptr, &*buf_dat.offset(j - 1)) == Less {
                     j -= 1;
                 }
@@ -1410,7 +1410,7 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
                 // `.offset(j)` is always in bounds.
                 ptr::copy_memory(buf_dat.offset(j + 1),
                                  &*buf_dat.offset(j),
-                                 i - j as uint);
+                                 i - j as usize);
                 ptr::copy_nonoverlapping_memory(buf_dat.offset(j), read_ptr, 1);
             }
         }
@@ -1431,24 +1431,24 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
                 // the end of the first run & start of the
                 // second. Offset of `len` is defined, since this is
                 // precisely one byte past the end of the object.
-                let right_start = buf_dat.offset(cmp::min(start + width, len) as int);
+                let right_start = buf_dat.offset(cmp::min(start + width, len) as isize);
                 // end of the second. Similar reasoning to the above re safety.
                 let right_end_idx = cmp::min(start + 2 * width, len);
-                let right_end = buf_dat.offset(right_end_idx as int);
+                let right_end = buf_dat.offset(right_end_idx as isize);
 
                 // the pointers to the elements under consideration
                 // from the two runs.
 
                 // both of these are in bounds.
-                let mut left = buf_dat.offset(start as int);
+                let mut left = buf_dat.offset(start as isize);
                 let mut right = right_start;
 
                 // where we're putting the results, it is a run of
                 // length `2*width`, so we step it once for each step
                 // of either `left` or `right`.  `buf_tmp` has length
                 // `len`, so these are in bounds.
-                let mut out = buf_tmp.offset(start as int);
-                let out_end = buf_tmp.offset(right_end_idx as int);
+                let mut out = buf_tmp.offset(start as isize);
+                let out_end = buf_tmp.offset(right_end_idx as isize);
 
                 while out < out_end {
                     // Either the left or the right run are exhausted,
@@ -1458,11 +1458,11 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
                     // case).
                     if left == right_start {
                         // the number remaining in this run.
-                        let elems = (right_end as uint - right as uint) / mem::size_of::<T>();
+                        let elems = (right_end as usize - right as usize) / mem::size_of::<T>();
                         ptr::copy_nonoverlapping_memory(out, &*right, elems);
                         break;
                     } else if right == right_end {
-                        let elems = (right_start as uint - left as uint) / mem::size_of::<T>();
+                        let elems = (right_start as usize - left as usize) / mem::size_of::<T>();
                         ptr::copy_nonoverlapping_memory(out, &*left, elems);
                         break;
                     }
@@ -1506,7 +1506,7 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
 #[cfg(test)]
 mod tests {
     use core::cmp::Ordering::{Greater, Less, Equal};
-    use core::prelude::{Some, None, range, Clone};
+    use core::prelude::{Some, None, Clone};
     use core::prelude::{Iterator, IteratorExt};
     use core::prelude::{AsSlice};
     use core::prelude::Ord;
@@ -1519,56 +1519,56 @@ mod tests {
     use vec::Vec;
     use super::{ElementSwaps, SliceConcatExt, SliceExt};
 
-    fn square(n: uint) -> uint { n * n }
+    fn square(n: usize) -> usize { n * n }
 
-    fn is_odd(n: &uint) -> bool { *n % 2u == 1u }
+    fn is_odd(n: &usize) -> bool { *n % 2 == 1 }
 
     #[test]
     fn test_from_fn() {
         // Test on-stack from_fn.
-        let mut v = (0u..3).map(square).collect::<Vec<_>>();
+        let mut v: Vec<_> = (0..3).map(square).collect();
         {
             let v = v;
-            assert_eq!(v.len(), 3u);
-            assert_eq!(v[0], 0u);
-            assert_eq!(v[1], 1u);
-            assert_eq!(v[2], 4u);
+            assert_eq!(v.len(), 3);
+            assert_eq!(v[0], 0);
+            assert_eq!(v[1], 1);
+            assert_eq!(v[2], 4);
         }
 
         // Test on-heap from_fn.
-        v = (0u..5).map(square).collect::<Vec<_>>();
+        v = (0..5).map(square).collect();
         {
             let v = v;
-            assert_eq!(v.len(), 5u);
-            assert_eq!(v[0], 0u);
-            assert_eq!(v[1], 1u);
-            assert_eq!(v[2], 4u);
-            assert_eq!(v[3], 9u);
-            assert_eq!(v[4], 16u);
+            assert_eq!(v.len(), 5);
+            assert_eq!(v[0], 0);
+            assert_eq!(v[1], 1);
+            assert_eq!(v[2], 4);
+            assert_eq!(v[3], 9);
+            assert_eq!(v[4], 16);
         }
     }
 
     #[test]
     fn test_from_elem() {
         // Test on-stack from_elem.
-        let mut v = vec![10u, 10u];
+        let mut v = vec![10, 10];
         {
             let v = v;
-            assert_eq!(v.len(), 2u);
-            assert_eq!(v[0], 10u);
-            assert_eq!(v[1], 10u);
+            assert_eq!(v.len(), 2);
+            assert_eq!(v[0], 10);
+            assert_eq!(v[1], 10);
         }
 
         // Test on-heap from_elem.
-        v = vec![20u, 20u, 20u, 20u, 20u, 20u];
+        v = vec![20; 6];
         {
-            let v = v;
-            assert_eq!(v[0], 20u);
-            assert_eq!(v[1], 20u);
-            assert_eq!(v[2], 20u);
-            assert_eq!(v[3], 20u);
-            assert_eq!(v[4], 20u);
-            assert_eq!(v[5], 20u);
+            let v = v.as_slice();
+            assert_eq!(v[0], 20);
+            assert_eq!(v[1], 20);
+            assert_eq!(v[2], 20);
+            assert_eq!(v[3], 20);
+            assert_eq!(v[4], 20);
+            assert_eq!(v[5], 20);
         }
     }
 
@@ -1624,68 +1624,68 @@ mod tests {
     #[test]
     fn test_tail() {
         let mut a = vec![11];
-        let b: &[int] = &[];
+        let b: &[i32] = &[];
         assert_eq!(a.tail(), b);
         a = vec![11, 12];
-        let b: &[int] = &[12];
+        let b: &[i32] = &[12];
         assert_eq!(a.tail(), b);
     }
 
     #[test]
     fn test_tail_mut() {
         let mut a = vec![11];
-        let b: &mut [int] = &mut [];
+        let b: &mut [i32] = &mut [];
         assert!(a.tail_mut() == b);
         a = vec![11, 12];
-        let b: &mut [int] = &mut [12];
+        let b: &mut [_] = &mut [12];
         assert!(a.tail_mut() == b);
     }
 
     #[test]
     #[should_fail]
     fn test_tail_empty() {
-        let a: Vec<int> = vec![];
+        let a = Vec::<i32>::new();
         a.tail();
     }
 
     #[test]
     #[should_fail]
     fn test_tail_mut_empty() {
-        let mut a: Vec<int> = vec![];
+        let mut a = Vec::<i32>::new();
         a.tail_mut();
     }
 
     #[test]
     fn test_init() {
         let mut a = vec![11];
-        let b: &[int] = &[];
+        let b: &[i32] = &[];
         assert_eq!(a.init(), b);
         a = vec![11, 12];
-        let b: &[int] = &[11];
+        let b: &[_] = &[11];
         assert_eq!(a.init(), b);
     }
 
     #[test]
     fn test_init_mut() {
         let mut a = vec![11];
-        let b: &mut [int] = &mut [];
+        let b: &mut [i32] = &mut [];
         assert!(a.init_mut() == b);
         a = vec![11, 12];
-        let b: &mut [int] = &mut [11];
+        let b: &mut [_] = &mut [11];
         assert!(a.init_mut() == b);
     }
 
     #[test]
     #[should_fail]
     fn test_init_empty() {
-        let a: Vec<int> = vec![];
+        let a = Vec::<i32>::new();
         a.init();
     }
 
     #[test]
     #[should_fail]
     fn test_init_mut_empty() {
-        let mut a: Vec<int> = vec![];
+        let mut a = Vec::<i32>::new();
         a.init_mut();
     }
 
@@ -1713,26 +1713,26 @@ mod tests {
     fn test_slice() {
         // Test fixed length vector.
         let vec_fixed = [1, 2, 3, 4];
-        let v_a = vec_fixed[1u..vec_fixed.len()].to_vec();
-        assert_eq!(v_a.len(), 3u);
-        let v_a = v_a;
+        let v_a = vec_fixed[1..vec_fixed.len()].to_vec();
+        assert_eq!(v_a.len(), 3);
+
         assert_eq!(v_a[0], 2);
         assert_eq!(v_a[1], 3);
         assert_eq!(v_a[2], 4);
 
         // Test on stack.
         let vec_stack: &[_] = &[1, 2, 3];
-        let v_b = vec_stack[1u..3u].to_vec();
-        assert_eq!(v_b.len(), 2u);
-        let v_b = v_b;
+        let v_b = vec_stack[1..3].to_vec();
+        assert_eq!(v_b.len(), 2);
+
         assert_eq!(v_b[0], 2);
         assert_eq!(v_b[1], 3);
 
         // Test `Box<[T]>`
         let vec_unique = vec![1, 2, 3, 4, 5, 6];
-        let v_d = vec_unique[1u..6u].to_vec();
-        assert_eq!(v_d.len(), 5u);
-        let v_d = v_d;
+        let v_d = vec_unique[1..6].to_vec();
+        assert_eq!(v_d.len(), 5);
+
         assert_eq!(v_d[0], 2);
         assert_eq!(v_d[1], 3);
         assert_eq!(v_d[2], 4);
@@ -1742,21 +1742,21 @@ mod tests {
 
     #[test]
     fn test_slice_from() {
-        let vec: &[int] = &[1, 2, 3, 4];
+        let vec: &[_] = &[1, 2, 3, 4];
         assert_eq!(&vec[], vec);
-        let b: &[int] = &[3, 4];
+        let b: &[_] = &[3, 4];
         assert_eq!(&vec[2..], b);
-        let b: &[int] = &[];
+        let b: &[_] = &[];
         assert_eq!(&vec[4..], b);
     }
 
     #[test]
     fn test_slice_to() {
-        let vec: &[int] = &[1, 2, 3, 4];
+        let vec: &[_] = &[1, 2, 3, 4];
         assert_eq!(&vec[..4], vec);
-        let b: &[int] = &[1, 2];
+        let b: &[_] = &[1, 2];
         assert_eq!(&vec[..2], b);
-        let b: &[int] = &[];
+        let b: &[_] = &[];
         assert_eq!(&vec[..0], b);
     }
 
@@ -1812,12 +1812,12 @@ mod tests {
         // Test on-stack push().
         let mut v = vec![];
         v.push(1);
-        assert_eq!(v.len(), 1u);
+        assert_eq!(v.len(), 1);
         assert_eq!(v[0], 1);
 
         // Test on-heap push().
         v.push(2);
-        assert_eq!(v.len(), 2u);
+        assert_eq!(v.len(), 2);
         assert_eq!(v[0], 1);
         assert_eq!(v[1], 2);
     }
@@ -1842,19 +1842,19 @@ mod tests {
 
     #[test]
     fn test_dedup() {
-        fn case(a: Vec<uint>, b: Vec<uint>) {
+        fn case(a: Vec<i32>, b: Vec<i32>) {
             let mut v = a;
             v.dedup();
             assert_eq!(v, b);
         }
         case(vec![], vec![]);
-        case(vec![1u], vec![1]);
-        case(vec![1u,1], vec![1]);
-        case(vec![1u,2,3], vec![1,2,3]);
-        case(vec![1u,1,2,3], vec![1,2,3]);
-        case(vec![1u,2,2,3], vec![1,2,3]);
-        case(vec![1u,2,3,3], vec![1,2,3]);
-        case(vec![1u,1,2,2,2,3,3], vec![1,2,3]);
+        case(vec![1], vec![1]);
+        case(vec![1,1], vec![1]);
+        case(vec![1,2,3], vec![1,2,3]);
+        case(vec![1,1,2,3], vec![1,2,3]);
+        case(vec![1,2,2,3], vec![1,2,3]);
+        case(vec![1,2,3,3], vec![1,2,3]);
+        case(vec![1,1,2,2,2,3,3], vec![1,2,3]);
     }
 
     #[test]
@@ -1887,9 +1887,9 @@ mod tests {
 
     #[test]
     fn test_retain() {
-        let mut v = vec![1u, 2, 3, 4, 5];
+        let mut v = vec![1, 2, 3, 4, 5];
         v.retain(is_odd);
-        assert_eq!(v, vec![1u, 3, 5]);
+        assert_eq!(v, vec![1, 3, 5]);
     }
 
     #[test]
@@ -1964,56 +1964,56 @@ mod tests {
 
     #[test]
     fn test_lexicographic_permutations() {
-        let v : &mut[int] = &mut[1, 2, 3, 4, 5];
+        let v : &mut[_] = &mut[1, 2, 3, 4, 5];
         assert!(v.prev_permutation() == false);
         assert!(v.next_permutation());
-        let b: &mut[int] = &mut[1, 2, 3, 5, 4];
+        let b: &mut[_] = &mut[1, 2, 3, 5, 4];
         assert!(v == b);
         assert!(v.prev_permutation());
-        let b: &mut[int] = &mut[1, 2, 3, 4, 5];
+        let b: &mut[_] = &mut[1, 2, 3, 4, 5];
         assert!(v == b);
         assert!(v.next_permutation());
         assert!(v.next_permutation());
-        let b: &mut[int] = &mut[1, 2, 4, 3, 5];
+        let b: &mut[_] = &mut[1, 2, 4, 3, 5];
         assert!(v == b);
         assert!(v.next_permutation());
-        let b: &mut[int] = &mut[1, 2, 4, 5, 3];
+        let b: &mut[_] = &mut[1, 2, 4, 5, 3];
         assert!(v == b);
 
-        let v : &mut[int] = &mut[1, 0, 0, 0];
+        let v : &mut[_] = &mut[1, 0, 0, 0];
         assert!(v.next_permutation() == false);
         assert!(v.prev_permutation());
-        let b: &mut[int] = &mut[0, 1, 0, 0];
+        let b: &mut[_] = &mut[0, 1, 0, 0];
         assert!(v == b);
         assert!(v.prev_permutation());
-        let b: &mut[int] = &mut[0, 0, 1, 0];
+        let b: &mut[_] = &mut[0, 0, 1, 0];
         assert!(v == b);
         assert!(v.prev_permutation());
-        let b: &mut[int] = &mut[0, 0, 0, 1];
+        let b: &mut[_] = &mut[0, 0, 0, 1];
         assert!(v == b);
         assert!(v.prev_permutation() == false);
     }
 
     #[test]
     fn test_lexicographic_permutations_empty_and_short() {
-        let empty : &mut[int] = &mut[];
+        let empty : &mut[i32] = &mut[];
         assert!(empty.next_permutation() == false);
-        let b: &mut[int] = &mut[];
+        let b: &mut[i32] = &mut[];
         assert!(empty == b);
         assert!(empty.prev_permutation() == false);
         assert!(empty == b);
 
-        let one_elem : &mut[int] = &mut[4];
+        let one_elem : &mut[_] = &mut[4];
         assert!(one_elem.prev_permutation() == false);
-        let b: &mut[int] = &mut[4];
+        let b: &mut[_] = &mut[4];
         assert!(one_elem == b);
         assert!(one_elem.next_permutation() == false);
         assert!(one_elem == b);
 
-        let two_elem : &mut[int] = &mut[1, 2];
+        let two_elem : &mut[_] = &mut[1, 2];
         assert!(two_elem.prev_permutation() == false);
-        let b : &mut[int] = &mut[1, 2];
-        let c : &mut[int] = &mut[2, 1];
+        let b : &mut[_] = &mut[1, 2];
+        let c : &mut[_] = &mut[2, 1];
         assert!(two_elem == b);
         assert!(two_elem.next_permutation());
         assert!(two_elem == c);
@@ -2030,9 +2030,9 @@ mod tests {
         assert!([].position_elem(&1).is_none());
 
         let v1 = vec![1, 2, 3, 3, 2, 5];
-        assert_eq!(v1.position_elem(&1), Some(0u));
-        assert_eq!(v1.position_elem(&2), Some(1u));
-        assert_eq!(v1.position_elem(&5), Some(5u));
+        assert_eq!(v1.position_elem(&1), Some(0));
+        assert_eq!(v1.position_elem(&2), Some(1));
+        assert_eq!(v1.position_elem(&5), Some(5));
         assert!(v1.position_elem(&4).is_none());
     }
 
@@ -2083,24 +2083,23 @@ mod tests {
 
     #[test]
     fn test_reverse() {
-        let mut v: Vec<int> = vec![10, 20];
+        let mut v = vec![10, 20];
         assert_eq!(v[0], 10);
         assert_eq!(v[1], 20);
         v.reverse();
         assert_eq!(v[0], 20);
         assert_eq!(v[1], 10);
 
-        let mut v3: Vec<int> = vec![];
+        let mut v3 = Vec::<i32>::new();
         v3.reverse();
         assert!(v3.is_empty());
     }
 
     #[test]
     fn test_sort() {
-        for len in 4u..25 {
+        for len in 4..25 {
             for _ in 0..100 {
-                let mut v = thread_rng().gen_iter::<uint>().take(len)
-                                      .collect::<Vec<uint>>();
+                let mut v: Vec<_> = thread_rng().gen_iter::<i32>().take(len).collect();
                 let mut v1 = v.clone();
 
                 v.sort();
@@ -2115,10 +2114,10 @@ mod tests {
         }
 
         // shouldn't panic
-        let mut v: [uint; 0] = [];
+        let mut v: [i32; 0] = [];
         v.sort();
 
-        let mut v = [0xDEADBEEFu];
+        let mut v = [0xDEADBEEFu64];
         v.sort();
         assert!(v == [0xDEADBEEF]);
     }
@@ -2126,7 +2125,7 @@ mod tests {
     #[test]
     fn test_sort_stability() {
         for len in 4..25 {
-            for _ in 0u..10 {
+            for _ in 0..10 {
                 let mut counts = [0; 10];
 
                 // create a vector like [(6, 1), (5, 1), (6, 2), ...],
@@ -2134,11 +2133,11 @@ mod tests {
                 // the second item represents which occurrence of that
                 // number this element is, i.e. the second elements
                 // will occur in sorted order.
-                let mut v = (0..len).map(|_| {
-                        let n = thread_rng().gen::<uint>() % 10;
+                let mut v: Vec<_> = (0..len).map(|_| {
+                        let n = thread_rng().gen::<usize>() % 10;
                         counts[n] += 1;
                         (n, counts[n])
-                    }).collect::<Vec<(uint, int)>>();
+                    }).collect();
 
                 // only sort on the first element, so an unstable sort
                 // may mix up the counts.
@@ -2156,28 +2155,28 @@ mod tests {
 
     #[test]
     fn test_concat() {
-        let v: [Vec<int>; 0] = [];
-        let c: Vec<int> = v.concat();
+        let v: [Vec<i32>; 0] = [];
+        let c = v.concat();
         assert_eq!(c, []);
-        let d: Vec<int> = [vec![1], vec![2,3]].concat();
+        let d = [vec![1], vec![2,3]].concat();
         assert_eq!(d, vec![1, 2, 3]);
 
-        let v: [&[int]; 2] = [&[1], &[2, 3]];
+        let v: &[&[_]] = &[&[1], &[2, 3]];
         assert_eq!(v.connect(&0), vec![1, 0, 2, 3]);
-        let v: [&[int]; 3] = [&[1], &[2], &[3]];
+        let v: &[&[_]] = &[&[1], &[2], &[3]];
         assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]);
     }
 
     #[test]
     fn test_connect() {
-        let v: [Vec<int>; 0] = [];
+        let v: [Vec<i32>; 0] = [];
         assert_eq!(v.connect(&0), vec![]);
         assert_eq!([vec![1], vec![2, 3]].connect(&0), vec![1, 0, 2, 3]);
         assert_eq!([vec![1], vec![2], vec![3]].connect(&0), vec![1, 0, 2, 0, 3]);
 
-        let v: [&[int]; 2] = [&[1], &[2, 3]];
+        let v: [&[_]; 2] = [&[1], &[2, 3]];
         assert_eq!(v.connect(&0), vec![1, 0, 2, 3]);
-        let v: [&[int]; 3] = [&[1], &[2], &[3]];
+        let v: [&[_]; 3] = [&[1], &[2], &[3]];
         assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]);
     }
 
@@ -2209,13 +2208,13 @@ mod tests {
 
     #[test]
     fn test_remove() {
-        let mut a = vec![1,2,3,4];
+        let mut a = vec![1, 2, 3, 4];
 
         assert_eq!(a.remove(2), 3);
-        assert_eq!(a, vec![1,2,4]);
+        assert_eq!(a, vec![1, 2, 4]);
 
         assert_eq!(a.remove(2), 4);
-        assert_eq!(a, vec![1,2]);
+        assert_eq!(a, vec![1, 2]);
 
         assert_eq!(a.remove(0), 1);
         assert_eq!(a, vec![2]);
@@ -2234,19 +2233,16 @@ mod tests {
 
     #[test]
     fn test_capacity() {
-        let mut v = vec![0u64];
-        v.reserve_exact(10u);
-        assert!(v.capacity() >= 11u);
-        let mut v = vec![0u32];
-        v.reserve_exact(10u);
-        assert!(v.capacity() >= 11u);
+        let mut v = vec![0];
+        v.reserve_exact(10);
+        assert!(v.capacity() >= 11);
     }
 
     #[test]
     fn test_slice_2() {
         let v = vec![1, 2, 3, 4, 5];
-        let v = v.slice(1u, 3u);
-        assert_eq!(v.len(), 2u);
+        let v = v.slice(1, 3);
+        assert_eq!(v.len(), 2);
         assert_eq!(v[0], 2);
         assert_eq!(v[1], 3);
     }
@@ -2256,7 +2252,7 @@ mod tests {
     fn test_permute_fail() {
         let v = [(box 0, Rc::new(0)), (box 0, Rc::new(0)),
                  (box 0, Rc::new(0)), (box 0, Rc::new(0))];
-        let mut i = 0u;
+        let mut i = 0;
         for _ in v.permutations() {
             if i == 2 {
                 panic!()
@@ -2267,15 +2263,15 @@ mod tests {
 
     #[test]
     fn test_total_ord() {
-        let c: &[int] = &[1, 2, 3];
+        let c = &[1, 2, 3];
         [1, 2, 3, 4][].cmp(c) == Greater;
-        let c: &[int] = &[1, 2, 3, 4];
+        let c = &[1, 2, 3, 4];
         [1, 2, 3][].cmp(c) == Less;
-        let c: &[int] = &[1, 2, 3, 6];
+        let c = &[1, 2, 3, 6];
         [1, 2, 3, 4][].cmp(c) == Equal;
-        let c: &[int] = &[1, 2, 3, 4, 5, 6];
+        let c = &[1, 2, 3, 4, 5, 6];
         [1, 2, 3, 4, 5, 5, 5, 5][].cmp(c) == Less;
-        let c: &[int] = &[1, 2, 3, 4];
+        let c = &[1, 2, 3, 4];
         [2, 2][].cmp(c) == Greater;
     }
 
@@ -2377,7 +2373,7 @@ mod tests {
 
     #[test]
     fn test_mut_rev_iterator() {
-        let mut xs = [1u, 2, 3, 4, 5];
+        let mut xs = [1, 2, 3, 4, 5];
         for (i,x) in xs.iter_mut().rev().enumerate() {
             *x += i;
         }
@@ -2386,77 +2382,77 @@ mod tests {
 
     #[test]
     fn test_move_iterator() {
-        let xs = vec![1u,2,3,4,5];
-        assert_eq!(xs.into_iter().fold(0, |a: uint, b: uint| 10*a + b), 12345);
+        let xs = vec![1,2,3,4,5];
+        assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10*a + b), 12345);
     }
 
     #[test]
     fn test_move_rev_iterator() {
-        let xs = vec![1u,2,3,4,5];
-        assert_eq!(xs.into_iter().rev().fold(0, |a: uint, b: uint| 10*a + b), 54321);
+        let xs = vec![1,2,3,4,5];
+        assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10*a + b), 54321);
     }
 
     #[test]
     fn test_splitator() {
         let xs = &[1,2,3,4,5];
 
-        let splits: &[&[int]] = &[&[1], &[3], &[5]];
-        assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[1], &[3], &[5]];
+        assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(),
                    splits);
-        let splits: &[&[int]] = &[&[], &[2,3,4,5]];
-        assert_eq!(xs.split(|x| *x == 1).collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[], &[2,3,4,5]];
+        assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(),
                    splits);
-        let splits: &[&[int]] = &[&[1,2,3,4], &[]];
-        assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[1,2,3,4], &[]];
+        assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(),
                    splits);
-        let splits: &[&[int]] = &[&[1,2,3,4,5]];
-        assert_eq!(xs.split(|x| *x == 10).collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[1,2,3,4,5]];
+        assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(),
                    splits);
-        let splits: &[&[int]] = &[&[], &[], &[], &[], &[], &[]];
-        assert_eq!(xs.split(|_| true).collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]];
+        assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(),
                    splits);
 
-        let xs: &[int] = &[];
-        let splits: &[&[int]] = &[&[]];
-        assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[int]>>(), splits);
+        let xs: &[i32] = &[];
+        let splits: &[&[i32]] = &[&[]];
+        assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
     }
 
     #[test]
     fn test_splitnator() {
         let xs = &[1,2,3,4,5];
 
-        let splits: &[&[int]] = &[&[1,2,3,4,5]];
-        assert_eq!(xs.splitn(0, |x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[1,2,3,4,5]];
+        assert_eq!(xs.splitn(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
                    splits);
-        let splits: &[&[int]] = &[&[1], &[3,4,5]];
-        assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[1], &[3,4,5]];
+        assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
                    splits);
-        let splits: &[&[int]] = &[&[], &[], &[], &[4,5]];
-        assert_eq!(xs.splitn(3, |_| true).collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[], &[], &[], &[4,5]];
+        assert_eq!(xs.splitn(3, |_| true).collect::<Vec<_>>(),
                    splits);
 
-        let xs: &[int] = &[];
-        let splits: &[&[int]] = &[&[]];
-        assert_eq!(xs.splitn(1, |x| *x == 5).collect::<Vec<&[int]>>(), splits);
+        let xs: &[i32] = &[];
+        let splits: &[&[i32]] = &[&[]];
+        assert_eq!(xs.splitn(1, |x| *x == 5).collect::<Vec<_>>(), splits);
     }
 
     #[test]
     fn test_splitnator_mut() {
         let xs = &mut [1,2,3,4,5];
 
-        let splits: &[&mut [int]] = &[&mut [1,2,3,4,5]];
-        assert_eq!(xs.splitn_mut(0, |x| *x % 2 == 0).collect::<Vec<&mut [int]>>(),
+        let splits: &[&mut[_]] = &[&mut [1,2,3,4,5]];
+        assert_eq!(xs.splitn_mut(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
                    splits);
-        let splits: &[&mut [int]] = &[&mut [1], &mut [3,4,5]];
-        assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<&mut [int]>>(),
+        let splits: &[&mut[_]] = &[&mut [1], &mut [3,4,5]];
+        assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
                    splits);
-        let splits: &[&mut [int]] = &[&mut [], &mut [], &mut [], &mut [4,5]];
-        assert_eq!(xs.splitn_mut(3, |_| true).collect::<Vec<&mut [int]>>(),
+        let splits: &[&mut[_]] = &[&mut [], &mut [], &mut [], &mut [4,5]];
+        assert_eq!(xs.splitn_mut(3, |_| true).collect::<Vec<_>>(),
                    splits);
 
-        let xs: &mut [int] = &mut [];
-        let splits: &[&mut [int]] = &[&mut []];
-        assert_eq!(xs.splitn_mut(1, |x| *x == 5).collect::<Vec<&mut [int]>>(),
+        let xs: &mut [i32] = &mut [];
+        let splits: &[&mut[i32]] = &[&mut []];
+        assert_eq!(xs.splitn_mut(1, |x| *x == 5).collect::<Vec<_>>(),
                    splits);
     }
 
@@ -2464,51 +2460,52 @@ mod tests {
     fn test_rsplitator() {
         let xs = &[1,2,3,4,5];
 
-        let splits: &[&[int]] = &[&[5], &[3], &[1]];
-        assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[5], &[3], &[1]];
+        assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(),
                    splits);
-        let splits: &[&[int]] = &[&[2,3,4,5], &[]];
-        assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[2,3,4,5], &[]];
+        assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(),
                    splits);
-        let splits: &[&[int]] = &[&[], &[1,2,3,4]];
-        assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[], &[1,2,3,4]];
+        assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(),
                    splits);
-        let splits: &[&[int]] = &[&[1,2,3,4,5]];
-        assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[1,2,3,4,5]];
+        assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(),
                    splits);
 
-        let xs: &[int] = &[];
-        let splits: &[&[int]] = &[&[]];
-        assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[int]>>(), splits);
+        let xs: &[i32] = &[];
+        let splits: &[&[i32]] = &[&[]];
+        assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
     }
 
     #[test]
     fn test_rsplitnator() {
         let xs = &[1,2,3,4,5];
 
-        let splits: &[&[int]] = &[&[1,2,3,4,5]];
-        assert_eq!(xs.rsplitn(0, |x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[1,2,3,4,5]];
+        assert_eq!(xs.rsplitn(0, |x| *x % 2 == 0).collect::<Vec<_>>(),
                    splits);
-        let splits: &[&[int]] = &[&[5], &[1,2,3]];
-        assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[5], &[1,2,3]];
+        assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
                    splits);
-        let splits: &[&[int]] = &[&[], &[], &[], &[1,2]];
-        assert_eq!(xs.rsplitn(3, |_| true).collect::<Vec<&[int]>>(),
+        let splits: &[&[_]] = &[&[], &[], &[], &[1,2]];
+        assert_eq!(xs.rsplitn(3, |_| true).collect::<Vec<_>>(),
                    splits);
 
-        let xs: &[int] = &[];
-        let splits: &[&[int]] = &[&[]];
-        assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::<Vec<&[int]>>(), splits);
+        let xs: &[i32]  = &[];
+        let splits: &[&[i32]] = &[&[]];
+        assert_eq!(xs.rsplitn(1, |x| *x == 5).collect::<Vec<&[i32]>>(), splits);
     }
 
     #[test]
     fn test_windowsator() {
         let v = &[1,2,3,4];
 
-        let wins: &[&[int]] = &[&[1,2], &[2,3], &[3,4]];
-        assert_eq!(v.windows(2).collect::<Vec<&[int]>>(), wins);
-        let wins: &[&[int]] = &[&[1,2,3], &[2,3,4]];
-        assert_eq!(v.windows(3).collect::<Vec<&[int]>>(), wins);
+        let wins: &[&[_]] = &[&[1,2], &[2,3], &[3,4]];
+        assert_eq!(v.windows(2).collect::<Vec<_>>(), wins);
+
+        let wins: &[&[_]] = &[&[1,2,3], &[2,3,4]];
+        assert_eq!(v.windows(3).collect::<Vec<_>>(), wins);
         assert!(v.windows(6).next().is_none());
     }
 
@@ -2527,22 +2524,23 @@ mod tests {
 
         assert_eq!(v.chunks(2).len(), 3);
 
-        let chunks: &[&[int]] = &[&[1,2], &[3,4], &[5]];
-        assert_eq!(v.chunks(2).collect::<Vec<&[int]>>(), chunks);
-        let chunks: &[&[int]] = &[&[1,2,3], &[4,5]];
-        assert_eq!(v.chunks(3).collect::<Vec<&[int]>>(), chunks);
-        let chunks: &[&[int]] = &[&[1,2,3,4,5]];
-        assert_eq!(v.chunks(6).collect::<Vec<&[int]>>(), chunks);
+        let chunks: &[&[_]] = &[&[1,2], &[3,4], &[5]];
+        assert_eq!(v.chunks(2).collect::<Vec<_>>(), chunks);
+        let chunks: &[&[_]] = &[&[1,2,3], &[4,5]];
+        assert_eq!(v.chunks(3).collect::<Vec<_>>(), chunks);
+        let chunks: &[&[_]] = &[&[1,2,3,4,5]];
+        assert_eq!(v.chunks(6).collect::<Vec<_>>(), chunks);
 
-        let chunks: &[&[int]] = &[&[5], &[3,4], &[1,2]];
-        assert_eq!(v.chunks(2).rev().collect::<Vec<&[int]>>(), chunks);
+        let chunks: &[&[_]] = &[&[5], &[3,4], &[1,2]];
+        assert_eq!(v.chunks(2).rev().collect::<Vec<_>>(), chunks);
         let mut it = v.chunks(2);
         assert_eq!(it.indexable(), 3);
-        let chunk: &[int] = &[1,2];
+
+        let chunk: &[_] = &[1,2];
         assert_eq!(it.idx(0).unwrap(), chunk);
-        let chunk: &[int] = &[3,4];
+        let chunk: &[_] = &[3,4];
         assert_eq!(it.idx(1).unwrap(), chunk);
-        let chunk: &[int] = &[5];
+        let chunk: &[_] = &[5];
         assert_eq!(it.idx(2).unwrap(), chunk);
         assert_eq!(it.idx(3), None);
     }
@@ -2590,20 +2588,20 @@ mod tests {
                 assert_eq!(format!("{:?}", x), x_str);
             })
         }
-        let empty: Vec<int> = vec![];
+        let empty = Vec::<i32>::new();
         test_show_vec!(empty, "[]");
         test_show_vec!(vec![1], "[1]");
         test_show_vec!(vec![1, 2, 3], "[1, 2, 3]");
-        test_show_vec!(vec![vec![], vec![1u], vec![1u, 1u]],
+        test_show_vec!(vec![vec![], vec![1], vec![1, 1]],
                        "[[], [1], [1, 1]]");
 
-        let empty_mut: &mut [int] = &mut[];
+        let empty_mut: &mut [i32] = &mut[];
         test_show_vec!(empty_mut, "[]");
-        let v: &mut[int] = &mut[1];
+        let v = &mut[1];
         test_show_vec!(v, "[1]");
-        let v: &mut[int] = &mut[1, 2, 3];
+        let v = &mut[1, 2, 3];
         test_show_vec!(v, "[1, 2, 3]");
-        let v: &mut [&mut[uint]] = &mut[&mut[], &mut[1u], &mut[1u, 1u]];
+        let v: &mut[&mut[_]] = &mut[&mut[], &mut[1], &mut[1, 1]];
         test_show_vec!(v, "[[], [1], [1, 1]]");
     }
 
@@ -2616,8 +2614,8 @@ mod tests {
             }}
         }
 
-        t!(&[int]);
-        t!(Vec<int>);
+        t!(&[i32]);
+        t!(Vec<i32>);
     }
 
     #[test]
@@ -2679,7 +2677,7 @@ mod tests {
     fn test_iter_zero_sized() {
         let mut v = vec![Foo, Foo, Foo];
         assert_eq!(v.len(), 3);
-        let mut cnt = 0u;
+        let mut cnt = 0;
 
         for f in &v {
             assert!(*f == Foo);
@@ -2829,15 +2827,15 @@ mod tests {
         let h = x.last_mut();
         assert_eq!(*h.unwrap(), 5);
 
-        let y: &mut [int] = &mut [];
+        let y: &mut [i32] = &mut [];
         assert!(y.last_mut().is_none());
     }
 
     #[test]
     fn test_to_vec() {
-        let xs = box [1u, 2, 3];
+        let xs = box [1, 2, 3];
         let ys = xs.to_vec();
-        assert_eq!(ys, [1u, 2, 3]);
+        assert_eq!(ys, [1, 2, 3]);
     }
 }
 
@@ -2854,7 +2852,7 @@ mod bench {
     fn iterator(b: &mut Bencher) {
         // peculiar numbers to stop LLVM from optimising the summation
         // out.
-        let v = (0u..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect::<Vec<_>>();
+        let v: Vec<_> = (0..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect();
 
         b.iter(|| {
             let mut sum = 0;
@@ -2868,7 +2866,7 @@ mod bench {
 
     #[bench]
     fn mut_iterator(b: &mut Bencher) {
-        let mut v = repeat(0).take(100).collect::<Vec<_>>();
+        let mut v: Vec<_> = repeat(0).take(100).collect();
 
         b.iter(|| {
             let mut i = 0;
@@ -2881,8 +2879,8 @@ mod bench {
 
     #[bench]
     fn concat(b: &mut Bencher) {
-        let xss: Vec<Vec<uint>> =
-            (0..100u).map(|i| (0..i).collect()).collect();
+        let xss: Vec<Vec<i32>> =
+            (0..100).map(|i| (0..i).collect()).collect();
         b.iter(|| {
             xss.concat();
         });
@@ -2890,8 +2888,8 @@ mod bench {
 
     #[bench]
     fn connect(b: &mut Bencher) {
-        let xss: Vec<Vec<uint>> =
-            (0..100u).map(|i| (0..i).collect()).collect();
+        let xss: Vec<Vec<i32>> =
+            (0..100).map(|i| (0..i).collect()).collect();
         b.iter(|| {
             xss.connect(&0)
         });
@@ -2899,7 +2897,7 @@ mod bench {
 
     #[bench]
     fn push(b: &mut Bencher) {
-        let mut vec: Vec<uint> = vec![];
+        let mut vec = Vec::<i32>::new();
         b.iter(|| {
             vec.push(0);
             black_box(&vec);
@@ -2908,7 +2906,7 @@ mod bench {
 
     #[bench]
     fn starts_with_same_vector(b: &mut Bencher) {
-        let vec: Vec<uint> = (0u..100).collect();
+        let vec: Vec<_> = (0..100).collect();
         b.iter(|| {
             vec.starts_with(&vec)
         })
@@ -2916,7 +2914,7 @@ mod bench {
 
     #[bench]
     fn starts_with_single_element(b: &mut Bencher) {
-        let vec: Vec<uint> = vec![0];
+        let vec: Vec<_> = vec![0];
         b.iter(|| {
             vec.starts_with(&vec)
         })
@@ -2924,8 +2922,8 @@ mod bench {
 
     #[bench]
     fn starts_with_diff_one_element_at_end(b: &mut Bencher) {
-        let vec: Vec<uint> = (0u..100).collect();
-        let mut match_vec: Vec<uint> = (0u..99).collect();
+        let vec: Vec<_> = (0..100).collect();
+        let mut match_vec: Vec<_> = (0..99).collect();
         match_vec.push(0);
         b.iter(|| {
             vec.starts_with(&match_vec)
@@ -2934,7 +2932,7 @@ mod bench {
 
     #[bench]
     fn ends_with_same_vector(b: &mut Bencher) {
-        let vec: Vec<uint> = (0u..100).collect();
+        let vec: Vec<_> = (0..100).collect();
         b.iter(|| {
             vec.ends_with(&vec)
         })
@@ -2942,7 +2940,7 @@ mod bench {
 
     #[bench]
     fn ends_with_single_element(b: &mut Bencher) {
-        let vec: Vec<uint> = vec![0];
+        let vec: Vec<_> = vec![0];
         b.iter(|| {
             vec.ends_with(&vec)
         })
@@ -2950,8 +2948,8 @@ mod bench {
 
     #[bench]
     fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) {
-        let vec: Vec<uint> = (0u..100).collect();
-        let mut match_vec: Vec<uint> = (0u..100).collect();
+        let vec: Vec<_> = (0..100).collect();
+        let mut match_vec: Vec<_> = (0..100).collect();
         match_vec[0] = 200;
         b.iter(|| {
             vec.starts_with(&match_vec)
@@ -2960,9 +2958,9 @@ mod bench {
 
     #[bench]
     fn contains_last_element(b: &mut Bencher) {
-        let vec: Vec<uint> = (0u..100).collect();
+        let vec: Vec<_> = (0..100).collect();
         b.iter(|| {
-            vec.contains(&99u)
+            vec.contains(&99)
         })
     }
 
@@ -2976,7 +2974,7 @@ mod bench {
     #[bench]
     fn zero_1kb_set_memory(b: &mut Bencher) {
         b.iter(|| {
-            let mut v: Vec<uint> = Vec::with_capacity(1024);
+            let mut v = Vec::<u8>::with_capacity(1024);
             unsafe {
                 let vp = v.as_mut_ptr();
                 ptr::set_memory(vp, 0, 1024);
@@ -2989,11 +2987,11 @@ mod bench {
     #[bench]
     fn zero_1kb_loop_set(b: &mut Bencher) {
         b.iter(|| {
-            let mut v: Vec<uint> = Vec::with_capacity(1024);
+            let mut v = Vec::<u8>::with_capacity(1024);
             unsafe {
                 v.set_len(1024);
             }
-            for i in 0u..1024 {
+            for i in 0..1024 {
                 v[i] = 0;
             }
         });
@@ -3002,7 +3000,7 @@ mod bench {
     #[bench]
     fn zero_1kb_mut_iter(b: &mut Bencher) {
         b.iter(|| {
-            let mut v = Vec::with_capacity(1024);
+            let mut v = Vec::<u8>::with_capacity(1024);
             unsafe {
                 v.set_len(1024);
             }
@@ -3017,10 +3015,10 @@ mod bench {
     fn random_inserts(b: &mut Bencher) {
         let mut rng = weak_rng();
         b.iter(|| {
-            let mut v = repeat((0u, 0u)).take(30).collect::<Vec<_>>();
-            for _ in 0u..100 {
+            let mut v: Vec<_> = repeat((0, 0)).take(30).collect();
+            for _ in 0..100 {
                 let l = v.len();
-                v.insert(rng.gen::<uint>() % (l + 1),
+                v.insert(rng.gen::<usize>() % (l + 1),
                          (1, 1));
             }
         })
@@ -3029,10 +3027,10 @@ mod bench {
     fn random_removes(b: &mut Bencher) {
         let mut rng = weak_rng();
         b.iter(|| {
-            let mut v = repeat((0u, 0u)).take(130).collect::<Vec<_>>();
-            for _ in 0u..100 {
+            let mut v: Vec<_> = repeat((0, 0)).take(130).collect();
+            for _ in 0..100 {
                 let l = v.len();
-                v.remove(rng.gen::<uint>() % l);
+                v.remove(rng.gen::<usize>() % l);
             }
         })
     }
@@ -3041,7 +3039,7 @@ mod bench {
     fn sort_random_small(b: &mut Bencher) {
         let mut rng = weak_rng();
         b.iter(|| {
-            let mut v = rng.gen_iter::<u64>().take(5).collect::<Vec<u64>>();
+            let mut v: Vec<_> = rng.gen_iter::<u64>().take(5).collect();
             v.sort();
         });
         b.bytes = 5 * mem::size_of::<u64>() as u64;
@@ -3051,7 +3049,7 @@ mod bench {
     fn sort_random_medium(b: &mut Bencher) {
         let mut rng = weak_rng();
         b.iter(|| {
-            let mut v = rng.gen_iter::<u64>().take(100).collect::<Vec<u64>>();
+            let mut v: Vec<_> = rng.gen_iter::<u64>().take(100).collect();
             v.sort();
         });
         b.bytes = 100 * mem::size_of::<u64>() as u64;
@@ -3061,7 +3059,7 @@ mod bench {
     fn sort_random_large(b: &mut Bencher) {
         let mut rng = weak_rng();
         b.iter(|| {
-            let mut v = rng.gen_iter::<u64>().take(10000).collect::<Vec<u64>>();
+            let mut v: Vec<_> = rng.gen_iter::<u64>().take(10000).collect();
             v.sort();
         });
         b.bytes = 10000 * mem::size_of::<u64>() as u64;
@@ -3069,14 +3067,14 @@ mod bench {
 
     #[bench]
     fn sort_sorted(b: &mut Bencher) {
-        let mut v = (0u..10000).collect::<Vec<_>>();
+        let mut v: Vec<_> = (0..10000).collect();
         b.iter(|| {
             v.sort();
         });
         b.bytes = (v.len() * mem::size_of_val(&v[0])) as u64;
     }
 
-    type BigSortable = (u64,u64,u64,u64);
+    type BigSortable = (u64, u64, u64, u64);
 
     #[bench]
     fn sort_big_random_small(b: &mut Bencher) {
@@ -3113,7 +3111,7 @@ mod bench {
 
     #[bench]
     fn sort_big_sorted(b: &mut Bencher) {
-        let mut v = (0..10000u).map(|i| (i, i, i, i)).collect::<Vec<_>>();
+        let mut v: Vec<BigSortable> = (0..10000).map(|i| (i, i, i, i)).collect();
         b.iter(|| {
             v.sort();
         });
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index 336d9fcf5da..65c397359f4 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -241,7 +241,7 @@ impl<'a> Iterator for Decompositions<'a> {
         }
     }
 
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         let (lower, _) = self.iter.size_hint();
         (lower, None)
     }
@@ -367,7 +367,7 @@ impl<'a> Iterator for Utf16Units<'a> {
     fn next(&mut self) -> Option<u16> { self.encoder.next() }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) { self.encoder.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.encoder.size_hint() }
 }
 
 /*
@@ -464,7 +464,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "this functionality may be moved to libunicode")]
-    fn nfd_chars<'a>(&'a self) -> Decompositions<'a> {
+    fn nfd_chars(&self) -> Decompositions {
         Decompositions {
             iter: self[].chars(),
             buffer: Vec::new(),
@@ -478,7 +478,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "this functionality may be moved to libunicode")]
-    fn nfkd_chars<'a>(&'a self) -> Decompositions<'a> {
+    fn nfkd_chars(&self) -> Decompositions {
         Decompositions {
             iter: self[].chars(),
             buffer: Vec::new(),
@@ -492,7 +492,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "this functionality may be moved to libunicode")]
-    fn nfc_chars<'a>(&'a self) -> Recompositions<'a> {
+    fn nfc_chars(&self) -> Recompositions {
         Recompositions {
             iter: self.nfd_chars(),
             state: Composing,
@@ -507,7 +507,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "this functionality may be moved to libunicode")]
-    fn nfkc_chars<'a>(&'a self) -> Recompositions<'a> {
+    fn nfkc_chars(&self) -> Recompositions {
         Recompositions {
             iter: self.nfkd_chars(),
             state: Composing,
@@ -629,7 +629,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// assert_eq!(v, vec![""]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn splitn<P: CharEq>(&self, count: uint, pat: P) -> SplitN<P> {
+    fn splitn<P: CharEq>(&self, count: usize, pat: P) -> SplitN<P> {
         core_str::StrExt::splitn(&self[], count, pat)
     }
 
@@ -679,7 +679,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// assert_eq!(v, vec!["leopard", "tiger", "lionX"]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn rsplitn<P: CharEq>(&self, count: uint, pat: P) -> RSplitN<P> {
+    fn rsplitn<P: CharEq>(&self, count: usize, pat: P) -> RSplitN<P> {
         core_str::StrExt::rsplitn(&self[], count, pat)
     }
 
@@ -694,13 +694,13 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// # Example
     ///
     /// ```rust
-    /// let v: Vec<(uint, uint)> = "abcXXXabcYYYabc".match_indices("abc").collect();
+    /// let v: Vec<(usize, usize)> = "abcXXXabcYYYabc".match_indices("abc").collect();
     /// assert_eq!(v, vec![(0,3), (6,9), (12,15)]);
     ///
-    /// let v: Vec<(uint, uint)> = "1abcabc2".match_indices("abc").collect();
+    /// let v: Vec<(usize, usize)> = "1abcabc2".match_indices("abc").collect();
     /// assert_eq!(v, vec![(1,4), (4,7)]);
     ///
-    /// let v: Vec<(uint, uint)> = "ababa".match_indices("aba").collect();
+    /// let v: Vec<(usize, usize)> = "ababa".match_indices("aba").collect();
     /// assert_eq!(v, vec![(0, 3)]); // only the first `aba`
     /// ```
     #[unstable(feature = "collections",
@@ -762,19 +762,19 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     #[unstable(feature = "collections",
                reason = "use slice notation [a..b] instead")]
     #[deprecated(since = "1.0.0", reason = "use slice notation [a..b] instead")]
-    fn slice(&self, begin: uint, end: uint) -> &str;
+    fn slice(&self, begin: usize, end: usize) -> &str;
 
     /// Deprecated: use `s[a..]` instead.
     #[unstable(feature = "collections",
                reason = "use slice notation [a..b] instead")]
     #[deprecated(since = "1.0.0", reason = "use slice notation [a..] instead")]
-    fn slice_from(&self, begin: uint) -> &str;
+    fn slice_from(&self, begin: usize) -> &str;
 
     /// Deprecated: use `s[..a]` instead.
     #[unstable(feature = "collections",
                reason = "use slice notation [a..b] instead")]
     #[deprecated(since = "1.0.0", reason = "use slice notation [..a] instead")]
-    fn slice_to(&self, end: uint) -> &str;
+    fn slice_to(&self, end: usize) -> &str;
 
     /// Returns a slice of the string from the character range
     /// [`begin`..`end`).
@@ -801,7 +801,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// ```
     #[unstable(feature = "collections",
                reason = "may have yet to prove its worth")]
-    fn slice_chars(&self, begin: uint, end: uint) -> &str {
+    fn slice_chars(&self, begin: usize, end: usize) -> &str {
         core_str::StrExt::slice_chars(&self[], begin, end)
     }
 
@@ -812,7 +812,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// Caller must check both UTF-8 character boundaries and the boundaries of
     /// the entire slice as well.
     #[stable(feature = "rust1", since = "1.0.0")]
-    unsafe fn slice_unchecked(&self, begin: uint, end: uint) -> &str {
+    unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str {
         core_str::StrExt::slice_unchecked(&self[], begin, end)
     }
 
@@ -925,7 +925,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// ```
     #[unstable(feature = "collections",
                reason = "naming is uncertain with container conventions")]
-    fn is_char_boundary(&self, index: uint) -> bool {
+    fn is_char_boundary(&self, index: usize) -> bool {
         core_str::StrExt::is_char_boundary(&self[], index)
     }
 
@@ -945,7 +945,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// use std::str::CharRange;
     ///
     /// let s = "中华Việt Nam";
-    /// let mut i = 0u;
+    /// let mut i = 0;
     /// while i < s.len() {
     ///     let CharRange {ch, next} = s.char_range_at(i);
     ///     println!("{}: {}", i, ch);
@@ -975,7 +975,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     ///
     /// # Return value
     ///
-    /// A record {ch: char, next: uint} containing the char value and the byte
+    /// A record {ch: char, next: usize} containing the char value and the byte
     /// index of the next Unicode character.
     ///
     /// # Panics
@@ -984,7 +984,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// If `i` is not the index of the beginning of a valid UTF-8 character.
     #[unstable(feature = "collections",
                reason = "naming is uncertain with container conventions")]
-    fn char_range_at(&self, start: uint) -> CharRange {
+    fn char_range_at(&self, start: usize) -> CharRange {
         core_str::StrExt::char_range_at(&self[], start)
     }
 
@@ -1000,7 +1000,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// If `i` is not an index following a valid UTF-8 character.
     #[unstable(feature = "collections",
                reason = "naming is uncertain with container conventions")]
-    fn char_range_at_reverse(&self, start: uint) -> CharRange {
+    fn char_range_at_reverse(&self, start: usize) -> CharRange {
         core_str::StrExt::char_range_at_reverse(&self[], start)
     }
 
@@ -1021,7 +1021,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// If `i` is not the index of the beginning of a valid UTF-8 character.
     #[unstable(feature = "collections",
                reason = "naming is uncertain with container conventions")]
-    fn char_at(&self, i: uint) -> char {
+    fn char_at(&self, i: usize) -> char {
         core_str::StrExt::char_at(&self[], i)
     }
 
@@ -1033,7 +1033,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// If `i` is not an index following a valid UTF-8 character.
     #[unstable(feature = "collections",
                reason = "naming is uncertain with container conventions")]
-    fn char_at_reverse(&self, i: uint) -> char {
+    fn char_at_reverse(&self, i: usize) -> char {
         core_str::StrExt::char_at_reverse(&self[], i)
     }
 
@@ -1073,7 +1073,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// assert_eq!(s.find(x), None);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn find<P: CharEq>(&self, pat: P) -> Option<uint> {
+    fn find<P: CharEq>(&self, pat: P) -> Option<usize> {
         core_str::StrExt::find(&self[], pat)
     }
 
@@ -1101,7 +1101,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// assert_eq!(s.rfind(x), None);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn rfind<P: CharEq>(&self, pat: P) -> Option<uint> {
+    fn rfind<P: CharEq>(&self, pat: P) -> Option<usize> {
         core_str::StrExt::rfind(&self[], pat)
     }
 
@@ -1126,7 +1126,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// ```
     #[unstable(feature = "collections",
                reason = "might get removed in favor of a more generic find in the future")]
-    fn find_str(&self, needle: &str) -> Option<uint> {
+    fn find_str(&self, needle: &str) -> Option<usize> {
         core_str::StrExt::find_str(&self[], needle)
     }
 
@@ -1170,7 +1170,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// ```
     #[unstable(feature = "collections",
                reason = "awaiting convention about comparability of arbitrary slices")]
-    fn subslice_offset(&self, inner: &str) -> uint {
+    fn subslice_offset(&self, inner: &str) -> usize {
         core_str::StrExt::subslice_offset(&self[], inner)
     }
 
@@ -1202,7 +1202,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    fn len(&self) -> uint {
+    fn len(&self) -> usize {
         core_str::StrExt::len(&self[])
     }
 
@@ -1264,8 +1264,8 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// # Example
     ///
     /// ```rust
-    /// let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(uint, &str)>>();
-    /// let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
+    /// let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>();
+    /// let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
     /// assert_eq!(gr_inds.as_slice(), b);
     /// ```
     #[unstable(feature = "collections",
@@ -1301,7 +1301,7 @@ pub trait StrExt: Index<RangeFull, Output = str> {
     /// `is_cjk` = `false`) if the locale is unknown.
     #[unstable(feature = "collections",
                reason = "this functionality may only be provided by libunicode")]
-    fn width(&self, is_cjk: bool) -> uint {
+    fn width(&self, is_cjk: bool) -> usize {
         UnicodeStr::width(&self[], is_cjk)
     }
 
@@ -1326,15 +1326,15 @@ pub trait StrExt: Index<RangeFull, Output = str> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl StrExt for str {
-    fn slice(&self, begin: uint, end: uint) -> &str {
+    fn slice(&self, begin: usize, end: usize) -> &str {
         &self[begin..end]
     }
 
-    fn slice_from(&self, begin: uint) -> &str {
+    fn slice_from(&self, begin: usize) -> &str {
         &self[begin..]
     }
 
-    fn slice_to(&self, end: uint) -> &str {
+    fn slice_to(&self, end: usize) -> &str {
         &self[..end]
     }
 }
@@ -1357,51 +1357,51 @@ mod tests {
 
     #[test]
     fn test_len() {
-        assert_eq!("".len(), 0u);
-        assert_eq!("hello world".len(), 11u);
-        assert_eq!("\x63".len(), 1u);
-        assert_eq!("\u{a2}".len(), 2u);
-        assert_eq!("\u{3c0}".len(), 2u);
-        assert_eq!("\u{2620}".len(), 3u);
-        assert_eq!("\u{1d11e}".len(), 4u);
+        assert_eq!("".len(), 0);
+        assert_eq!("hello world".len(), 11);
+        assert_eq!("\x63".len(), 1);
+        assert_eq!("\u{a2}".len(), 2);
+        assert_eq!("\u{3c0}".len(), 2);
+        assert_eq!("\u{2620}".len(), 3);
+        assert_eq!("\u{1d11e}".len(), 4);
 
-        assert_eq!("".chars().count(), 0u);
-        assert_eq!("hello world".chars().count(), 11u);
-        assert_eq!("\x63".chars().count(), 1u);
-        assert_eq!("\u{a2}".chars().count(), 1u);
-        assert_eq!("\u{3c0}".chars().count(), 1u);
-        assert_eq!("\u{2620}".chars().count(), 1u);
-        assert_eq!("\u{1d11e}".chars().count(), 1u);
-        assert_eq!("ประเทศไทย中华Việt Nam".chars().count(), 19u);
+        assert_eq!("".chars().count(), 0);
+        assert_eq!("hello world".chars().count(), 11);
+        assert_eq!("\x63".chars().count(), 1);
+        assert_eq!("\u{a2}".chars().count(), 1);
+        assert_eq!("\u{3c0}".chars().count(), 1);
+        assert_eq!("\u{2620}".chars().count(), 1);
+        assert_eq!("\u{1d11e}".chars().count(), 1);
+        assert_eq!("ประเทศไทย中华Việt Nam".chars().count(), 19);
 
-        assert_eq!("ｈｅｌｌｏ".width(false), 10u);
-        assert_eq!("ｈｅｌｌｏ".width(true), 10u);
-        assert_eq!("\0\0\0\0\0".width(false), 0u);
-        assert_eq!("\0\0\0\0\0".width(true), 0u);
-        assert_eq!("".width(false), 0u);
-        assert_eq!("".width(true), 0u);
-        assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(false), 4u);
-        assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(true), 8u);
+        assert_eq!("ｈｅｌｌｏ".width(false), 10);
+        assert_eq!("ｈｅｌｌｏ".width(true), 10);
+        assert_eq!("\0\0\0\0\0".width(false), 0);
+        assert_eq!("\0\0\0\0\0".width(true), 0);
+        assert_eq!("".width(false), 0);
+        assert_eq!("".width(true), 0);
+        assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(false), 4);
+        assert_eq!("\u{2081}\u{2082}\u{2083}\u{2084}".width(true), 8);
     }
 
     #[test]
     fn test_find() {
-        assert_eq!("hello".find('l'), Some(2u));
-        assert_eq!("hello".find(|c:char| c == 'o'), Some(4u));
+        assert_eq!("hello".find('l'), Some(2));
+        assert_eq!("hello".find(|c:char| c == 'o'), Some(4));
         assert!("hello".find('x').is_none());
         assert!("hello".find(|c:char| c == 'x').is_none());
-        assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30u));
-        assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30u));
+        assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30));
+        assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30));
     }
 
     #[test]
     fn test_rfind() {
-        assert_eq!("hello".rfind('l'), Some(3u));
-        assert_eq!("hello".rfind(|c:char| c == 'o'), Some(4u));
+        assert_eq!("hello".rfind('l'), Some(3));
+        assert_eq!("hello".rfind(|c:char| c == 'o'), Some(4));
         assert!("hello".rfind('x').is_none());
         assert!("hello".rfind(|c:char| c == 'x').is_none());
-        assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30u));
-        assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30u));
+        assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30));
+        assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30));
     }
 
     #[test]
@@ -1424,37 +1424,37 @@ mod tests {
     #[test]
     fn test_find_str() {
         // byte positions
-        assert_eq!("".find_str(""), Some(0u));
+        assert_eq!("".find_str(""), Some(0));
         assert!("banana".find_str("apple pie").is_none());
 
         let data = "abcabc";
-        assert_eq!(data[0u..6u].find_str("ab"), Some(0u));
-        assert_eq!(data[2u..6u].find_str("ab"), Some(3u - 2u));
-        assert!(data[2u..4u].find_str("ab").is_none());
+        assert_eq!(data[0..6].find_str("ab"), Some(0));
+        assert_eq!(data[2..6].find_str("ab"), Some(3 - 2));
+        assert!(data[2..4].find_str("ab").is_none());
 
         let string = "ประเทศไทย中华Việt Nam";
         let mut data = String::from_str(string);
         data.push_str(string);
         assert!(data.find_str("ไท华").is_none());
-        assert_eq!(data[0u..43u].find_str(""), Some(0u));
-        assert_eq!(data[6u..43u].find_str(""), Some(6u - 6u));
+        assert_eq!(data[0..43].find_str(""), Some(0));
+        assert_eq!(data[6..43].find_str(""), Some(6 - 6));
 
-        assert_eq!(data[0u..43u].find_str("ประ"), Some( 0u));
-        assert_eq!(data[0u..43u].find_str("ทศไ"), Some(12u));
-        assert_eq!(data[0u..43u].find_str("ย中"), Some(24u));
-        assert_eq!(data[0u..43u].find_str("iệt"), Some(34u));
-        assert_eq!(data[0u..43u].find_str("Nam"), Some(40u));
+        assert_eq!(data[0..43].find_str("ประ"), Some( 0));
+        assert_eq!(data[0..43].find_str("ทศไ"), Some(12));
+        assert_eq!(data[0..43].find_str("ย中"), Some(24));
+        assert_eq!(data[0..43].find_str("iệt"), Some(34));
+        assert_eq!(data[0..43].find_str("Nam"), Some(40));
 
-        assert_eq!(data[43u..86u].find_str("ประ"), Some(43u - 43u));
-        assert_eq!(data[43u..86u].find_str("ทศไ"), Some(55u - 43u));
-        assert_eq!(data[43u..86u].find_str("ย中"), Some(67u - 43u));
-        assert_eq!(data[43u..86u].find_str("iệt"), Some(77u - 43u));
-        assert_eq!(data[43u..86u].find_str("Nam"), Some(83u - 43u));
+        assert_eq!(data[43..86].find_str("ประ"), Some(43 - 43));
+        assert_eq!(data[43..86].find_str("ทศไ"), Some(55 - 43));
+        assert_eq!(data[43..86].find_str("ย中"), Some(67 - 43));
+        assert_eq!(data[43..86].find_str("iệt"), Some(77 - 43));
+        assert_eq!(data[43..86].find_str("Nam"), Some(83 - 43));
     }
 
     #[test]
     fn test_slice_chars() {
-        fn t(a: &str, b: &str, start: uint) {
+        fn t(a: &str, b: &str, start: usize) {
             assert_eq!(a.slice_chars(start, start + b.chars().count()), b);
         }
         t("", "", 0);
@@ -1527,7 +1527,7 @@ mod tests {
         assert_eq!("bc", unsafe {"abc".slice_unchecked(1, 3)});
         assert_eq!("", unsafe {"abc".slice_unchecked(1, 1)});
         fn a_million_letter_a() -> String {
-            let mut i = 0u;
+            let mut i = 0;
             let mut rs = String::new();
             while i < 100000 {
                 rs.push_str("aaaaaaaaaa");
@@ -1536,7 +1536,7 @@ mod tests {
             rs
         }
         fn half_a_million_letter_a() -> String {
-            let mut i = 0u;
+            let mut i = 0;
             let mut rs = String::new();
             while i < 100000 {
                 rs.push_str("aaaaa");
@@ -1547,7 +1547,7 @@ mod tests {
         let letters = a_million_letter_a();
         assert!(half_a_million_letter_a() ==
             unsafe {String::from_str(letters.slice_unchecked(
-                                     0u,
+                                     0,
                                      500000))});
     }
 
@@ -1644,7 +1644,7 @@ mod tests {
         assert_eq!("华", data.slice(30, 33));
 
         fn a_million_letter_x() -> String {
-            let mut i = 0u;
+            let mut i = 0;
             let mut rs = String::new();
             while i < 100000 {
                 rs.push_str("华华华华华华华华华华");
@@ -1653,7 +1653,7 @@ mod tests {
             rs
         }
         fn half_a_million_letter_x() -> String {
-            let mut i = 0u;
+            let mut i = 0;
             let mut rs = String::new();
             while i < 100000 {
                 rs.push_str("华华华华华");
@@ -1663,23 +1663,23 @@ mod tests {
         }
         let letters = a_million_letter_x();
         assert!(half_a_million_letter_x() ==
-            String::from_str(letters.slice(0u, 3u * 500000u)));
+            String::from_str(letters.slice(0, 3 * 500000)));
     }
 
     #[test]
     fn test_slice_2() {
         let ss = "中华Việt Nam";
 
-        assert_eq!("华", ss.slice(3u, 6u));
-        assert_eq!("Việt Nam", ss.slice(6u, 16u));
+        assert_eq!("华", ss.slice(3, 6));
+        assert_eq!("Việt Nam", ss.slice(6, 16));
 
-        assert_eq!("ab", "abc".slice(0u, 2u));
-        assert_eq!("bc", "abc".slice(1u, 3u));
-        assert_eq!("", "abc".slice(1u, 1u));
+        assert_eq!("ab", "abc".slice(0, 2));
+        assert_eq!("bc", "abc".slice(1, 3));
+        assert_eq!("", "abc".slice(1, 1));
 
-        assert_eq!("中", ss.slice(0u, 3u));
-        assert_eq!("华V", ss.slice(3u, 7u));
-        assert_eq!("", ss.slice(3u, 3u));
+        assert_eq!("中", ss.slice(0, 3));
+        assert_eq!("华V", ss.slice(3, 7));
+        assert_eq!("", ss.slice(3, 3));
         /*0: 中
           3: 华
           6: V
@@ -1695,7 +1695,7 @@ mod tests {
     #[test]
     #[should_fail]
     fn test_slice_fail() {
-        "中华Việt Nam".slice(0u, 2u);
+        "中华Việt Nam".slice(0, 2);
     }
 
     #[test]
@@ -1961,9 +1961,9 @@ mod tests {
 
         let v: Vec<u8> = s1.as_bytes().to_vec();
         let s2: String = String::from_str(from_utf8(&v).unwrap());
-        let mut i: uint = 0u;
-        let n1: uint = s1.len();
-        let n2: uint = v.len();
+        let mut i = 0;
+        let n1 = s1.len();
+        let n2 = v.len();
         assert_eq!(n1, n2);
         while i < n1 {
             let a: u8 = s1.as_bytes()[i];
@@ -1971,7 +1971,7 @@ mod tests {
             debug!("{}", a);
             debug!("{}", b);
             assert_eq!(a, b);
-            i += 1u;
+            i += 1;
         }
     }
 
@@ -2093,7 +2093,7 @@ mod tests {
         let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
 
         let mut pos = 0;
-        let mut it = s.chars();
+        let it = s.chars();
 
         for c in it {
             assert_eq!(c, v[pos]);
@@ -2108,7 +2108,7 @@ mod tests {
         let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
 
         let mut pos = 0;
-        let mut it = s.chars().rev();
+        let it = s.chars().rev();
 
         for c in it {
             assert_eq!(c, v[pos]);
@@ -2188,7 +2188,7 @@ mod tests {
         let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
 
         let mut pos = 0;
-        let mut it = s.char_indices();
+        let it = s.char_indices();
 
         for c in it {
             assert_eq!(c, (p[pos], v[pos]));
@@ -2205,7 +2205,7 @@ mod tests {
         let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
 
         let mut pos = 0;
-        let mut it = s.char_indices().rev();
+        let it = s.char_indices().rev();
 
         for c in it {
             assert_eq!(c, (p[pos], v[pos]));
@@ -2725,11 +2725,11 @@ mod tests {
 
         // test the indices iterators
         let s = "a̐éö̲\r\n";
-        let gr_inds = s.grapheme_indices(true).collect::<Vec<(uint, &str)>>();
-        let b: &[_] = &[(0u, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
+        let gr_inds = s.grapheme_indices(true).collect::<Vec<(usize, &str)>>();
+        let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
         assert_eq!(gr_inds, b);
-        let gr_inds = s.grapheme_indices(true).rev().collect::<Vec<(uint, &str)>>();
-        let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0u, "a̐")];
+        let gr_inds = s.grapheme_indices(true).rev().collect::<Vec<(usize, &str)>>();
+        let b: &[_] = &[(11, "\r\n"), (6, "ö̲"), (3, "é"), (0, "a̐")];
         assert_eq!(gr_inds, b);
         let mut gr_inds_iter = s.grapheme_indices(true);
         {
@@ -2785,7 +2785,7 @@ mod tests {
 
     #[test]
     fn test_str_container() {
-        fn sum_len(v: &[&str]) -> uint {
+        fn sum_len(v: &[&str]) -> usize {
             v.iter().map(|x| x.len()).sum()
         }
 
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index 00e453943a2..63483d30dd2 100644
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -79,7 +79,7 @@ impl String {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_capacity(capacity: uint) -> String {
+    pub fn with_capacity(capacity: usize) -> String {
         String {
             vec: Vec::with_capacity(capacity),
         }
@@ -156,10 +156,10 @@ impl String {
         static TAG_CONT_U8: u8 = 128u8;
         static REPLACEMENT: &'static [u8] = b"\xEF\xBF\xBD"; // U+FFFD in UTF-8
         let total = v.len();
-        fn unsafe_get(xs: &[u8], i: uint) -> u8 {
+        fn unsafe_get(xs: &[u8], i: usize) -> u8 {
             unsafe { *xs.get_unchecked(i) }
         }
-        fn safe_get(xs: &[u8], i: uint, total: uint) -> u8 {
+        fn safe_get(xs: &[u8], i: usize, total: usize) -> u8 {
             if i >= total {
                 0
             } else {
@@ -318,7 +318,7 @@ impl String {
     /// * We assume that the `Vec` contains valid UTF-8.
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn from_raw_parts(buf: *mut u8, length: uint, capacity: uint) -> String {
+    pub unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String {
         String {
             vec: Vec::from_raw_parts(buf, length, capacity),
         }
@@ -374,7 +374,7 @@ impl String {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn capacity(&self) -> uint {
+    pub fn capacity(&self) -> usize {
         self.vec.capacity()
     }
 
@@ -384,7 +384,7 @@ impl String {
     ///
     /// # Panics
     ///
-    /// Panics if the new capacity overflows `uint`.
+    /// Panics if the new capacity overflows `usize`.
     ///
     /// # Examples
     ///
@@ -395,7 +395,7 @@ impl String {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve(&mut self, additional: uint) {
+    pub fn reserve(&mut self, additional: usize) {
         self.vec.reserve(additional)
     }
 
@@ -409,7 +409,7 @@ impl String {
     ///
     /// # Panics
     ///
-    /// Panics if the new capacity overflows `uint`.
+    /// Panics if the new capacity overflows `usize`.
     ///
     /// # Examples
     ///
@@ -420,7 +420,7 @@ impl String {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_exact(&mut self, additional: uint) {
+    pub fn reserve_exact(&mut self, additional: usize) {
         self.vec.reserve_exact(additional)
     }
 
@@ -468,7 +468,7 @@ impl String {
             // Attempt to not use an intermediate buffer by just pushing bytes
             // directly onto this string.
             let slice = RawSlice {
-                data: self.vec.as_ptr().offset(cur_len as int),
+                data: self.vec.as_ptr().offset(cur_len as isize),
                 len: 4,
             };
             let used = ch.encode_utf8(mem::transmute(slice)).unwrap_or(0);
@@ -487,7 +487,7 @@ impl String {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn as_bytes<'a>(&'a self) -> &'a [u8] {
+    pub fn as_bytes(&self) -> &[u8] {
         &self.vec
     }
 
@@ -507,7 +507,7 @@ impl String {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn truncate(&mut self, new_len: uint) {
+    pub fn truncate(&mut self, new_len: usize) {
         assert!(self.is_char_boundary(new_len));
         self.vec.truncate(new_len)
     }
@@ -562,14 +562,14 @@ impl String {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn remove(&mut self, idx: uint) -> char {
+    pub fn remove(&mut self, idx: usize) -> char {
         let len = self.len();
         assert!(idx <= len);
 
         let CharRange { ch, next } = self.char_range_at(idx);
         unsafe {
-            ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as int),
-                             self.vec.as_ptr().offset(next as int),
+            ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as isize),
+                             self.vec.as_ptr().offset(next as isize),
                              len - next);
             self.vec.set_len(len - (next - idx));
         }
@@ -589,7 +589,7 @@ impl String {
     /// this function will panic.
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn insert(&mut self, idx: uint, ch: char) {
+    pub fn insert(&mut self, idx: usize, ch: char) {
         let len = self.len();
         assert!(idx <= len);
         assert!(self.is_char_boundary(idx));
@@ -598,10 +598,10 @@ impl String {
         let amt = ch.encode_utf8(&mut bits).unwrap();
 
         unsafe {
-            ptr::copy_memory(self.vec.as_mut_ptr().offset((idx + amt) as int),
-                             self.vec.as_ptr().offset(idx as int),
+            ptr::copy_memory(self.vec.as_mut_ptr().offset((idx + amt) as isize),
+                             self.vec.as_ptr().offset(idx as isize),
                              len - idx);
-            ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as int),
+            ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as isize),
                              bits.as_ptr(),
                              amt);
             self.vec.set_len(len + amt);
@@ -626,7 +626,7 @@ impl String {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn as_mut_vec<'a>(&'a mut self) -> &'a mut Vec<u8> {
+    pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8> {
         &mut self.vec
     }
 
@@ -640,7 +640,7 @@ impl String {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> uint { self.vec.len() }
+    pub fn len(&self) -> usize { self.vec.len() }
 
     /// Returns true if the string contains no bytes
     ///
@@ -802,7 +802,7 @@ impl<'a, 'b> PartialEq<CowString<'a>> for &'b str {
 impl Str for String {
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn as_slice<'a>(&'a self) -> &'a str {
+    fn as_slice(&self) -> &str {
         unsafe { mem::transmute(&*self.vec) }
     }
 }
@@ -853,26 +853,26 @@ impl<'a> Add<&'a str> for String {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::Range<uint>> for String {
+impl ops::Index<ops::Range<usize>> for String {
     type Output = str;
     #[inline]
-    fn index(&self, index: &ops::Range<uint>) -> &str {
+    fn index(&self, index: &ops::Range<usize>) -> &str {
         &self[][*index]
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeTo<uint>> for String {
+impl ops::Index<ops::RangeTo<usize>> for String {
     type Output = str;
     #[inline]
-    fn index(&self, index: &ops::RangeTo<uint>) -> &str {
+    fn index(&self, index: &ops::RangeTo<usize>) -> &str {
         &self[][*index]
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeFrom<uint>> for String {
+impl ops::Index<ops::RangeFrom<usize>> for String {
     type Output = str;
     #[inline]
-    fn index(&self, index: &ops::RangeFrom<uint>) -> &str {
+    fn index(&self, index: &ops::RangeFrom<usize>) -> &str {
         &self[][*index]
     }
 }
@@ -890,7 +890,7 @@ impl ops::Deref for String {
     type Target = str;
 
     #[inline]
-    fn deref<'a>(&'a self) -> &'a str {
+    fn deref(&self) -> &str {
         unsafe { mem::transmute(&self.vec[]) }
     }
 }
@@ -1297,7 +1297,7 @@ mod tests {
     fn test_simple_types() {
         assert_eq!(1.to_string(), "1");
         assert_eq!((-1).to_string(), "-1");
-        assert_eq!(200u.to_string(), "200");
+        assert_eq!(200.to_string(), "200");
         assert_eq!(2u8.to_string(), "2");
         assert_eq!(true.to_string(), "true");
         assert_eq!(false.to_string(), "false");
@@ -1306,7 +1306,7 @@ mod tests {
 
     #[test]
     fn test_vectors() {
-        let x: Vec<int> = vec![];
+        let x: Vec<i32> = vec![];
         assert_eq!(format!("{:?}", x), "[]");
         assert_eq!(format!("{:?}", vec![1]), "[1]");
         assert_eq!(format!("{:?}", vec![1, 2, 3]), "[1, 2, 3]");
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 8218469d6af..c6c8beec870 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -66,7 +66,7 @@ use core::ops;
 use core::ptr;
 use core::raw::Slice as RawSlice;
 use core::slice;
-use core::uint;
+use core::usize;
 
 /// A growable list type, written `Vec<T>` but pronounced 'vector.'
 ///
@@ -138,8 +138,8 @@ use core::uint;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Vec<T> {
     ptr: NonZero<*mut T>,
-    len: uint,
-    cap: uint,
+    len: usize,
+    cap: usize,
 }
 
 unsafe impl<T: Send> Send for Vec<T> { }
@@ -196,9 +196,9 @@ impl<T> Vec<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_capacity(capacity: uint) -> Vec<T> {
+    pub fn with_capacity(capacity: usize) -> Vec<T> {
         if mem::size_of::<T>() == 0 {
-            Vec { ptr: unsafe { NonZero::new(EMPTY as *mut T) }, len: 0, cap: uint::MAX }
+            Vec { ptr: unsafe { NonZero::new(EMPTY as *mut T) }, len: 0, cap: usize::MAX }
         } else if capacity == 0 {
             Vec::new()
         } else {
@@ -234,7 +234,7 @@ impl<T> Vec<T> {
     ///         mem::forget(v);
     ///
     ///         // Overwrite memory with 4, 5, 6
-    ///         for i in 0..len as int {
+    ///         for i in 0..len as isize {
     ///             ptr::write(p.offset(i), 4 + i);
     ///         }
     ///
@@ -245,8 +245,8 @@ impl<T> Vec<T> {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn from_raw_parts(ptr: *mut T, length: uint,
-                                 capacity: uint) -> Vec<T> {
+    pub unsafe fn from_raw_parts(ptr: *mut T, length: usize,
+                                 capacity: usize) -> Vec<T> {
         Vec { ptr: NonZero::new(ptr), len: length, cap: capacity }
     }
 
@@ -258,7 +258,7 @@ impl<T> Vec<T> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "may be better expressed via composition")]
-    pub unsafe fn from_raw_buf(ptr: *const T, elts: uint) -> Vec<T> {
+    pub unsafe fn from_raw_buf(ptr: *const T, elts: usize) -> Vec<T> {
         let mut dst = Vec::with_capacity(elts);
         dst.set_len(elts);
         ptr::copy_nonoverlapping_memory(dst.as_mut_ptr(), ptr, elts);
@@ -276,7 +276,7 @@ impl<T> Vec<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn capacity(&self) -> uint {
+    pub fn capacity(&self) -> usize {
         self.cap
     }
 
@@ -285,7 +285,7 @@ impl<T> Vec<T> {
     ///
     /// # Panics
     ///
-    /// Panics if the new capacity overflows `uint`.
+    /// Panics if the new capacity overflows `usize`.
     ///
     /// # Examples
     ///
@@ -295,9 +295,9 @@ impl<T> Vec<T> {
     /// assert!(vec.capacity() >= 11);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve(&mut self, additional: uint) {
+    pub fn reserve(&mut self, additional: usize) {
         if self.cap - self.len < additional {
-            let err_msg = "Vec::reserve: `uint` overflow";
+            let err_msg = "Vec::reserve: `usize` overflow";
             let new_cap = self.len.checked_add(additional).expect(err_msg)
                 .checked_next_power_of_two().expect(err_msg);
             self.grow_capacity(new_cap);
@@ -314,7 +314,7 @@ impl<T> Vec<T> {
     ///
     /// # Panics
     ///
-    /// Panics if the new capacity overflows `uint`.
+    /// Panics if the new capacity overflows `usize`.
     ///
     /// # Examples
     ///
@@ -324,10 +324,10 @@ impl<T> Vec<T> {
     /// assert!(vec.capacity() >= 11);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_exact(&mut self, additional: uint) {
+    pub fn reserve_exact(&mut self, additional: usize) {
         if self.cap - self.len < additional {
             match self.len.checked_add(additional) {
-                None => panic!("Vec::reserve: `uint` overflow"),
+                None => panic!("Vec::reserve: `usize` overflow"),
                 Some(new_cap) => self.grow_capacity(new_cap)
             }
         }
@@ -401,7 +401,7 @@ impl<T> Vec<T> {
     /// assert_eq!(vec, vec![1, 2]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn truncate(&mut self, len: uint) {
+    pub fn truncate(&mut self, len: usize) {
         unsafe {
             // drop any extra elements
             while len < self.len {
@@ -425,7 +425,7 @@ impl<T> Vec<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn as_mut_slice<'a>(&'a mut self) -> &'a mut [T] {
+    pub fn as_mut_slice(&mut self) -> &mut [T] {
         unsafe {
             mem::transmute(RawSlice {
                 data: *self.ptr,
@@ -455,9 +455,9 @@ impl<T> Vec<T> {
             let cap = self.cap;
             let begin = ptr as *const T;
             let end = if mem::size_of::<T>() == 0 {
-                (ptr as uint + self.len()) as *const T
+                (ptr as usize + self.len()) as *const T
             } else {
-                ptr.offset(self.len() as int) as *const T
+                ptr.offset(self.len() as isize) as *const T
             };
             mem::forget(self);
             IntoIter { allocation: ptr, cap: cap, ptr: begin, end: end }
@@ -473,14 +473,14 @@ impl<T> Vec<T> {
     /// # Examples
     ///
     /// ```
-    /// let mut v = vec![1u, 2, 3, 4];
+    /// let mut v = vec![1, 2, 3, 4];
     /// unsafe {
     ///     v.set_len(1);
     /// }
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn set_len(&mut self, len: uint) {
+    pub unsafe fn set_len(&mut self, len: usize) {
         self.len = len;
     }
 
@@ -506,7 +506,7 @@ impl<T> Vec<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn swap_remove(&mut self, index: uint) -> T {
+    pub fn swap_remove(&mut self, index: usize) -> T {
         let length = self.len();
         self.swap(index, length - 1);
         self.pop().unwrap()
@@ -530,7 +530,7 @@ impl<T> Vec<T> {
     /// assert_eq!(vec, vec![1, 4, 2, 3, 5]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn insert(&mut self, index: uint, element: T) {
+    pub fn insert(&mut self, index: usize, element: T) {
         let len = self.len();
         assert!(index <= len);
         // space for the new element
@@ -539,7 +539,7 @@ impl<T> Vec<T> {
         unsafe { // infallible
             // The spot to put the new value
             {
-                let p = self.as_mut_ptr().offset(index as int);
+                let p = self.as_mut_ptr().offset(index as isize);
                 // Shift everything over to make space. (Duplicating the
                 // `index`th element into two consecutive places.)
                 ptr::copy_memory(p.offset(1), &*p, len - index);
@@ -566,14 +566,14 @@ impl<T> Vec<T> {
     /// assert_eq!(v, vec![1, 3]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn remove(&mut self, index: uint) -> T {
+    pub fn remove(&mut self, index: usize) -> T {
         let len = self.len();
         assert!(index < len);
         unsafe { // infallible
             let ret;
             {
                 // the place we are taking from.
-                let ptr = self.as_mut_ptr().offset(index as int);
+                let ptr = self.as_mut_ptr().offset(index as isize);
                 // copy it out, unsafely having a copy of the value on
                 // the stack and in the vector at the same time.
                 ret = ptr::read(ptr);
@@ -602,11 +602,11 @@ impl<T> Vec<T> {
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn retain<F>(&mut self, mut f: F) where F: FnMut(&T) -> bool {
         let len = self.len();
-        let mut del = 0u;
+        let mut del = 0;
         {
             let v = &mut **self;
 
-            for i in 0u..len {
+            for i in 0..len {
                 if !f(&v[i]) {
                     del += 1;
                 } else if del > 0 {
@@ -623,7 +623,7 @@ impl<T> Vec<T> {
     ///
     /// # Panics
     ///
-    /// Panics if the number of elements in the vector overflows a `uint`.
+    /// Panics if the number of elements in the vector overflows a `usize`.
     ///
     /// # Examples
     ///
@@ -655,7 +655,7 @@ impl<T> Vec<T> {
         }
 
         unsafe {
-            let end = (*self.ptr).offset(self.len as int);
+            let end = (*self.ptr).offset(self.len as isize);
             ptr::write(&mut *end, value);
             self.len += 1;
         }
@@ -687,7 +687,7 @@ impl<T> Vec<T> {
     ///
     /// # Panics
     ///
-    /// Panics if the number of elements in the vector overflows a `uint`.
+    /// Panics if the number of elements in the vector overflows a `usize`.
     ///
     /// # Examples
     /// ```rust
@@ -737,13 +737,13 @@ impl<T> Vec<T> {
     #[inline]
     #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
-    pub fn drain<'a>(&'a mut self) -> Drain<'a, T> {
+    pub fn drain(&mut self) -> Drain<T> {
         unsafe {
             let begin = *self.ptr as *const T;
             let end = if mem::size_of::<T>() == 0 {
-                (*self.ptr as uint + self.len()) as *const T
+                (*self.ptr as usize + self.len()) as *const T
             } else {
-                (*self.ptr).offset(self.len() as int) as *const T
+                (*self.ptr).offset(self.len() as isize) as *const T
             };
             self.set_len(0);
             Drain {
@@ -781,7 +781,7 @@ impl<T> Vec<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> uint { self.len }
+    pub fn len(&self) -> usize { self.len }
 
     /// Returns `true` if the vector contains no elements.
     ///
@@ -808,7 +808,7 @@ impl<T> Vec<T> {
     /// # Examples
     ///
     /// ```
-    /// let v = vec![0u, 1, 2];
+    /// let v = vec![0, 1, 2];
     /// let w = v.map_in_place(|i| i + 3);
     /// assert_eq!(w.as_slice(), [3, 4, 5].as_slice());
     ///
@@ -835,7 +835,7 @@ impl<T> Vec<T> {
             // types are passed to the allocator by `Vec`.
             assert!(mem::min_align_of::<T>() == mem::min_align_of::<U>());
 
-            // This `as int` cast is safe, because the size of the elements of the
+            // This `as isize` cast is safe, because the size of the elements of the
             // vector is not 0, and:
             //
             // 1) If the size of the elements in the vector is 1, the `int` may
@@ -850,9 +850,9 @@ impl<T> Vec<T> {
             //        After `array.offset(offset)`: 0x9.
             //        (0x1 + 0x8 = 0x1 - 0x8)
             //
-            // 2) If the size of the elements in the vector is >1, the `uint` ->
+            // 2) If the size of the elements in the vector is >1, the `usize` ->
             //    `int` conversion can't overflow.
-            let offset = vec.len() as int;
+            let offset = vec.len() as isize;
             let start = vec.as_mut_ptr();
 
             let mut pv = PartialVecNonZeroSized {
@@ -977,8 +977,8 @@ impl<T> Vec<T> {
                     let u = f(t);
 
                     // Forget the `U` and increment `num_u`. This increment
-                    // cannot overflow the `uint` as we only do this for a
-                    // number of times that fits into a `uint` (and start with
+                    // cannot overflow the `usize` as we only do this for a
+                    // number of times that fits into a `usize` (and start with
                     // `0`). Again, we should not panic between these steps.
                     mem::forget(u);
                     pv.num_u += 1;
@@ -1052,7 +1052,7 @@ impl<T: Clone> Vec<T> {
     /// ```
     #[unstable(feature = "collections",
                reason = "matches collection reform specification; waiting for dust to settle")]
-    pub fn resize(&mut self, new_len: uint, value: T) {
+    pub fn resize(&mut self, new_len: usize, value: T) {
         let len = self.len();
 
         if new_len > len {
@@ -1179,8 +1179,8 @@ impl<T: PartialEq> Vec<T> {
             let mut w = 1;
 
             while r < ln {
-                let p_r = p.offset(r as int);
-                let p_wm1 = p.offset((w - 1) as int);
+                let p_r = p.offset(r as isize);
+                let p_wm1 = p.offset((w - 1) as isize);
                 if *p_r != *p_wm1 {
                     if r != w {
                         let p_w = p_wm1.offset(1);
@@ -1205,7 +1205,7 @@ impl<T> Vec<T> {
     ///
     /// If the capacity for `self` is already equal to or greater than the
     /// requested capacity, then no action is taken.
-    fn grow_capacity(&mut self, capacity: uint) {
+    fn grow_capacity(&mut self, capacity: usize) {
         if mem::size_of::<T>() == 0 { return }
 
         if capacity > self.cap {
@@ -1223,7 +1223,7 @@ impl<T> Vec<T> {
 
 // FIXME: #13996: need a way to mark the return value as `noalias`
 #[inline(never)]
-unsafe fn alloc_or_realloc<T>(ptr: *mut T, old_size: uint, size: uint) -> *mut T {
+unsafe fn alloc_or_realloc<T>(ptr: *mut T, old_size: usize, size: usize) -> *mut T {
     if old_size == 0 {
         allocate(size, mem::min_align_of::<T>()) as *mut T
     } else {
@@ -1232,7 +1232,7 @@ unsafe fn alloc_or_realloc<T>(ptr: *mut T, old_size: uint, size: uint) -> *mut T
 }
 
 #[inline]
-unsafe fn dealloc<T>(ptr: *mut T, len: uint) {
+unsafe fn dealloc<T>(ptr: *mut T, len: usize) {
     if mem::size_of::<T>() != 0 {
         deallocate(ptr as *mut u8,
                    len * mem::size_of::<T>(),
@@ -1274,22 +1274,22 @@ impl<S: hash::Writer + hash::Hasher, T: Hash<S>> Hash<S> for Vec<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Index<uint> for Vec<T> {
+impl<T> Index<usize> for Vec<T> {
     type Output = T;
 
     #[inline]
-    fn index<'a>(&'a self, index: &uint) -> &'a T {
+    fn index(&self, index: &usize) -> &T {
         // NB built-in indexing via `&[T]`
         &(**self)[*index]
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> IndexMut<uint> for Vec<T> {
+impl<T> IndexMut<usize> for Vec<T> {
     type Output = T;
 
     #[inline]
-    fn index_mut<'a>(&'a mut self, index: &uint) -> &'a mut T {
+    fn index_mut(&mut self, index: &usize) -> &mut T {
         // NB built-in indexing via `&mut [T]`
         &mut (**self)[*index]
     }
@@ -1297,26 +1297,26 @@ impl<T> IndexMut<uint> for Vec<T> {
 
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::Range<uint>> for Vec<T> {
+impl<T> ops::Index<ops::Range<usize>> for Vec<T> {
     type Output = [T];
     #[inline]
-    fn index(&self, index: &ops::Range<uint>) -> &[T] {
+    fn index(&self, index: &ops::Range<usize>) -> &[T] {
         Index::index(&**self, index)
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::RangeTo<uint>> for Vec<T> {
+impl<T> ops::Index<ops::RangeTo<usize>> for Vec<T> {
     type Output = [T];
     #[inline]
-    fn index(&self, index: &ops::RangeTo<uint>) -> &[T] {
+    fn index(&self, index: &ops::RangeTo<usize>) -> &[T] {
         Index::index(&**self, index)
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::RangeFrom<uint>> for Vec<T> {
+impl<T> ops::Index<ops::RangeFrom<usize>> for Vec<T> {
     type Output = [T];
     #[inline]
-    fn index(&self, index: &ops::RangeFrom<uint>) -> &[T] {
+    fn index(&self, index: &ops::RangeFrom<usize>) -> &[T] {
         Index::index(&**self, index)
     }
 }
@@ -1330,26 +1330,26 @@ impl<T> ops::Index<ops::RangeFull> for Vec<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::Range<uint>> for Vec<T> {
+impl<T> ops::IndexMut<ops::Range<usize>> for Vec<T> {
     type Output = [T];
     #[inline]
-    fn index_mut(&mut self, index: &ops::Range<uint>) -> &mut [T] {
+    fn index_mut(&mut self, index: &ops::Range<usize>) -> &mut [T] {
         IndexMut::index_mut(&mut **self, index)
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::RangeTo<uint>> for Vec<T> {
+impl<T> ops::IndexMut<ops::RangeTo<usize>> for Vec<T> {
     type Output = [T];
     #[inline]
-    fn index_mut(&mut self, index: &ops::RangeTo<uint>) -> &mut [T] {
+    fn index_mut(&mut self, index: &ops::RangeTo<usize>) -> &mut [T] {
         IndexMut::index_mut(&mut **self, index)
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::RangeFrom<uint>> for Vec<T> {
+impl<T> ops::IndexMut<ops::RangeFrom<usize>> for Vec<T> {
     type Output = [T];
     #[inline]
-    fn index_mut(&mut self, index: &ops::RangeFrom<uint>) -> &mut [T] {
+    fn index_mut(&mut self, index: &ops::RangeFrom<usize>) -> &mut [T] {
         IndexMut::index_mut(&mut **self, index)
     }
 }
@@ -1366,12 +1366,12 @@ impl<T> ops::IndexMut<ops::RangeFull> for Vec<T> {
 impl<T> ops::Deref for Vec<T> {
     type Target = [T];
 
-    fn deref<'a>(&'a self) -> &'a [T] { self.as_slice() }
+    fn deref(&self) -> &[T] { self.as_slice() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ops::DerefMut for Vec<T> {
-    fn deref_mut<'a>(&'a mut self) -> &'a mut [T] { self.as_mut_slice() }
+    fn deref_mut(&mut self) -> &mut [T] { self.as_mut_slice() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1519,7 +1519,7 @@ impl<T> AsSlice<T> for Vec<T> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    fn as_slice<'a>(&'a self) -> &'a [T] {
+    fn as_slice(&self) -> &[T] {
         unsafe {
             mem::transmute(RawSlice {
                 data: *self.ptr,
@@ -1609,7 +1609,7 @@ impl<'a, T> IntoCow<'a, Vec<T>, [T]> for &'a [T] where T: Clone {
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct IntoIter<T> {
     allocation: *mut T, // the block of memory allocated for the vector
-    cap: uint, // the capacity of the vector
+    cap: usize, // the capacity of the vector
     ptr: *const T,
     end: *const T
 }
@@ -1636,7 +1636,7 @@ impl<T> Iterator for IntoIter<T> {
     type Item = T;
 
     #[inline]
-    fn next<'a>(&'a mut self) -> Option<T> {
+    fn next(&mut self) -> Option<T> {
         unsafe {
             if self.ptr == self.end {
                 None
@@ -1645,10 +1645,10 @@ impl<T> Iterator for IntoIter<T> {
                     // purposefully don't use 'ptr.offset' because for
                     // vectors with 0-size elements this would return the
                     // same pointer.
-                    self.ptr = mem::transmute(self.ptr as uint + 1);
+                    self.ptr = mem::transmute(self.ptr as usize + 1);
 
                     // Use a non-null pointer value
-                    Some(ptr::read(mem::transmute(1u)))
+                    Some(ptr::read(EMPTY as *mut T))
                 } else {
                     let old = self.ptr;
                     self.ptr = self.ptr.offset(1);
@@ -1660,8 +1660,8 @@ impl<T> Iterator for IntoIter<T> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        let diff = (self.end as uint) - (self.ptr as uint);
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let diff = (self.end as usize) - (self.ptr as usize);
         let size = mem::size_of::<T>();
         let exact = diff / (if size == 0 {1} else {size});
         (exact, Some(exact))
@@ -1671,17 +1671,17 @@ impl<T> Iterator for IntoIter<T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> DoubleEndedIterator for IntoIter<T> {
     #[inline]
-    fn next_back<'a>(&'a mut self) -> Option<T> {
+    fn next_back(&mut self) -> Option<T> {
         unsafe {
             if self.end == self.ptr {
                 None
             } else {
                 if mem::size_of::<T>() == 0 {
                     // See above for why 'ptr.offset' isn't used
-                    self.end = mem::transmute(self.end as uint - 1);
+                    self.end = mem::transmute(self.end as usize - 1);
 
                     // Use a non-null pointer value
-                    Some(ptr::read(mem::transmute(1u)))
+                    Some(ptr::read(EMPTY as *mut T))
                 } else {
                     self.end = self.end.offset(-1);
 
@@ -1733,10 +1733,10 @@ impl<'a, T> Iterator for Drain<'a, T> {
                     // purposefully don't use 'ptr.offset' because for
                     // vectors with 0-size elements this would return the
                     // same pointer.
-                    self.ptr = mem::transmute(self.ptr as uint + 1);
+                    self.ptr = mem::transmute(self.ptr as usize + 1);
 
                     // Use a non-null pointer value
-                    Some(ptr::read(mem::transmute(1u)))
+                    Some(ptr::read(EMPTY as *mut T))
                 } else {
                     let old = self.ptr;
                     self.ptr = self.ptr.offset(1);
@@ -1748,8 +1748,8 @@ impl<'a, T> Iterator for Drain<'a, T> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
-        let diff = (self.end as uint) - (self.ptr as uint);
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let diff = (self.end as usize) - (self.ptr as usize);
         let size = mem::size_of::<T>();
         let exact = diff / (if size == 0 {1} else {size});
         (exact, Some(exact))
@@ -1766,10 +1766,10 @@ impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
             } else {
                 if mem::size_of::<T>() == 0 {
                     // See above for why 'ptr.offset' isn't used
-                    self.end = mem::transmute(self.end as uint - 1);
+                    self.end = mem::transmute(self.end as usize - 1);
 
                     // Use a non-null pointer value
-                    Some(ptr::read(mem::transmute(1u)))
+                    Some(ptr::read(EMPTY as *mut T))
                 } else {
                     self.end = self.end.offset(-1);
 
@@ -1862,8 +1862,8 @@ struct PartialVecNonZeroSized<T,U> {
 /// When the destructor of this struct runs, all `num_t` `T`s and `num_u` `U`s
 /// are destructed.
 struct PartialVecZeroSized<T,U> {
-    num_t: uint,
-    num_u: uint,
+    num_t: usize,
+    num_u: usize,
     marker_t: InvariantType<T>,
     marker_u: InvariantType<U>,
 }
@@ -1920,7 +1920,7 @@ mod tests {
     use super::as_vec;
 
     struct DropCounter<'a> {
-        count: &'a mut int
+        count: &'a mut u32
     }
 
     #[unsafe_destructor]
@@ -1949,7 +1949,7 @@ mod tests {
 
     #[test]
     fn test_small_vec_struct() {
-        assert!(size_of::<Vec<u8>>() == size_of::<uint>() * 3);
+        assert!(size_of::<Vec<u8>>() == size_of::<usize>() * 3);
     }
 
     #[test]
@@ -2020,7 +2020,7 @@ mod tests {
 
     #[test]
     fn test_slice_from_mut() {
-        let mut values = vec![1u8,2,3,4,5];
+        let mut values = vec![1, 2, 3, 4, 5];
         {
             let slice = &mut values[2 ..];
             assert!(slice == [3, 4, 5]);
@@ -2034,7 +2034,7 @@ mod tests {
 
     #[test]
     fn test_slice_to_mut() {
-        let mut values = vec![1u8,2,3,4,5];
+        let mut values = vec![1, 2, 3, 4, 5];
         {
             let slice = &mut values[.. 2];
             assert!(slice == [1, 2]);
@@ -2048,7 +2048,7 @@ mod tests {
 
     #[test]
     fn test_split_at_mut() {
-        let mut values = vec![1u8,2,3,4,5];
+        let mut values = vec![1, 2, 3, 4, 5];
         {
             let (left, right) = values.split_at_mut(2);
             {
@@ -2068,12 +2068,12 @@ mod tests {
             }
         }
 
-        assert!(values == vec![2u8, 3, 5, 6, 7]);
+        assert!(values == vec![2, 3, 5, 6, 7]);
     }
 
     #[test]
     fn test_clone() {
-        let v: Vec<int> = vec!();
+        let v: Vec<i32> = vec![];
         let w = vec!(1, 2, 3);
 
         assert_eq!(v, v.clone());
@@ -2108,9 +2108,9 @@ mod tests {
 
     #[test]
     fn test_retain() {
-        let mut vec = vec![1u, 2, 3, 4];
+        let mut vec = vec![1, 2, 3, 4];
         vec.retain(|&x| x % 2 == 0);
-        assert!(vec == vec![2u, 4]);
+        assert!(vec == vec![2, 4]);
     }
 
     #[test]
@@ -2169,20 +2169,20 @@ mod tests {
             // Test on-stack copy-from-buf.
             let a = [1, 2, 3];
             let ptr = a.as_ptr();
-            let b = Vec::from_raw_buf(ptr, 3u);
+            let b = Vec::from_raw_buf(ptr, 3);
             assert_eq!(b, vec![1, 2, 3]);
 
             // Test on-heap copy-from-buf.
             let c = vec![1, 2, 3, 4, 5];
             let ptr = c.as_ptr();
-            let d = Vec::from_raw_buf(ptr, 5u);
+            let d = Vec::from_raw_buf(ptr, 5);
             assert_eq!(d, vec![1, 2, 3, 4, 5]);
         }
     }
 
     #[test]
     fn test_vec_truncate_drop() {
-        static mut drops: uint = 0;
+        static mut drops: u32 = 0;
         struct Elem(int);
         impl Drop for Elem {
             fn drop(&mut self) {
@@ -2201,7 +2201,7 @@ mod tests {
     #[test]
     #[should_fail]
     fn test_vec_truncate_fail() {
-        struct BadElem(int);
+        struct BadElem(i32);
         impl Drop for BadElem {
             fn drop(&mut self) {
                 let BadElem(ref mut x) = *self;
@@ -2217,62 +2217,62 @@ mod tests {
 
     #[test]
     fn test_index() {
-        let vec = vec!(1, 2, 3);
+        let vec = vec![1, 2, 3];
         assert!(vec[1] == 2);
     }
 
     #[test]
     #[should_fail]
     fn test_index_out_of_bounds() {
-        let vec = vec!(1, 2, 3);
+        let vec = vec![1, 2, 3];
         let _ = vec[3];
     }
 
     #[test]
     #[should_fail]
     fn test_slice_out_of_bounds_1() {
-        let x: Vec<int> = vec![1, 2, 3, 4, 5];
+        let x = vec![1, 2, 3, 4, 5];
         &x[-1..];
     }
 
     #[test]
     #[should_fail]
     fn test_slice_out_of_bounds_2() {
-        let x: Vec<int> = vec![1, 2, 3, 4, 5];
+        let x = vec![1, 2, 3, 4, 5];
         &x[..6];
     }
 
     #[test]
     #[should_fail]
     fn test_slice_out_of_bounds_3() {
-        let x: Vec<int> = vec![1, 2, 3, 4, 5];
+        let x = vec![1, 2, 3, 4, 5];
         &x[-1..4];
     }
 
     #[test]
     #[should_fail]
     fn test_slice_out_of_bounds_4() {
-        let x: Vec<int> = vec![1, 2, 3, 4, 5];
+        let x = vec![1, 2, 3, 4, 5];
         &x[1..6];
     }
 
     #[test]
     #[should_fail]
     fn test_slice_out_of_bounds_5() {
-        let x: Vec<int> = vec![1, 2, 3, 4, 5];
+        let x = vec![1, 2, 3, 4, 5];
         &x[3..2];
     }
 
     #[test]
     #[should_fail]
     fn test_swap_remove_empty() {
-        let mut vec: Vec<uint> = vec!();
+        let mut vec= Vec::<i32>::new();
         vec.swap_remove(0);
     }
 
     #[test]
     fn test_move_iter_unwrap() {
-        let mut vec: Vec<uint> = Vec::with_capacity(7);
+        let mut vec = Vec::with_capacity(7);
         vec.push(1);
         vec.push(2);
         let ptr = vec.as_ptr();
@@ -2285,14 +2285,14 @@ mod tests {
     #[test]
     #[should_fail]
     fn test_map_in_place_incompatible_types_fail() {
-        let v = vec![0u, 1, 2];
+        let v = vec![0, 1, 2];
         v.map_in_place(|_| ());
     }
 
     #[test]
     fn test_map_in_place() {
-        let v = vec![0u, 1, 2];
-        assert_eq!(v.map_in_place(|i: uint| i as int - 1), [-1, 0, 1]);
+        let v = vec![0, 1, 2];
+        assert_eq!(v.map_in_place(|i: u32| i as i32 - 1), [-1, 0, 1]);
     }
 
     #[test]
@@ -2318,7 +2318,7 @@ mod tests {
                 DROP_COUNTER.fetch_add(1, Ordering::Relaxed);
             }
         }
-        const NUM_ELEMENTS: uint = 2;
+        const NUM_ELEMENTS: usize = 2;
         static DROP_COUNTER: AtomicUsize = ATOMIC_USIZE_INIT;
 
         let v = repeat(Nothing).take(NUM_ELEMENTS).collect::<Vec<_>>();
@@ -2334,7 +2334,7 @@ mod tests {
     #[test]
     fn test_move_items() {
         let vec = vec![1, 2, 3];
-        let mut vec2 : Vec<i32> = vec![];
+        let mut vec2 = vec![];
         for i in vec {
             vec2.push(i);
         }
@@ -2344,7 +2344,7 @@ mod tests {
     #[test]
     fn test_move_items_reverse() {
         let vec = vec![1, 2, 3];
-        let mut vec2 : Vec<i32> = vec![];
+        let mut vec2 = vec![];
         for i in vec.into_iter().rev() {
             vec2.push(i);
         }
@@ -2354,7 +2354,7 @@ mod tests {
     #[test]
     fn test_move_items_zero_sized() {
         let vec = vec![(), (), ()];
-        let mut vec2 : Vec<()> = vec![];
+        let mut vec2 = vec![];
         for i in vec {
             vec2.push(i);
         }
@@ -2364,7 +2364,7 @@ mod tests {
     #[test]
     fn test_drain_items() {
         let mut vec = vec![1, 2, 3];
-        let mut vec2: Vec<i32> = vec![];
+        let mut vec2 = vec![];
         for i in vec.drain() {
             vec2.push(i);
         }
@@ -2375,18 +2375,18 @@ mod tests {
     #[test]
     fn test_drain_items_reverse() {
         let mut vec = vec![1, 2, 3];
-        let mut vec2: Vec<i32> = vec![];
+        let mut vec2 = vec![];
         for i in vec.drain().rev() {
             vec2.push(i);
         }
         assert_eq!(vec, []);
-        assert_eq!(vec2, [ 3, 2, 1 ]);
+        assert_eq!(vec2, [3, 2, 1]);
     }
 
     #[test]
     fn test_drain_items_zero_sized() {
         let mut vec = vec![(), (), ()];
-        let mut vec2: Vec<()> = vec![];
+        let mut vec2 = vec![];
         for i in vec.drain() {
             vec2.push(i);
         }
@@ -2396,9 +2396,9 @@ mod tests {
 
     #[test]
     fn test_into_boxed_slice() {
-        let xs = vec![1u, 2, 3];
+        let xs = vec![1, 2, 3];
         let ys = xs.into_boxed_slice();
-        assert_eq!(ys, [1u, 2, 3]);
+        assert_eq!(ys, [1, 2, 3]);
     }
 
     #[test]
@@ -2421,17 +2421,17 @@ mod tests {
     #[bench]
     fn bench_new(b: &mut Bencher) {
         b.iter(|| {
-            let v: Vec<uint> = Vec::new();
+            let v: Vec<u32> = Vec::new();
             assert_eq!(v.len(), 0);
             assert_eq!(v.capacity(), 0);
         })
     }
 
-    fn do_bench_with_capacity(b: &mut Bencher, src_len: uint) {
+    fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) {
         b.bytes = src_len as u64;
 
         b.iter(|| {
-            let v: Vec<uint> = Vec::with_capacity(src_len);
+            let v: Vec<u32> = Vec::with_capacity(src_len);
             assert_eq!(v.len(), 0);
             assert_eq!(v.capacity(), src_len);
         })
@@ -2457,7 +2457,7 @@ mod tests {
         do_bench_with_capacity(b, 1000)
     }
 
-    fn do_bench_from_fn(b: &mut Bencher, src_len: uint) {
+    fn do_bench_from_fn(b: &mut Bencher, src_len: usize) {
         b.bytes = src_len as u64;
 
         b.iter(|| {
@@ -2487,11 +2487,11 @@ mod tests {
         do_bench_from_fn(b, 1000)
     }
 
-    fn do_bench_from_elem(b: &mut Bencher, src_len: uint) {
+    fn do_bench_from_elem(b: &mut Bencher, src_len: usize) {
         b.bytes = src_len as u64;
 
         b.iter(|| {
-            let dst: Vec<uint> = repeat(5).take(src_len).collect();
+            let dst: Vec<usize> = repeat(5).take(src_len).collect();
             assert_eq!(dst.len(), src_len);
             assert!(dst.iter().all(|x| *x == 5));
         })
@@ -2517,8 +2517,8 @@ mod tests {
         do_bench_from_elem(b, 1000)
     }
 
-    fn do_bench_from_slice(b: &mut Bencher, src_len: uint) {
-        let src: Vec<uint> = FromIterator::from_iter(0..src_len);
+    fn do_bench_from_slice(b: &mut Bencher, src_len: usize) {
+        let src: Vec<_> = FromIterator::from_iter(0..src_len);
 
         b.bytes = src_len as u64;
 
@@ -2549,13 +2549,13 @@ mod tests {
         do_bench_from_slice(b, 1000)
     }
 
-    fn do_bench_from_iter(b: &mut Bencher, src_len: uint) {
-        let src: Vec<uint> = FromIterator::from_iter(0..src_len);
+    fn do_bench_from_iter(b: &mut Bencher, src_len: usize) {
+        let src: Vec<_> = FromIterator::from_iter(0..src_len);
 
         b.bytes = src_len as u64;
 
         b.iter(|| {
-            let dst: Vec<uint> = FromIterator::from_iter(src.clone().into_iter());
+            let dst: Vec<_> = FromIterator::from_iter(src.clone().into_iter());
             assert_eq!(dst.len(), src_len);
             assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
         });
@@ -2581,9 +2581,9 @@ mod tests {
         do_bench_from_iter(b, 1000)
     }
 
-    fn do_bench_extend(b: &mut Bencher, dst_len: uint, src_len: uint) {
-        let dst: Vec<uint> = FromIterator::from_iter(0..dst_len);
-        let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
+    fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) {
+        let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
+        let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 
         b.bytes = src_len as u64;
 
@@ -2630,9 +2630,9 @@ mod tests {
         do_bench_extend(b, 1000, 1000)
     }
 
-    fn do_bench_push_all(b: &mut Bencher, dst_len: uint, src_len: uint) {
-        let dst: Vec<uint> = FromIterator::from_iter(0..dst_len);
-        let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
+    fn do_bench_push_all(b: &mut Bencher, dst_len: usize, src_len: usize) {
+        let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
+        let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 
         b.bytes = src_len as u64;
 
@@ -2679,9 +2679,9 @@ mod tests {
         do_bench_push_all(b, 1000, 1000)
     }
 
-    fn do_bench_push_all_move(b: &mut Bencher, dst_len: uint, src_len: uint) {
-        let dst: Vec<uint> = FromIterator::from_iter(0u..dst_len);
-        let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
+    fn do_bench_push_all_move(b: &mut Bencher, dst_len: usize, src_len: usize) {
+        let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
+        let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 
         b.bytes = src_len as u64;
 
@@ -2728,8 +2728,8 @@ mod tests {
         do_bench_push_all_move(b, 1000, 1000)
     }
 
-    fn do_bench_clone(b: &mut Bencher, src_len: uint) {
-        let src: Vec<uint> = FromIterator::from_iter(0..src_len);
+    fn do_bench_clone(b: &mut Bencher, src_len: usize) {
+        let src: Vec<usize> = FromIterator::from_iter(0..src_len);
 
         b.bytes = src_len as u64;
 
@@ -2760,9 +2760,9 @@ mod tests {
         do_bench_clone(b, 1000)
     }
 
-    fn do_bench_clone_from(b: &mut Bencher, times: uint, dst_len: uint, src_len: uint) {
-        let dst: Vec<uint> = FromIterator::from_iter(0..src_len);
-        let src: Vec<uint> = FromIterator::from_iter(dst_len..dst_len + src_len);
+    fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) {
+        let dst: Vec<_> = FromIterator::from_iter(0..src_len);
+        let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
 
         b.bytes = (times * src_len) as u64;
 
diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs
index a907d624169..1bb9fcf8192 100644
--- a/src/libcollections/vec_map.rs
+++ b/src/libcollections/vec_map.rs
@@ -29,8 +29,6 @@ use core::ops::{Index, IndexMut};
 use {vec, slice};
 use vec::Vec;
 
-// FIXME(conventions): capacity management???
-
 /// A map optimized for small integer keys.
 ///
 /// # Examples
@@ -117,7 +115,7 @@ impl<S: Writer + Hasher, V: Hash<S>> Hash<S> for VecMap<V> {
     fn hash(&self, state: &mut S) {
         // In order to not traverse the `VecMap` twice, count the elements
         // during iteration.
-        let mut count: uint = 0;
+        let mut count: usize = 0;
         for elt in self {
             elt.hash(state);
             count += 1;
@@ -148,7 +146,7 @@ impl<V> VecMap<V> {
     /// let mut map: VecMap<&str> = VecMap::with_capacity(10);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_capacity(capacity: uint) -> VecMap<V> {
+    pub fn with_capacity(capacity: usize) -> VecMap<V> {
         VecMap { v: Vec::with_capacity(capacity) }
     }
 
@@ -164,7 +162,7 @@ impl<V> VecMap<V> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn capacity(&self) -> uint {
+    pub fn capacity(&self) -> usize {
         self.v.capacity()
     }
 
@@ -183,7 +181,7 @@ impl<V> VecMap<V> {
     /// assert!(map.capacity() >= 10);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_len(&mut self, len: uint) {
+    pub fn reserve_len(&mut self, len: usize) {
         let cur_len = self.v.len();
         if len >= cur_len {
             self.v.reserve(len - cur_len);
@@ -207,7 +205,7 @@ impl<V> VecMap<V> {
     /// assert!(map.capacity() >= 10);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_len_exact(&mut self, len: uint) {
+    pub fn reserve_len_exact(&mut self, len: usize) {
         let cur_len = self.v.len();
         if len >= cur_len {
             self.v.reserve_exact(len - cur_len);
@@ -215,11 +213,11 @@ impl<V> VecMap<V> {
     }
 
     /// Returns an iterator visiting all keys in ascending order of the keys.
-    /// The iterator's element type is `uint`.
+    /// The iterator's element type is `usize`.
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn keys<'r>(&'r self) -> Keys<'r, V> {
         fn first<A, B>((a, _): (A, B)) -> A { a }
-        let first: fn((uint, &'r V)) -> uint = first; // coerce to fn pointer
+        let first: fn((usize, &'r V)) -> usize = first; // coerce to fn pointer
 
         Keys { iter: self.iter().map(first) }
     }
@@ -229,13 +227,13 @@ impl<V> VecMap<V> {
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn values<'r>(&'r self) -> Values<'r, V> {
         fn second<A, B>((_, b): (A, B)) -> B { b }
-        let second: fn((uint, &'r V)) -> &'r V = second; // coerce to fn pointer
+        let second: fn((usize, &'r V)) -> &'r V = second; // coerce to fn pointer
 
         Values { iter: self.iter().map(second) }
     }
 
     /// Returns an iterator visiting all key-value pairs in ascending order of the keys.
-    /// The iterator's element type is `(uint, &'r V)`.
+    /// The iterator's element type is `(usize, &'r V)`.
     ///
     /// # Examples
     ///
@@ -263,7 +261,7 @@ impl<V> VecMap<V> {
 
     /// Returns an iterator visiting all key-value pairs in ascending order of the keys,
     /// with mutable references to the values.
-    /// The iterator's element type is `(uint, &'r mut V)`.
+    /// The iterator's element type is `(usize, &'r mut V)`.
     ///
     /// # Examples
     ///
@@ -294,7 +292,7 @@ impl<V> VecMap<V> {
 
     /// Returns an iterator visiting all key-value pairs in ascending order of
     /// the keys, consuming the original `VecMap`.
-    /// The iterator's element type is `(uint, &'r V)`.
+    /// The iterator's element type is `(usize, &'r V)`.
     ///
     /// # Examples
     ///
@@ -306,23 +304,23 @@ impl<V> VecMap<V> {
     /// map.insert(3, "c");
     /// map.insert(2, "b");
     ///
-    /// let vec: Vec<(uint, &str)> = map.into_iter().collect();
+    /// let vec: Vec<(usize, &str)> = map.into_iter().collect();
     ///
     /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn into_iter(self) -> IntoIter<V> {
-        fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> {
+        fn filter<A>((i, v): (usize, Option<A>)) -> Option<(usize, A)> {
             v.map(|v| (i, v))
         }
-        let filter: fn((uint, Option<V>)) -> Option<(uint, V)> = filter; // coerce to fn ptr
+        let filter: fn((usize, Option<V>)) -> Option<(usize, V)> = filter; // coerce to fn ptr
 
         IntoIter { iter: self.v.into_iter().enumerate().filter_map(filter) }
     }
 
     /// Returns an iterator visiting all key-value pairs in ascending order of
     /// the keys, emptying (but not consuming) the original `VecMap`.
-    /// The iterator's element type is `(uint, &'r V)`. Keeps the allocated memory for reuse.
+    /// The iterator's element type is `(usize, &'r V)`. Keeps the allocated memory for reuse.
     ///
     /// # Examples
     ///
@@ -334,17 +332,17 @@ impl<V> VecMap<V> {
     /// map.insert(3, "c");
     /// map.insert(2, "b");
     ///
-    /// let vec: Vec<(uint, &str)> = map.drain().collect();
+    /// let vec: Vec<(usize, &str)> = map.drain().collect();
     ///
     /// assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
     /// ```
     #[unstable(feature = "collections",
                reason = "matches collection reform specification, waiting for dust to settle")]
     pub fn drain<'a>(&'a mut self) -> Drain<'a, V> {
-        fn filter<A>((i, v): (uint, Option<A>)) -> Option<(uint, A)> {
+        fn filter<A>((i, v): (usize, Option<A>)) -> Option<(usize, A)> {
             v.map(|v| (i, v))
         }
-        let filter: fn((uint, Option<V>)) -> Option<(uint, V)> = filter; // coerce to fn ptr
+        let filter: fn((usize, Option<V>)) -> Option<(usize, V)> = filter; // coerce to fn ptr
 
         Drain { iter: self.v.drain().enumerate().filter_map(filter) }
     }
@@ -362,7 +360,7 @@ impl<V> VecMap<V> {
     /// assert_eq!(a.len(), 1);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> uint {
+    pub fn len(&self) -> usize {
         self.v.iter().filter(|elt| elt.is_some()).count()
     }
 
@@ -411,7 +409,7 @@ impl<V> VecMap<V> {
     /// assert_eq!(map.get(&2), None);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get(&self, key: &uint) -> Option<&V> {
+    pub fn get(&self, key: &usize) -> Option<&V> {
         if *key < self.v.len() {
             match self.v[*key] {
               Some(ref value) => Some(value),
@@ -436,7 +434,7 @@ impl<V> VecMap<V> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn contains_key(&self, key: &uint) -> bool {
+    pub fn contains_key(&self, key: &usize) -> bool {
         self.get(key).is_some()
     }
 
@@ -456,7 +454,7 @@ impl<V> VecMap<V> {
     /// assert_eq!(map[1], "b");
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get_mut(&mut self, key: &uint) -> Option<&mut V> {
+    pub fn get_mut(&mut self, key: &usize) -> Option<&mut V> {
         if *key < self.v.len() {
             match *(&mut self.v[*key]) {
               Some(ref mut value) => Some(value),
@@ -484,7 +482,7 @@ impl<V> VecMap<V> {
     /// assert_eq!(map[37], "c");
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn insert(&mut self, key: uint, value: V) -> Option<V> {
+    pub fn insert(&mut self, key: usize, value: V) -> Option<V> {
         let len = self.v.len();
         if len <= key {
             self.v.extend((0..key - len + 1).map(|_| None));
@@ -506,7 +504,7 @@ impl<V> VecMap<V> {
     /// assert_eq!(map.remove(&1), None);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn remove(&mut self, key: &uint) -> Option<V> {
+    pub fn remove(&mut self, key: &usize) -> Option<V> {
         if *key >= self.v.len() {
             return None;
         }
@@ -662,8 +660,8 @@ impl<V: fmt::Debug> fmt::Debug for VecMap<V> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<V> FromIterator<(uint, V)> for VecMap<V> {
-    fn from_iter<Iter: Iterator<Item=(uint, V)>>(iter: Iter) -> VecMap<V> {
+impl<V> FromIterator<(usize, V)> for VecMap<V> {
+    fn from_iter<Iter: Iterator<Item=(usize, V)>>(iter: Iter) -> VecMap<V> {
         let mut map = VecMap::new();
         map.extend(iter);
         map
@@ -695,29 +693,29 @@ impl<'a, T> IntoIterator for &'a mut VecMap<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<V> Extend<(uint, V)> for VecMap<V> {
-    fn extend<Iter: Iterator<Item=(uint, V)>>(&mut self, iter: Iter) {
+impl<V> Extend<(usize, V)> for VecMap<V> {
+    fn extend<Iter: Iterator<Item=(usize, V)>>(&mut self, iter: Iter) {
         for (k, v) in iter {
             self.insert(k, v);
         }
     }
 }
 
-impl<V> Index<uint> for VecMap<V> {
+impl<V> Index<usize> for VecMap<V> {
     type Output = V;
 
     #[inline]
-    fn index<'a>(&'a self, i: &uint) -> &'a V {
+    fn index<'a>(&'a self, i: &usize) -> &'a V {
         self.get(i).expect("key not present")
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<V> IndexMut<uint> for VecMap<V> {
+impl<V> IndexMut<usize> for VecMap<V> {
     type Output = V;
 
     #[inline]
-    fn index_mut<'a>(&'a mut self, i: &uint) -> &'a mut V {
+    fn index_mut<'a>(&'a mut self, i: &usize) -> &'a mut V {
         self.get_mut(i).expect("key not present")
     }
 }
@@ -750,7 +748,7 @@ macro_rules! iterator {
             }
 
             #[inline]
-            fn size_hint(&self) -> (uint, Option<uint>) {
+            fn size_hint(&self) -> (usize, Option<usize>) {
                 (0, Some(self.back - self.front))
             }
         }
@@ -787,8 +785,8 @@ macro_rules! double_ended_iterator {
 /// An iterator over the key-value pairs of a map.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Iter<'a, V:'a> {
-    front: uint,
-    back: uint,
+    front: usize,
+    back: usize,
     iter: slice::Iter<'a, Option<V>>
 }
 
@@ -803,25 +801,25 @@ impl<'a, V> Clone for Iter<'a, V> {
     }
 }
 
-iterator! { impl Iter -> (uint, &'a V), as_ref }
-double_ended_iterator! { impl Iter -> (uint, &'a V), as_ref }
+iterator! { impl Iter -> (usize, &'a V), as_ref }
+double_ended_iterator! { impl Iter -> (usize, &'a V), as_ref }
 
 /// An iterator over the key-value pairs of a map, with the
 /// values being mutable.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct IterMut<'a, V:'a> {
-    front: uint,
-    back: uint,
+    front: usize,
+    back: usize,
     iter: slice::IterMut<'a, Option<V>>
 }
 
-iterator! { impl IterMut -> (uint, &'a mut V), as_mut }
-double_ended_iterator! { impl IterMut -> (uint, &'a mut V), as_mut }
+iterator! { impl IterMut -> (usize, &'a mut V), as_mut }
+double_ended_iterator! { impl IterMut -> (usize, &'a mut V), as_mut }
 
 /// An iterator over the keys of a map.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Keys<'a, V: 'a> {
-    iter: Map<Iter<'a, V>, fn((uint, &'a V)) -> uint>
+    iter: Map<Iter<'a, V>, fn((usize, &'a V)) -> usize>
 }
 
 // FIXME(#19839) Remove in favor of `#[derive(Clone)]`
@@ -836,7 +834,7 @@ impl<'a, V> Clone for Keys<'a, V> {
 /// An iterator over the values of a map.
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Values<'a, V: 'a> {
-    iter: Map<Iter<'a, V>, fn((uint, &'a V)) -> &'a V>
+    iter: Map<Iter<'a, V>, fn((usize, &'a V)) -> &'a V>
 }
 
 // FIXME(#19839) Remove in favor of `#[derive(Clone)]`
@@ -853,39 +851,39 @@ impl<'a, V> Clone for Values<'a, V> {
 pub struct IntoIter<V> {
     iter: FilterMap<
     Enumerate<vec::IntoIter<Option<V>>>,
-    fn((uint, Option<V>)) -> Option<(uint, V)>>
+    fn((usize, Option<V>)) -> Option<(usize, V)>>
 }
 
 #[unstable(feature = "collections")]
 pub struct Drain<'a, V> {
     iter: FilterMap<
     Enumerate<vec::Drain<'a, Option<V>>>,
-    fn((uint, Option<V>)) -> Option<(uint, V)>>
+    fn((usize, Option<V>)) -> Option<(usize, V)>>
 }
 
 #[unstable(feature = "collections")]
 impl<'a, V> Iterator for Drain<'a, V> {
-    type Item = (uint, V);
+    type Item = (usize, V);
 
-    fn next(&mut self) -> Option<(uint, V)> { self.iter.next() }
-    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+    fn next(&mut self) -> Option<(usize, V)> { self.iter.next() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
 }
 
 #[unstable(feature = "collections")]
 impl<'a, V> DoubleEndedIterator for Drain<'a, V> {
-    fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
+    fn next_back(&mut self) -> Option<(usize, V)> { self.iter.next_back() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, V> Iterator for Keys<'a, V> {
-    type Item = uint;
+    type Item = usize;
 
-    fn next(&mut self) -> Option<uint> { self.iter.next() }
-    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+    fn next(&mut self) -> Option<usize> { self.iter.next() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, V> DoubleEndedIterator for Keys<'a, V> {
-    fn next_back(&mut self) -> Option<uint> { self.iter.next_back() }
+    fn next_back(&mut self) -> Option<usize> { self.iter.next_back() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -893,7 +891,7 @@ impl<'a, V> Iterator for Values<'a, V> {
     type Item = &'a V;
 
     fn next(&mut self) -> Option<(&'a V)> { self.iter.next() }
-    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, V> DoubleEndedIterator for Values<'a, V> {
@@ -902,14 +900,14 @@ impl<'a, V> DoubleEndedIterator for Values<'a, V> {
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<V> Iterator for IntoIter<V> {
-    type Item = (uint, V);
+    type Item = (usize, V);
 
-    fn next(&mut self) -> Option<(uint, V)> { self.iter.next() }
-    fn size_hint(&self) -> (uint, Option<uint>) { self.iter.size_hint() }
+    fn next(&mut self) -> Option<(usize, V)> { self.iter.next() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<V> DoubleEndedIterator for IntoIter<V> {
-    fn next_back(&mut self) -> Option<(uint, V)> { self.iter.next_back() }
+    fn next_back(&mut self) -> Option<(usize, V)> { self.iter.next_back() }
 }
 
 #[cfg(test)]
@@ -983,7 +981,7 @@ mod test_map {
         map.insert(1, 'a');
         map.insert(2, 'b');
         map.insert(3, 'c');
-        let keys = map.keys().collect::<Vec<uint>>();
+        let keys: Vec<_> = map.keys().collect();
         assert_eq!(keys.len(), 3);
         assert!(keys.contains(&1));
         assert!(keys.contains(&2));
@@ -996,7 +994,7 @@ mod test_map {
         map.insert(1, 'a');
         map.insert(2, 'b');
         map.insert(3, 'c');
-        let values = map.values().map(|&v| v).collect::<Vec<char>>();
+        let values: Vec<_> = map.values().cloned().collect();
         assert_eq!(values.len(), 3);
         assert!(values.contains(&'a'));
         assert!(values.contains(&'b'));
@@ -1130,7 +1128,7 @@ mod test_map {
         map.insert(3, "c");
         map.insert(2, "b");
 
-        let vec: Vec<(usize, &str)> = map.drain().collect();
+        let vec: Vec<_> = map.drain().collect();
 
         assert_eq!(vec, vec![(1, "a"), (2, "b"), (3, "c")]);
         assert_eq!(map.len(), 0);
@@ -1139,7 +1137,7 @@ mod test_map {
     #[test]
     fn test_show() {
         let mut map = VecMap::new();
-        let empty = VecMap::<int>::new();
+        let empty = VecMap::<i32>::new();
 
         map.insert(1, 2);
         map.insert(3, 4);
@@ -1188,7 +1186,7 @@ mod test_map {
         let mut b = VecMap::new();
 
         assert!(!(a < b) && !(b < a));
-        assert!(b.insert(2u, 5).is_none());
+        assert!(b.insert(2, 5).is_none());
         assert!(a < b);
         assert!(a.insert(2, 7).is_none());
         assert!(!(a < b) && b < a);
@@ -1206,7 +1204,7 @@ mod test_map {
         let mut b = VecMap::new();
 
         assert!(a <= b && a >= b);
-        assert!(a.insert(1u, 1).is_none());
+        assert!(a.insert(1, 1).is_none());
         assert!(a > b && a >= b);
         assert!(b < a && b <= a);
         assert!(b.insert(2, 2).is_none());
@@ -1238,9 +1236,9 @@ mod test_map {
 
     #[test]
     fn test_from_iter() {
-        let xs: Vec<(uint, char)> = vec![(1u, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')];
+        let xs = vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e')];
 
-        let map: VecMap<char> = xs.iter().map(|&x| x).collect();
+        let map: VecMap<_> = xs.iter().cloned().collect();
 
         for &(k, v) in &xs {
             assert_eq!(map.get(&k), Some(&v));
@@ -1249,7 +1247,7 @@ mod test_map {
 
     #[test]
     fn test_index() {
-        let mut map: VecMap<int> = VecMap::new();
+        let mut map = VecMap::new();
 
         map.insert(1, 2);
         map.insert(2, 1);
@@ -1261,7 +1259,7 @@ mod test_map {
     #[test]
     #[should_fail]
     fn test_index_nonexistent() {
-        let mut map: VecMap<int> = VecMap::new();
+        let mut map = VecMap::new();
 
         map.insert(1, 2);
         map.insert(2, 1);
@@ -1274,7 +1272,7 @@ mod test_map {
     fn test_entry(){
         let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
 
-        let mut map: VecMap<i32> = xs.iter().map(|&x| x).collect();
+        let mut map: VecMap<_> = xs.iter().cloned().collect();
 
         // Existing key (insert)
         match map.entry(1) {
@@ -1330,7 +1328,7 @@ mod bench {
 
     #[bench]
     pub fn insert_rand_100(b: &mut Bencher) {
-        let mut m : VecMap<uint> = VecMap::new();
+        let mut m = VecMap::new();
         insert_rand_n(100, &mut m, b,
                       |m, i| { m.insert(i, 1); },
                       |m, i| { m.remove(&i); });
@@ -1338,7 +1336,7 @@ mod bench {
 
     #[bench]
     pub fn insert_rand_10_000(b: &mut Bencher) {
-        let mut m : VecMap<uint> = VecMap::new();
+        let mut m = VecMap::new();
         insert_rand_n(10_000, &mut m, b,
                       |m, i| { m.insert(i, 1); },
                       |m, i| { m.remove(&i); });
@@ -1347,7 +1345,7 @@ mod bench {
     // Insert seq
     #[bench]
     pub fn insert_seq_100(b: &mut Bencher) {
-        let mut m : VecMap<uint> = VecMap::new();
+        let mut m = VecMap::new();
         insert_seq_n(100, &mut m, b,
                      |m, i| { m.insert(i, 1); },
                      |m, i| { m.remove(&i); });
@@ -1355,7 +1353,7 @@ mod bench {
 
     #[bench]
     pub fn insert_seq_10_000(b: &mut Bencher) {
-        let mut m : VecMap<uint> = VecMap::new();
+        let mut m = VecMap::new();
         insert_seq_n(10_000, &mut m, b,
                      |m, i| { m.insert(i, 1); },
                      |m, i| { m.remove(&i); });
@@ -1364,7 +1362,7 @@ mod bench {
     // Find rand
     #[bench]
     pub fn find_rand_100(b: &mut Bencher) {
-        let mut m : VecMap<uint> = VecMap::new();
+        let mut m = VecMap::new();
         find_rand_n(100, &mut m, b,
                     |m, i| { m.insert(i, 1); },
                     |m, i| { m.get(&i); });
@@ -1372,7 +1370,7 @@ mod bench {
 
     #[bench]
     pub fn find_rand_10_000(b: &mut Bencher) {
-        let mut m : VecMap<uint> = VecMap::new();
+        let mut m = VecMap::new();
         find_rand_n(10_000, &mut m, b,
                     |m, i| { m.insert(i, 1); },
                     |m, i| { m.get(&i); });
@@ -1381,7 +1379,7 @@ mod bench {
     // Find seq
     #[bench]
     pub fn find_seq_100(b: &mut Bencher) {
-        let mut m : VecMap<uint> = VecMap::new();
+        let mut m = VecMap::new();
         find_seq_n(100, &mut m, b,
                    |m, i| { m.insert(i, 1); },
                    |m, i| { m.get(&i); });
@@ -1389,7 +1387,7 @@ mod bench {
 
     #[bench]
     pub fn find_seq_10_000(b: &mut Bencher) {
-        let mut m : VecMap<uint> = VecMap::new();
+        let mut m = VecMap::new();
         find_seq_n(10_000, &mut m, b,
                    |m, i| { m.insert(i, 1); },
                    |m, i| { m.get(&i); });
diff --git a/src/librustc/middle/ty.rs b/src/librustc/middle/ty.rs
index fbdeaabc73f..b7833461348 100644
--- a/src/librustc/middle/ty.rs
+++ b/src/librustc/middle/ty.rs
@@ -1591,10 +1591,10 @@ pub fn region_existential_bound<'tcx>(r: ty::Region) -> ExistentialBounds<'tcx>
 }
 
 impl CLike for BuiltinBound {
-    fn to_uint(&self) -> uint {
+    fn to_usize(&self) -> uint {
         *self as uint
     }
-    fn from_uint(v: uint) -> BuiltinBound {
+    fn from_usize(v: uint) -> BuiltinBound {
         unsafe { mem::transmute(v) }
     }
 }
diff --git a/src/libserialize/collection_impls.rs b/src/libserialize/collection_impls.rs
index be7abfe6aca..53d3b069467 100644
--- a/src/libserialize/collection_impls.rs
+++ b/src/libserialize/collection_impls.rs
@@ -136,7 +136,7 @@ impl<
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         let mut bits = 0;
         for item in self {
-            bits |= item.to_uint();
+            bits |= item.to_usize();
         }
         s.emit_uint(bits)
     }
@@ -150,7 +150,7 @@ impl<
         let mut set = EnumSet::new();
         for bit in 0..uint::BITS {
             if bits & (1 << bit) != 0 {
-                set.insert(CLike::from_uint(1 << bit));
+                set.insert(CLike::from_usize(1 << bit));
             }
         }
         Ok(set)
diff --git a/src/libstd/collections/hash/bench.rs b/src/libstd/collections/hash/bench.rs
index ce02648b8f2..ca506e8c36f 100644
--- a/src/libstd/collections/hash/bench.rs
+++ b/src/libstd/collections/hash/bench.rs
@@ -21,7 +21,7 @@ fn new_drop(b : &mut Bencher) {
     use super::map::HashMap;
 
     b.iter(|| {
-        let m : HashMap<int, int> = HashMap::new();
+        let m : HashMap<i32, i32> = HashMap::new();
         assert_eq!(m.len(), 0);
     })
 }
diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs
index 42f365b4e1b..283210ed644 100644
--- a/src/libstd/collections/hash/map.rs
+++ b/src/libstd/collections/hash/map.rs
@@ -45,9 +45,9 @@ use super::table::BucketState::{
 };
 use super::state::HashState;
 
-const INITIAL_LOG2_CAP: uint = 5;
+const INITIAL_LOG2_CAP: usize = 5;
 #[unstable(feature = "std_misc")]
-pub const INITIAL_CAPACITY: uint = 1 << INITIAL_LOG2_CAP; // 2^5
+pub const INITIAL_CAPACITY: usize = 1 << INITIAL_LOG2_CAP; // 2^5
 
 /// The default behavior of HashMap implements a load factor of 90.9%.
 /// This behavior is characterized by the following condition:
@@ -62,7 +62,7 @@ impl DefaultResizePolicy {
     }
 
     #[inline]
-    fn min_capacity(&self, usable_size: uint) -> uint {
+    fn min_capacity(&self, usable_size: usize) -> usize {
         // Here, we are rephrasing the logic by specifying the lower limit
         // on capacity:
         //
@@ -72,7 +72,7 @@ impl DefaultResizePolicy {
 
     /// An inverse of `min_capacity`, approximately.
     #[inline]
-    fn usable_capacity(&self, cap: uint) -> uint {
+    fn usable_capacity(&self, cap: usize) -> usize {
         // As the number of entries approaches usable capacity,
         // min_capacity(size) must be smaller than the internal capacity,
         // so that the map is not resized:
@@ -369,7 +369,7 @@ fn pop_internal<K, V>(starting_bucket: FullBucketMut<K, V>) -> (K, V) {
 ///
 /// `hash`, `k`, and `v` are the elements to "robin hood" into the hashtable.
 fn robin_hood<'a, K: 'a, V: 'a>(mut bucket: FullBucketMut<'a, K, V>,
-                        mut ib: uint,
+                        mut ib: usize,
                         mut hash: SafeHash,
                         mut k: K,
                         mut v: V)
@@ -515,7 +515,7 @@ impl<K: Hash<Hasher> + Eq, V> HashMap<K, V, RandomState> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_capacity(capacity: uint) -> HashMap<K, V, RandomState> {
+    pub fn with_capacity(capacity: usize) -> HashMap<K, V, RandomState> {
         HashMap::with_capacity_and_hash_state(capacity, Default::default())
     }
 }
@@ -569,7 +569,7 @@ impl<K, V, S, H> HashMap<K, V, S>
     /// ```
     #[inline]
     #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
-    pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S)
+    pub fn with_capacity_and_hash_state(capacity: usize, hash_state: S)
                                         -> HashMap<K, V, S> {
         let resize_policy = DefaultResizePolicy::new();
         let min_cap = max(INITIAL_CAPACITY, resize_policy.min_capacity(capacity));
@@ -593,7 +593,7 @@ impl<K, V, S, H> HashMap<K, V, S>
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn capacity(&self) -> uint {
+    pub fn capacity(&self) -> usize {
         self.resize_policy.usable_capacity(self.table.capacity())
     }
 
@@ -603,7 +603,7 @@ impl<K, V, S, H> HashMap<K, V, S>
     ///
     /// # Panics
     ///
-    /// Panics if the new allocation size overflows `uint`.
+    /// Panics if the new allocation size overflows `usize`.
     ///
     /// # Example
     ///
@@ -613,7 +613,7 @@ impl<K, V, S, H> HashMap<K, V, S>
     /// map.reserve(10);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve(&mut self, additional: uint) {
+    pub fn reserve(&mut self, additional: usize) {
         let new_size = self.len().checked_add(additional).expect("capacity overflow");
         let min_cap = self.resize_policy.min_capacity(new_size);
 
@@ -631,7 +631,7 @@ impl<K, V, S, H> HashMap<K, V, S>
     ///   1) Make sure the new capacity is enough for all the elements, accounting
     ///      for the load factor.
     ///   2) Ensure new_capacity is a power of two or zero.
-    fn resize(&mut self, new_capacity: uint) {
+    fn resize(&mut self, new_capacity: usize) {
         assert!(self.table.size() <= new_capacity);
         assert!(new_capacity.is_power_of_two() || new_capacity == 0);
 
@@ -793,7 +793,7 @@ impl<K, V, S, H> HashMap<K, V, S>
 
             if (ib as int) < robin_ib {
                 // Found a luckier bucket than me. Better steal his spot.
-                return robin_hood(bucket, robin_ib as uint, hash, k, v);
+                return robin_hood(bucket, robin_ib as usize, hash, k, v);
             }
 
             probe = bucket.next();
@@ -951,7 +951,7 @@ impl<K, V, S, H> HashMap<K, V, S>
     /// assert_eq!(a.len(), 1);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> uint { self.table.size() }
+    pub fn len(&self) -> usize { self.table.size() }
 
     /// Returns true if the map contains no elements.
     ///
@@ -1186,7 +1186,7 @@ fn search_entry_hashed<'a, K: Eq, V>(table: &'a mut RawTable<K,V>, hash: SafeHas
             return Vacant(VacantEntry {
                 hash: hash,
                 key: k,
-                elem: NeqElem(bucket, robin_ib as uint),
+                elem: NeqElem(bucket, robin_ib as usize),
             });
         }
 
@@ -1369,7 +1369,7 @@ pub enum Entry<'a, K: 'a, V: 'a> {
 enum VacantEntryState<K, V, M> {
     /// The index is occupied, but the key to insert has precedence,
     /// and will kick the current one out on insertion.
-    NeqElem(FullBucket<K, V, M>, uint),
+    NeqElem(FullBucket<K, V, M>, usize),
     /// The index is genuinely vacant.
     NoElem(EmptyBucket<K, V, M>),
 }
@@ -1672,11 +1672,11 @@ mod test_map {
 
     #[derive(Hash, PartialEq, Eq)]
     struct Dropable {
-        k: uint
+        k: usize
     }
 
     impl Dropable {
-        fn new(k: uint) -> Dropable {
+        fn new(k: usize) -> Dropable {
             DROP_VECTOR.with(|slot| {
                 slot.borrow_mut()[k] += 1;
             });
@@ -1709,24 +1709,24 @@ mod test_map {
             let mut m = HashMap::new();
 
             DROP_VECTOR.with(|v| {
-                for i in 0u..200 {
+                for i in 0..200 {
                     assert_eq!(v.borrow()[i], 0);
                 }
             });
 
-            for i in 0u..100 {
+            for i in 0..100 {
                 let d1 = Dropable::new(i);
                 let d2 = Dropable::new(i+100);
                 m.insert(d1, d2);
             }
 
             DROP_VECTOR.with(|v| {
-                for i in 0u..200 {
+                for i in 0..200 {
                     assert_eq!(v.borrow()[i], 1);
                 }
             });
 
-            for i in 0u..50 {
+            for i in 0..50 {
                 let k = Dropable::new(i);
                 let v = m.remove(&k);
 
@@ -1739,12 +1739,12 @@ mod test_map {
             }
 
             DROP_VECTOR.with(|v| {
-                for i in 0u..50 {
+                for i in 0..50 {
                     assert_eq!(v.borrow()[i], 0);
                     assert_eq!(v.borrow()[i+100], 0);
                 }
 
-                for i in 50u..100 {
+                for i in 50..100 {
                     assert_eq!(v.borrow()[i], 1);
                     assert_eq!(v.borrow()[i+100], 1);
                 }
@@ -1752,7 +1752,7 @@ mod test_map {
         }
 
         DROP_VECTOR.with(|v| {
-            for i in 0u..200 {
+            for i in 0..200 {
                 assert_eq!(v.borrow()[i], 0);
             }
         });
@@ -1768,19 +1768,19 @@ mod test_map {
             let mut hm = HashMap::new();
 
             DROP_VECTOR.with(|v| {
-                for i in 0u..200 {
+                for i in 0..200 {
                     assert_eq!(v.borrow()[i], 0);
                 }
             });
 
-            for i in 0u..100 {
+            for i in 0..100 {
                 let d1 = Dropable::new(i);
                 let d2 = Dropable::new(i+100);
                 hm.insert(d1, d2);
             }
 
             DROP_VECTOR.with(|v| {
-                for i in 0u..200 {
+                for i in 0..200 {
                     assert_eq!(v.borrow()[i], 1);
                 }
             });
@@ -1795,7 +1795,7 @@ mod test_map {
             let mut half = hm.into_iter().take(50);
 
             DROP_VECTOR.with(|v| {
-                for i in 0u..200 {
+                for i in 0..200 {
                     assert_eq!(v.borrow()[i], 1);
                 }
             });
@@ -1803,11 +1803,11 @@ mod test_map {
             for _ in half.by_ref() {}
 
             DROP_VECTOR.with(|v| {
-                let nk = (0u..100).filter(|&i| {
+                let nk = (0..100).filter(|&i| {
                     v.borrow()[i] == 1
                 }).count();
 
-                let nv = (0u..100).filter(|&i| {
+                let nv = (0..100).filter(|&i| {
                     v.borrow()[i+100] == 1
                 }).count();
 
@@ -1817,7 +1817,7 @@ mod test_map {
         };
 
         DROP_VECTOR.with(|v| {
-            for i in 0u..200 {
+            for i in 0..200 {
                 assert_eq!(v.borrow()[i], 0);
             }
         });
@@ -1962,7 +1962,7 @@ mod test_map {
     #[test]
     fn test_iterate() {
         let mut m = HashMap::with_capacity(4);
-        for i in 0u..32 {
+        for i in 0..32 {
             assert!(m.insert(i, i*2).is_none());
         }
         assert_eq!(m.len(), 32);
@@ -1979,8 +1979,8 @@ mod test_map {
     #[test]
     fn test_keys() {
         let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
-        let map = vec.into_iter().collect::<HashMap<int, char>>();
-        let keys = map.keys().map(|&k| k).collect::<Vec<int>>();
+        let map: HashMap<_, _> = vec.into_iter().collect();
+        let keys: Vec<_> = map.keys().cloned().collect();
         assert_eq!(keys.len(), 3);
         assert!(keys.contains(&1));
         assert!(keys.contains(&2));
@@ -1990,8 +1990,8 @@ mod test_map {
     #[test]
     fn test_values() {
         let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
-        let map = vec.into_iter().collect::<HashMap<int, char>>();
-        let values = map.values().map(|&v| v).collect::<Vec<char>>();
+        let map: HashMap<_, _> = vec.into_iter().collect();
+        let values: Vec<_> = map.values().cloned().collect();
         assert_eq!(values.len(), 3);
         assert!(values.contains(&'a'));
         assert!(values.contains(&'b'));
@@ -2029,8 +2029,8 @@ mod test_map {
 
     #[test]
     fn test_show() {
-        let mut map: HashMap<int, int> = HashMap::new();
-        let empty: HashMap<int, int> = HashMap::new();
+        let mut map = HashMap::new();
+        let empty: HashMap<i32, i32> = HashMap::new();
 
         map.insert(1, 2);
         map.insert(3, 4);
@@ -2049,7 +2049,7 @@ mod test_map {
         assert_eq!(m.len(), 0);
         assert!(m.is_empty());
 
-        let mut i = 0u;
+        let mut i = 0;
         let old_cap = m.table.capacity();
         while old_cap == m.table.capacity() {
             m.insert(i, i);
@@ -2077,7 +2077,7 @@ mod test_map {
 
         assert_eq!(cap, initial_cap * 2);
 
-        let mut i = 0u;
+        let mut i = 0;
         for _ in 0..cap * 3 / 4 {
             m.insert(i, i);
             i += 1;
@@ -2119,21 +2119,21 @@ mod test_map {
     #[test]
     fn test_reserve_shrink_to_fit() {
         let mut m = HashMap::new();
-        m.insert(0u, 0u);
+        m.insert(0, 0);
         m.remove(&0);
         assert!(m.capacity() >= m.len());
-        for i in 0us..128 {
+        for i in 0..128 {
             m.insert(i, i);
         }
         m.reserve(256);
 
         let usable_cap = m.capacity();
-        for i in 128us..128+256 {
+        for i in 128..(128 + 256) {
             m.insert(i, i);
             assert_eq!(m.capacity(), usable_cap);
         }
 
-        for i in 100us..128+256 {
+        for i in 100..(128 + 256) {
             assert_eq!(m.remove(&i), Some(i));
         }
         m.shrink_to_fit();
@@ -2142,7 +2142,7 @@ mod test_map {
         assert!(!m.is_empty());
         assert!(m.capacity() >= m.len());
 
-        for i in 0us..100 {
+        for i in 0..100 {
             assert_eq!(m.remove(&i), Some(i));
         }
         m.shrink_to_fit();
@@ -2157,7 +2157,7 @@ mod test_map {
     fn test_from_iter() {
         let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
 
-        let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+        let map: HashMap<_, _> = xs.iter().cloned().collect();
 
         for &(k, v) in &xs {
             assert_eq!(map.get(&k), Some(&v));
@@ -2168,7 +2168,7 @@ mod test_map {
     fn test_size_hint() {
         let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
 
-        let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+        let map: HashMap<_, _>  = xs.iter().cloned().collect();
 
         let mut iter = map.iter();
 
@@ -2181,7 +2181,7 @@ mod test_map {
     fn test_iter_len() {
         let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
 
-        let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+        let map: HashMap<_, _>  = xs.iter().cloned().collect();
 
         let mut iter = map.iter();
 
@@ -2194,7 +2194,7 @@ mod test_map {
     fn test_mut_size_hint() {
         let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
 
-        let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+        let mut map: HashMap<_, _>  = xs.iter().cloned().collect();
 
         let mut iter = map.iter_mut();
 
@@ -2207,7 +2207,7 @@ mod test_map {
     fn test_iter_mut_len() {
         let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
 
-        let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+        let mut map: HashMap<_, _>  = xs.iter().cloned().collect();
 
         let mut iter = map.iter_mut();
 
@@ -2218,7 +2218,7 @@ mod test_map {
 
     #[test]
     fn test_index() {
-        let mut map: HashMap<int, int> = HashMap::new();
+        let mut map = HashMap::new();
 
         map.insert(1, 2);
         map.insert(2, 1);
@@ -2230,7 +2230,7 @@ mod test_map {
     #[test]
     #[should_fail]
     fn test_index_nonexistent() {
-        let mut map: HashMap<int, int> = HashMap::new();
+        let mut map = HashMap::new();
 
         map.insert(1, 2);
         map.insert(2, 1);
@@ -2243,7 +2243,7 @@ mod test_map {
     fn test_entry(){
         let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
 
-        let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
+        let mut map: HashMap<_, _> = xs.iter().cloned().collect();
 
         // Existing key (insert)
         match map.entry(1) {
@@ -2294,7 +2294,7 @@ mod test_map {
     #[test]
     fn test_entry_take_doesnt_corrupt() {
         // Test for #19292
-        fn check(m: &HashMap<int, ()>) {
+        fn check(m: &HashMap<isize, ()>) {
             for k in m.keys() {
                 assert!(m.contains_key(k),
                         "{} is in keys() but not in the map?", k);
@@ -2305,12 +2305,12 @@ mod test_map {
         let mut rng = weak_rng();
 
         // Populate the map with some items.
-        for _ in 0u..50 {
+        for _ in 0..50 {
             let x = rng.gen_range(-10, 10);
             m.insert(x, ());
         }
 
-        for i in 0u..1000 {
+        for i in 0..1000 {
             let x = rng.gen_range(-10, 10);
             match m.entry(x) {
                 Vacant(_) => {},
diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs
index f5877e1dd99..a4641f14e30 100644
--- a/src/libstd/collections/hash/set.rs
+++ b/src/libstd/collections/hash/set.rs
@@ -76,7 +76,7 @@ use super::state::HashState;
 /// #[derive(Hash, Eq, PartialEq, Debug)]
 /// struct Viking<'a> {
 ///     name: &'a str,
-///     power: uint,
+///     power: usize,
 /// }
 ///
 /// let mut vikings = HashSet::new();
@@ -123,7 +123,7 @@ impl<T: Hash<Hasher> + Eq> HashSet<T, RandomState> {
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_capacity(capacity: uint) -> HashSet<T, RandomState> {
+    pub fn with_capacity(capacity: usize) -> HashSet<T, RandomState> {
         HashSet { map: HashMap::with_capacity(capacity) }
     }
 }
@@ -174,7 +174,7 @@ impl<T, S, H> HashSet<T, S>
     /// ```
     #[inline]
     #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")]
-    pub fn with_capacity_and_hash_state(capacity: uint, hash_state: S)
+    pub fn with_capacity_and_hash_state(capacity: usize, hash_state: S)
                                         -> HashSet<T, S> {
         HashSet {
             map: HashMap::with_capacity_and_hash_state(capacity, hash_state),
@@ -192,7 +192,7 @@ impl<T, S, H> HashSet<T, S>
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn capacity(&self) -> uint {
+    pub fn capacity(&self) -> usize {
         self.map.capacity()
     }
 
@@ -202,7 +202,7 @@ impl<T, S, H> HashSet<T, S>
     ///
     /// # Panics
     ///
-    /// Panics if the new allocation size overflows `uint`.
+    /// Panics if the new allocation size overflows `usize`.
     ///
     /// # Example
     ///
@@ -212,7 +212,7 @@ impl<T, S, H> HashSet<T, S>
     /// set.reserve(10);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve(&mut self, additional: uint) {
+    pub fn reserve(&mut self, additional: usize) {
         self.map.reserve(additional)
     }
 
@@ -402,7 +402,7 @@ impl<T, S, H> HashSet<T, S>
     /// assert_eq!(v.len(), 1);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> uint { self.map.len() }
+    pub fn len(&self) -> usize { self.map.len() }
 
     /// Returns true if the set contains no elements
     ///
@@ -456,7 +456,7 @@ impl<T, S, H> HashSet<T, S>
     /// ```
     /// use std::collections::HashSet;
     ///
-    /// let set: HashSet<uint> = [1, 2, 3].iter().map(|&x| x).collect();
+    /// let set: HashSet<_> = [1, 2, 3].iter().cloned().collect();
     /// assert_eq!(set.contains(&1), true);
     /// assert_eq!(set.contains(&4), false);
     /// ```
@@ -475,8 +475,8 @@ impl<T, S, H> HashSet<T, S>
     /// ```
     /// use std::collections::HashSet;
     ///
-    /// let a: HashSet<uint> = [1, 2, 3].iter().map(|&x| x).collect();
-    /// let mut b: HashSet<uint> = HashSet::new();
+    /// let a: HashSet<_> = [1, 2, 3].iter().cloned().collect();
+    /// let mut b = HashSet::new();
     ///
     /// assert_eq!(a.is_disjoint(&b), true);
     /// b.insert(4);
@@ -496,8 +496,8 @@ impl<T, S, H> HashSet<T, S>
     /// ```
     /// use std::collections::HashSet;
     ///
-    /// let sup: HashSet<uint> = [1, 2, 3].iter().map(|&x| x).collect();
-    /// let mut set: HashSet<uint> = HashSet::new();
+    /// let sup: HashSet<_> = [1, 2, 3].iter().cloned().collect();
+    /// let mut set = HashSet::new();
     ///
     /// assert_eq!(set.is_subset(&sup), true);
     /// set.insert(2);
@@ -517,8 +517,8 @@ impl<T, S, H> HashSet<T, S>
     /// ```
     /// use std::collections::HashSet;
     ///
-    /// let sub: HashSet<uint> = [1, 2].iter().map(|&x| x).collect();
-    /// let mut set: HashSet<uint> = HashSet::new();
+    /// let sub: HashSet<_> = [1, 2].iter().cloned().collect();
+    /// let mut set = HashSet::new();
     ///
     /// assert_eq!(set.is_superset(&sub), false);
     ///
@@ -670,10 +670,10 @@ impl<'a, 'b, T, S, H> BitOr<&'b HashSet<T, S>> for &'a HashSet<T, S>
     /// ```
     /// use std::collections::HashSet;
     ///
-    /// let a: HashSet<int> = vec![1, 2, 3].into_iter().collect();
-    /// let b: HashSet<int> = vec![3, 4, 5].into_iter().collect();
+    /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
+    /// let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();
     ///
-    /// let set: HashSet<int> = &a | &b;
+    /// let set = &a | &b;
     ///
     /// let mut i = 0;
     /// let expected = [1, 2, 3, 4, 5];
@@ -703,10 +703,10 @@ impl<'a, 'b, T, S, H> BitAnd<&'b HashSet<T, S>> for &'a HashSet<T, S>
     /// ```
     /// use std::collections::HashSet;
     ///
-    /// let a: HashSet<int> = vec![1, 2, 3].into_iter().collect();
-    /// let b: HashSet<int> = vec![2, 3, 4].into_iter().collect();
+    /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
+    /// let b: HashSet<_> = vec![2, 3, 4].into_iter().collect();
     ///
-    /// let set: HashSet<int> = &a & &b;
+    /// let set = &a & &b;
     ///
     /// let mut i = 0;
     /// let expected = [2, 3];
@@ -736,10 +736,10 @@ impl<'a, 'b, T, S, H> BitXor<&'b HashSet<T, S>> for &'a HashSet<T, S>
     /// ```
     /// use std::collections::HashSet;
     ///
-    /// let a: HashSet<int> = vec![1, 2, 3].into_iter().collect();
-    /// let b: HashSet<int> = vec![3, 4, 5].into_iter().collect();
+    /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
+    /// let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();
     ///
-    /// let set: HashSet<int> = &a ^ &b;
+    /// let set = &a ^ &b;
     ///
     /// let mut i = 0;
     /// let expected = [1, 2, 4, 5];
@@ -769,10 +769,10 @@ impl<'a, 'b, T, S, H> Sub<&'b HashSet<T, S>> for &'a HashSet<T, S>
     /// ```
     /// use std::collections::HashSet;
     ///
-    /// let a: HashSet<int> = vec![1, 2, 3].into_iter().collect();
-    /// let b: HashSet<int> = vec![3, 4, 5].into_iter().collect();
+    /// let a: HashSet<_> = vec![1, 2, 3].into_iter().collect();
+    /// let b: HashSet<_> = vec![3, 4, 5].into_iter().collect();
     ///
-    /// let set: HashSet<int> = &a - &b;
+    /// let set = &a - &b;
     ///
     /// let mut i = 0;
     /// let expected = [1, 2];
@@ -1029,7 +1029,7 @@ mod test_set {
     #[test]
     fn test_iterate() {
         let mut a = HashSet::new();
-        for i in 0u..32 {
+        for i in 0..32 {
             assert!(a.insert(i));
         }
         let mut observed: u32 = 0;
@@ -1152,7 +1152,7 @@ mod test_set {
     fn test_from_iter() {
         let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
 
-        let set: HashSet<int> = xs.iter().map(|&x| x).collect();
+        let set: HashSet<_> = xs.iter().cloned().collect();
 
         for x in &xs {
             assert!(set.contains(x));
@@ -1198,8 +1198,8 @@ mod test_set {
 
     #[test]
     fn test_show() {
-        let mut set: HashSet<int> = HashSet::new();
-        let empty: HashSet<int> = HashSet::new();
+        let mut set = HashSet::new();
+        let empty = HashSet::<i32>::new();
 
         set.insert(1);
         set.insert(2);
@@ -1212,19 +1212,19 @@ mod test_set {
 
     #[test]
     fn test_trivial_drain() {
-        let mut s = HashSet::<int>::new();
+        let mut s = HashSet::<i32>::new();
         for _ in s.drain() {}
         assert!(s.is_empty());
         drop(s);
 
-        let mut s = HashSet::<int>::new();
+        let mut s = HashSet::<i32>::new();
         drop(s.drain());
         assert!(s.is_empty());
     }
 
     #[test]
     fn test_drain() {
-        let mut s: HashSet<i32> = (1..100).collect();
+        let mut s: HashSet<_> = (1..100).collect();
 
         // try this a bunch of times to make sure we don't screw up internal state.
         for _ in 0..20 {
diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs
index 8952b816901..0bb6bd4cf35 100644
--- a/src/libstd/collections/hash/table.rs
+++ b/src/libstd/collections/hash/table.rs
@@ -67,8 +67,8 @@ const EMPTY_BUCKET: u64 = 0u64;
 /// but in general is just a tricked out `Vec<Option<u64, K, V>>`.
 #[unsafe_no_drop_flag]
 pub struct RawTable<K, V> {
-    capacity: uint,
-    size:     uint,
+    capacity: usize,
+    size:     usize,
     hashes:   *mut u64,
     // Because K/V do not appear directly in any of the types in the struct,
     // inform rustc that in fact instances of K and V are reachable from here.
@@ -88,7 +88,7 @@ impl<K,V> Copy for RawBucket<K,V> {}
 
 pub struct Bucket<K, V, M> {
     raw:   RawBucket<K, V>,
-    idx:   uint,
+    idx:   usize,
     table: M
 }
 
@@ -96,13 +96,13 @@ impl<K,V,M:Copy> Copy for Bucket<K,V,M> {}
 
 pub struct EmptyBucket<K, V, M> {
     raw:   RawBucket<K, V>,
-    idx:   uint,
+    idx:   usize,
     table: M
 }
 
 pub struct FullBucket<K, V, M> {
     raw:   RawBucket<K, V>,
-    idx:   uint,
+    idx:   usize,
     table: M
 }
 
@@ -190,7 +190,7 @@ impl<K, V, M> FullBucket<K, V, M> {
         self.table
     }
     /// Get the raw index.
-    pub fn index(&self) -> uint {
+    pub fn index(&self) -> usize {
         self.idx
     }
 }
@@ -212,21 +212,21 @@ impl<K, V, M> Bucket<K, V, M> {
         self.table
     }
     /// Get the raw index.
-    pub fn index(&self) -> uint {
+    pub fn index(&self) -> usize {
         self.idx
     }
 }
 
 impl<K, V, M: Deref<Target=RawTable<K, V>>> Bucket<K, V, M> {
     pub fn new(table: M, hash: SafeHash) -> Bucket<K, V, M> {
-        Bucket::at_index(table, hash.inspect() as uint)
+        Bucket::at_index(table, hash.inspect() as usize)
     }
 
-    pub fn at_index(table: M, ib_index: uint) -> Bucket<K, V, M> {
+    pub fn at_index(table: M, ib_index: usize) -> Bucket<K, V, M> {
         let ib_index = ib_index & (table.capacity() - 1);
         Bucket {
             raw: unsafe {
-               table.first_bucket_raw().offset(ib_index as int)
+               table.first_bucket_raw().offset(ib_index as isize)
             },
             idx: ib_index,
             table: table
@@ -276,7 +276,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> Bucket<K, V, M> {
         // ... and it's zero at all other times.
         let maybe_wraparound_dist = (self.idx ^ (self.idx + 1)) & self.table.capacity();
         // Finally, we obtain the offset 1 or the offset -cap + 1.
-        let dist = 1 - (maybe_wraparound_dist as int);
+        let dist = 1 - (maybe_wraparound_dist as isize);
 
         self.idx += 1;
 
@@ -366,11 +366,11 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> FullBucket<K, V, M> {
     ///
     /// In the cited blog posts above, this is called the "distance to
     /// initial bucket", or DIB. Also known as "probe count".
-    pub fn distance(&self) -> uint {
+    pub fn distance(&self) -> usize {
         // Calculates the distance one has to travel when going from
         // `hash mod capacity` onwards to `idx mod capacity`, wrapping around
         // if the destination is not reached before the end of the table.
-        (self.idx - self.hash().inspect() as uint) & (self.table.capacity() - 1)
+        (self.idx - self.hash().inspect() as usize) & (self.table.capacity() - 1)
     }
 
     #[inline]
@@ -503,7 +503,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> GapThenFull<K, V, M> {
 /// # Panics
 ///
 /// Panics if `target_alignment` is not a power of two.
-fn round_up_to_next(unrounded: uint, target_alignment: uint) -> uint {
+fn round_up_to_next(unrounded: usize, target_alignment: usize) -> usize {
     assert!(target_alignment.is_power_of_two());
     (unrounded + target_alignment - 1) & !(target_alignment - 1)
 }
@@ -520,10 +520,10 @@ fn test_rounding() {
 
 // Returns a tuple of (key_offset, val_offset),
 // from the start of a mallocated array.
-fn calculate_offsets(hashes_size: uint,
-                     keys_size: uint, keys_align: uint,
-                     vals_align: uint)
-                     -> (uint, uint) {
+fn calculate_offsets(hashes_size: usize,
+                     keys_size: usize, keys_align: usize,
+                     vals_align: usize)
+                     -> (usize, usize) {
     let keys_offset = round_up_to_next(hashes_size, keys_align);
     let end_of_keys = keys_offset + keys_size;
 
@@ -534,10 +534,10 @@ fn calculate_offsets(hashes_size: uint,
 
 // Returns a tuple of (minimum required malloc alignment, hash_offset,
 // array_size), from the start of a mallocated array.
-fn calculate_allocation(hash_size: uint, hash_align: uint,
-                        keys_size: uint, keys_align: uint,
-                        vals_size: uint, vals_align: uint)
-                        -> (uint, uint, uint) {
+fn calculate_allocation(hash_size: usize, hash_align: usize,
+                        keys_size: usize, keys_align: usize,
+                        vals_size: usize, vals_align: usize)
+                        -> (usize, usize, usize) {
     let hash_offset = 0;
     let (_, vals_offset) = calculate_offsets(hash_size,
                                              keys_size, keys_align,
@@ -562,7 +562,7 @@ fn test_offset_calculation() {
 impl<K, V> RawTable<K, V> {
     /// Does not initialize the buckets. The caller should ensure they,
     /// at the very least, set every hash to EMPTY_BUCKET.
-    unsafe fn new_uninitialized(capacity: uint) -> RawTable<K, V> {
+    unsafe fn new_uninitialized(capacity: usize) -> RawTable<K, V> {
         if capacity == 0 {
             return RawTable {
                 size: 0,
@@ -601,7 +601,7 @@ impl<K, V> RawTable<K, V> {
         let buffer = allocate(size, malloc_alignment);
         if buffer.is_null() { ::alloc::oom() }
 
-        let hashes = buffer.offset(hash_offset as int) as *mut u64;
+        let hashes = buffer.offset(hash_offset as isize) as *mut u64;
 
         RawTable {
             capacity: capacity,
@@ -623,15 +623,15 @@ impl<K, V> RawTable<K, V> {
         unsafe {
             RawBucket {
                 hash: self.hashes,
-                key:  buffer.offset(keys_offset as int) as *mut K,
-                val:  buffer.offset(vals_offset as int) as *mut V
+                key:  buffer.offset(keys_offset as isize) as *mut K,
+                val:  buffer.offset(vals_offset as isize) as *mut V
             }
         }
     }
 
     /// Creates a new raw table from a given capacity. All buckets are
     /// initially empty.
-    pub fn new(capacity: uint) -> RawTable<K, V> {
+    pub fn new(capacity: usize) -> RawTable<K, V> {
         unsafe {
             let ret = RawTable::new_uninitialized(capacity);
             zero_memory(ret.hashes, capacity);
@@ -640,13 +640,13 @@ impl<K, V> RawTable<K, V> {
     }
 
     /// The hashtable's capacity, similar to a vector's.
-    pub fn capacity(&self) -> uint {
+    pub fn capacity(&self) -> usize {
         self.capacity
     }
 
     /// The number of elements ever `put` in the hashtable, minus the number
     /// of elements ever `take`n.
-    pub fn size(&self) -> uint {
+    pub fn size(&self) -> usize {
         self.size
     }
 
@@ -654,7 +654,7 @@ impl<K, V> RawTable<K, V> {
         RawBuckets {
             raw: self.first_bucket_raw(),
             hashes_end: unsafe {
-                self.hashes.offset(self.capacity as int)
+                self.hashes.offset(self.capacity as isize)
             },
             marker: marker::ContravariantLifetime,
         }
@@ -705,7 +705,7 @@ impl<K, V> RawTable<K, V> {
     unsafe fn rev_move_buckets(&mut self) -> RevMoveBuckets<K, V> {
         let raw_bucket = self.first_bucket_raw();
         RevMoveBuckets {
-            raw: raw_bucket.offset(self.capacity as int),
+            raw: raw_bucket.offset(self.capacity as isize),
             hashes_end: raw_bucket.hash,
             elems_left: self.size,
             marker:     marker::ContravariantLifetime,
@@ -758,7 +758,7 @@ impl<'a, K, V> Iterator for RawBuckets<'a, K, V> {
 struct RevMoveBuckets<'a, K, V> {
     raw: RawBucket<K, V>,
     hashes_end: *mut u64,
-    elems_left: uint,
+    elems_left: usize,
     marker: marker::ContravariantLifetime<'a>,
 }
 
@@ -791,7 +791,7 @@ impl<'a, K, V> Iterator for RevMoveBuckets<'a, K, V> {
 /// Iterator over shared references to entries in a table.
 pub struct Iter<'a, K: 'a, V: 'a> {
     iter: RawBuckets<'a, K, V>,
-    elems_left: uint,
+    elems_left: usize,
 }
 
 // FIXME(#19839) Remove in favor of `#[derive(Clone)]`
@@ -808,7 +808,7 @@ impl<'a, K, V> Clone for Iter<'a, K, V> {
 /// Iterator over mutable references to entries in a table.
 pub struct IterMut<'a, K: 'a, V: 'a> {
     iter: RawBuckets<'a, K, V>,
-    elems_left: uint,
+    elems_left: usize,
 }
 
 /// Iterator over the entries in a table, consuming the table.