diff --git a/src/compiletest/runtest.rs b/src/compiletest/runtest.rs
index c3ac40e8f08d4..6720b9a530f23 100644
--- a/src/compiletest/runtest.rs
+++ b/src/compiletest/runtest.rs
@@ -1178,7 +1178,7 @@ fn make_run_args(config: &Config, props: &TestProps, testfile: &Path) ->
     // Add the arguments in the run_flags directive
     args.push_all_move(split_maybe_args(&props.run_flags));
 
-    let prog = args.shift().unwrap();
+    let prog = args.remove(0).unwrap();
     return ProcArgs {
         prog: prog,
         args: args,
diff --git a/src/etc/vim/syntax/rust.vim b/src/etc/vim/syntax/rust.vim
index e3fadccd1c9fd..0204d42a726ff 100644
--- a/src/etc/vim/syntax/rust.vim
+++ b/src/etc/vim/syntax/rust.vim
@@ -100,7 +100,7 @@ syn keyword rustTrait Clone
 syn keyword rustTrait PartialEq PartialOrd Eq Ord Equiv
 syn keyword rustEnum Ordering
 syn keyword rustEnumVariant Less Equal Greater
-syn keyword rustTrait Collection Mutable Map MutableMap
+syn keyword rustTrait Collection Mutable Map MutableMap MutableSeq
 syn keyword rustTrait Set MutableSet
 syn keyword rustTrait FromIterator Extendable ExactSize
 syn keyword rustTrait Iterator DoubleEndedIterator
diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs
index 9b4f879e61ea4..27174de8e7416 100644
--- a/src/liballoc/arc.rs
+++ b/src/liballoc/arc.rs
@@ -268,6 +268,7 @@ impl<T: Share + Send> Drop for Weak<T> {
 #[allow(experimental)]
 mod tests {
     use std::clone::Clone;
+    use std::collections::MutableSeq;
     use std::comm::channel;
     use std::mem::drop;
     use std::ops::Drop;
diff --git a/src/libcollections/bitv.rs b/src/libcollections/bitv.rs
index f1e9eabe8d1ed..44af3d52db982 100644
--- a/src/libcollections/bitv.rs
+++ b/src/libcollections/bitv.rs
@@ -72,7 +72,7 @@ use core::slice;
 use core::uint;
 use std::hash;
 
-use {Collection, Mutable, Set, MutableSet};
+use {Collection, Mutable, Set, MutableSet, MutableSeq};
 use vec::Vec;
 
 
@@ -1574,7 +1574,7 @@ mod tests {
     use std::rand::Rng;
     use test::Bencher;
 
-    use {Set, Mutable, MutableSet};
+    use {Set, Mutable, MutableSet, MutableSeq};
     use bitv::{Bitv, BitvSet, from_fn, from_bytes};
     use bitv;
     use vec::Vec;
diff --git a/src/libcollections/btree.rs b/src/libcollections/btree.rs
index e4605527ce550..947c87daa8460 100644
--- a/src/libcollections/btree.rs
+++ b/src/libcollections/btree.rs
@@ -24,7 +24,7 @@ use alloc::boxed::Box;
 use core::fmt;
 use core::fmt::Show;
 
-use Collection;
+use {Collection, MutableSeq};
 use vec::Vec;
 
 #[allow(missing_doc)]
@@ -782,6 +782,8 @@ mod test_btree {
 
     use super::{BTree, Node, LeafElt};
 
+    use MutableSeq;
+
     //Tests the functionality of the insert methods (which are unfinished).
     #[test]
     fn insert_test_one() {
diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs
index 48ea1bd1c0150..68b6416b69bf5 100644
--- a/src/libcollections/dlist.rs
+++ b/src/libcollections/dlist.rs
@@ -30,7 +30,7 @@ use core::iter;
 use core::mem;
 use core::ptr;
 
-use {Collection, Mutable, Deque};
+use {Collection, Mutable, Deque, MutableSeq};
 
 /// A doubly-linked list.
 pub struct DList<T> {
@@ -249,18 +249,13 @@ impl<T> Deque<T> for DList<T> {
     fn pop_front(&mut self) -> Option<T> {
         self.pop_front_node().map(|box Node{value, ..}| value)
     }
+}
 
-    /// Add an element last in the list
-    ///
-    /// O(1)
-    fn push_back(&mut self, elt: T) {
+impl<T> MutableSeq<T> for DList<T> {
+    fn push(&mut self, elt: T) {
         self.push_back_node(box Node::new(elt))
     }
-
-    /// Remove the last element and return it, or None if the list is empty
-    ///
-    /// O(1)
-    fn pop_back(&mut self) -> Option<T> {
+    fn pop(&mut self) -> Option<T> {
         self.pop_back_node().map(|box Node{value, ..}| value)
     }
 }
@@ -284,12 +279,12 @@ impl<T> DList<T> {
     /// # Example
     ///
     /// ```rust
-    /// use std::collections::{DList, Deque};
+    /// use std::collections::DList;
     ///
     /// let mut dl = DList::new();
-    /// dl.push_back(1i);
-    /// dl.push_back(2);
-    /// dl.push_back(3);
+    /// dl.push(1i);
+    /// dl.push(2);
+    /// dl.push(3);
     ///
     /// dl.rotate_forward();
     ///
@@ -311,12 +306,12 @@ impl<T> DList<T> {
     /// # Example
     ///
     /// ```rust
-    /// use std::collections::{DList, Deque};
+    /// use std::collections::DList;
     ///
     /// let mut dl = DList::new();
-    /// dl.push_back(1i);
-    /// dl.push_back(2);
-    /// dl.push_back(3);
+    /// dl.push(1i);
+    /// dl.push(2);
+    /// dl.push(3);
     ///
     /// dl.rotate_backward();
     ///
@@ -338,14 +333,14 @@ impl<T> DList<T> {
     /// # Example
     ///
     /// ```rust
-    /// use std::collections::{DList, Deque};
+    /// use std::collections::DList;
     ///
     /// let mut a = DList::new();
     /// let mut b = DList::new();
-    /// a.push_back(1i);
-    /// a.push_back(2);
-    /// b.push_back(3i);
-    /// b.push_back(4);
+    /// a.push(1i);
+    /// a.push(2);
+    /// b.push(3i);
+    /// b.push(4);
     ///
     /// a.append(b);
     ///
@@ -379,14 +374,14 @@ impl<T> DList<T> {
     /// # Example
     ///
     /// ```rust
-    /// use std::collections::{DList, Deque};
+    /// use std::collections::DList;
     ///
     /// let mut a = DList::new();
     /// let mut b = DList::new();
-    /// a.push_back(1i);
-    /// a.push_back(2);
-    /// b.push_back(3i);
-    /// b.push_back(4);
+    /// a.push(1i);
+    /// a.push(2);
+    /// b.push(3i);
+    /// b.push(4);
     ///
     /// a.prepend(b);
     ///
@@ -408,13 +403,13 @@ impl<T> DList<T> {
     /// # Example
     ///
     /// ```rust
-    /// use std::collections::{DList, Deque};
+    /// use std::collections::DList;
     ///
     /// let mut a: DList<int> = DList::new();
-    /// a.push_back(2i);
-    /// a.push_back(4);
-    /// a.push_back(7);
-    /// a.push_back(8);
+    /// a.push(2i);
+    /// a.push(4);
+    /// a.push(7);
+    /// a.push(8);
     ///
     /// // insert 11 before the first odd number in the list
     /// a.insert_when(11, |&e, _| e % 2 == 1);
@@ -719,7 +714,7 @@ mod tests {
     use test::Bencher;
     use test;
 
-    use Deque;
+    use {Deque, MutableSeq};
     use super::{DList, Node, ListInsertion};
     use vec::Vec;
 
diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs
index 1360b412c2370..ca3f6a746f335 100644
--- a/src/libcollections/enum_set.rs
+++ b/src/libcollections/enum_set.rs
@@ -141,6 +141,8 @@ mod test {
 
     use enum_set::{EnumSet, CLike};
 
+    use MutableSeq;
+
     #[deriving(PartialEq, Show)]
     #[repr(uint)]
     enum Foo {
diff --git a/src/libcollections/hash/sip.rs b/src/libcollections/hash/sip.rs
index 7168af89b59ea..485dc8c5959b7 100644
--- a/src/libcollections/hash/sip.rs
+++ b/src/libcollections/hash/sip.rs
@@ -281,6 +281,8 @@ mod tests {
     use super::super::{Hash, Writer};
     use super::{SipState, hash, hash_with_keys};
 
+    use MutableSeq;
+
     // Hash just the bytes of the slice, without length prefix
     struct Bytes<'a>(&'a [u8]);
 
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
index fba89df1bbc6b..d2d8ad696d7c5 100644
--- a/src/libcollections/lib.rs
+++ b/src/libcollections/lib.rs
@@ -325,6 +325,30 @@ pub trait MutableSet<T>: Set<T> + Mutable {
     fn remove(&mut self, value: &T) -> bool;
 }
 
+pub trait MutableSeq<T>: Mutable {
+    /// Append an element to the back of a collection.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// let mut vec = vec!(1i, 2);
+    /// vec.push(3);
+    /// assert_eq!(vec, vec!(1, 2, 3));
+    /// ```
+    fn push(&mut self, t: T);
+    /// Remove the last element from a collection and return it, or `None` if it is
+    /// empty.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// let mut vec = vec!(1i, 2, 3);
+    /// assert_eq!(vec.pop(), Some(3));
+    /// assert_eq!(vec, vec!(1, 2));
+    /// ```
+    fn pop(&mut self) -> Option<T>;
+}
+
 /// A double-ended sequence that allows querying, insertion and deletion at both
 /// ends.
 ///
@@ -336,9 +360,9 @@ pub trait MutableSet<T>: Set<T> + Mutable {
 /// use std::collections::{RingBuf, Deque};
 ///
 /// let mut queue = RingBuf::new();
-/// queue.push_back(1i);
-/// queue.push_back(2i);
-/// queue.push_back(3i);
+/// queue.push(1i);
+/// queue.push(2i);
+/// queue.push(3i);
 ///
 /// // Will print 1, 2, 3
 /// while !queue.is_empty() {
@@ -374,17 +398,17 @@ pub trait MutableSet<T>: Set<T> + Mutable {
 /// // Init deque with 1, 2, 3, 4
 /// deque.push_front(2i);
 /// deque.push_front(1i);
-/// deque.push_back(3i);
-/// deque.push_back(4i);
+/// deque.push(3i);
+/// deque.push(4i);
 ///
 /// // Will print (1, 4) and (2, 3)
 /// while !deque.is_empty() {
 ///     let f = deque.pop_front().unwrap();
-///     let b = deque.pop_back().unwrap();
+///     let b = deque.pop().unwrap();
 ///     println!("{}", (f, b));
 /// }
 /// ```
-pub trait Deque<T> : Mutable {
+pub trait Deque<T> : MutableSeq<T> {
     /// Provide a reference to the front element, or `None` if the sequence is
     /// empty.
     ///
@@ -396,8 +420,8 @@ pub trait Deque<T> : Mutable {
     /// let mut d = RingBuf::new();
     /// assert_eq!(d.front(), None);
     ///
-    /// d.push_back(1i);
-    /// d.push_back(2i);
+    /// d.push(1i);
+    /// d.push(2i);
     /// assert_eq!(d.front(), Some(&1i));
     /// ```
     fn front<'a>(&'a self) -> Option<&'a T>;
@@ -413,8 +437,8 @@ pub trait Deque<T> : Mutable {
     /// let mut d = RingBuf::new();
     /// assert_eq!(d.front_mut(), None);
     ///
-    /// d.push_back(1i);
-    /// d.push_back(2i);
+    /// d.push(1i);
+    /// d.push(2i);
     /// match d.front_mut() {
     ///     Some(x) => *x = 9i,
     ///     None => (),
@@ -434,8 +458,8 @@ pub trait Deque<T> : Mutable {
     /// let mut d = DList::new();
     /// assert_eq!(d.back(), None);
     ///
-    /// d.push_back(1i);
-    /// d.push_back(2i);
+    /// d.push(1i);
+    /// d.push(2i);
     /// assert_eq!(d.back(), Some(&2i));
     /// ```
     fn back<'a>(&'a self) -> Option<&'a T>;
@@ -451,8 +475,8 @@ pub trait Deque<T> : Mutable {
     /// let mut d = DList::new();
     /// assert_eq!(d.back(), None);
     ///
-    /// d.push_back(1i);
-    /// d.push_back(2i);
+    /// d.push(1i);
+    /// d.push(2i);
     /// match d.back_mut() {
     ///     Some(x) => *x = 9i,
     ///     None => (),
@@ -479,7 +503,7 @@ pub trait Deque<T> : Mutable {
     ///
     /// # Example
     ///
-    /// ```
+    /// ```ignore
     /// use std::collections::{DList, Deque};
     ///
     /// let mut d = DList::new();
@@ -487,13 +511,14 @@ pub trait Deque<T> : Mutable {
     /// d.push_back(2i);
     /// assert_eq!(d.front(), Some(&1i));
     /// ```
-    fn push_back(&mut self, elt: T);
+    #[deprecated = "use the `push` method"]
+    fn push_back(&mut self, elt: T) { self.push(elt) }
 
     /// Remove the last element and return it, or `None` if the sequence is empty.
     ///
     /// # Example
     ///
-    /// ```
+    /// ```ignore
     /// use std::collections::{RingBuf, Deque};
     ///
     /// let mut d = RingBuf::new();
@@ -504,7 +529,8 @@ pub trait Deque<T> : Mutable {
     /// assert_eq!(d.pop_back(), Some(1i));
     /// assert_eq!(d.pop_back(), None);
     /// ```
-    fn pop_back(&mut self) -> Option<T>;
+    #[deprecated = "use the `pop` method"]
+    fn pop_back(&mut self) -> Option<T> { self.pop() }
 
     /// Remove the first element and return it, or `None` if the sequence is empty.
     ///
@@ -514,8 +540,8 @@ pub trait Deque<T> : Mutable {
     /// use std::collections::{RingBuf, Deque};
     ///
     /// let mut d = RingBuf::new();
-    /// d.push_back(1i);
-    /// d.push_back(2i);
+    /// d.push(1i);
+    /// d.push(2i);
     ///
     /// assert_eq!(d.pop_front(), Some(1i));
     /// assert_eq!(d.pop_front(), Some(2i));
@@ -535,4 +561,8 @@ mod std {
     pub use core::clone;    // deriving(Clone)
     pub use core::cmp;      // deriving(Eq, Ord, etc.)
     pub use hash;           // deriving(Hash)
+
+    pub mod collections {
+        pub use MutableSeq;
+    }
 }
diff --git a/src/libcollections/priority_queue.rs b/src/libcollections/priority_queue.rs
index 9451f2521c89a..6e1a3ec1cb6c8 100644
--- a/src/libcollections/priority_queue.rs
+++ b/src/libcollections/priority_queue.rs
@@ -154,7 +154,7 @@ use core::default::Default;
 use core::mem::{zeroed, replace, swap};
 use core::ptr;
 
-use {Collection, Mutable};
+use {Collection, Mutable, MutableSeq};
 use slice;
 use vec::Vec;
 
@@ -388,6 +388,7 @@ mod tests {
 
     use priority_queue::PriorityQueue;
     use vec::Vec;
+    use MutableSeq;
 
     #[test]
     fn test_iterator() {
diff --git a/src/libcollections/ringbuf.rs b/src/libcollections/ringbuf.rs
index 5e19accdd6715..3a4e66b38ae3f 100644
--- a/src/libcollections/ringbuf.rs
+++ b/src/libcollections/ringbuf.rs
@@ -20,7 +20,7 @@ use core::default::Default;
 use core::fmt;
 use core::iter::RandomAccessIterator;
 
-use {Deque, Collection, Mutable};
+use {Deque, Collection, Mutable, MutableSeq};
 use vec::Vec;
 
 static INITIAL_CAPACITY: uint = 8u; // 2^3
@@ -80,17 +80,6 @@ impl<T> Deque<T> for RingBuf<T> {
         result
     }
 
-    /// Remove and return the last element in the RingBuf, or None if it is empty
-    fn pop_back(&mut self) -> Option<T> {
-        if self.nelts > 0 {
-            self.nelts -= 1;
-            let hi = self.raw_index(self.nelts);
-            self.elts.get_mut(hi).take()
-        } else {
-            None
-        }
-    }
-
     /// Prepend an element to the RingBuf
     fn push_front(&mut self, t: T) {
         if self.nelts == self.elts.len() {
@@ -102,9 +91,10 @@ impl<T> Deque<T> for RingBuf<T> {
         *self.elts.get_mut(self.lo) = Some(t);
         self.nelts += 1u;
     }
+}
 
-    /// Append an element to the RingBuf
-    fn push_back(&mut self, t: T) {
+impl<T> MutableSeq<T> for RingBuf<T> {
+    fn push(&mut self, t: T) {
         if self.nelts == self.elts.len() {
             grow(self.nelts, &mut self.lo, &mut self.elts);
         }
@@ -112,6 +102,15 @@ impl<T> Deque<T> for RingBuf<T> {
         *self.elts.get_mut(hi) = Some(t);
         self.nelts += 1u;
     }
+    fn pop(&mut self) -> Option<T> {
+        if self.nelts > 0 {
+            self.nelts -= 1;
+            let hi = self.raw_index(self.nelts);
+            self.elts.get_mut(hi).take()
+        } else {
+            None
+        }
+    }
 }
 
 impl<T> Default for RingBuf<T> {
@@ -423,7 +422,7 @@ mod tests {
     use test::Bencher;
     use test;
 
-    use {Deque, Mutable};
+    use {Deque, Mutable, MutableSeq};
     use super::RingBuf;
     use vec::Vec;
 
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
index 6c3c8437e255a..64062dc0ccbf8 100644
--- a/src/libcollections/slice.rs
+++ b/src/libcollections/slice.rs
@@ -107,7 +107,7 @@ use core::mem;
 use core::ptr;
 use core::iter::{range_step, MultiplicativeIterator};
 
-use Collection;
+use {Collection, MutableSeq};
 use vec::Vec;
 
 pub use core::slice::{ref_slice, mut_ref_slice, Splits, Windows};
@@ -731,7 +731,7 @@ mod tests {
     use std::rt;
     use slice::*;
 
-    use Mutable;
+    use {Mutable, MutableSeq};
     use vec::Vec;
 
     fn square(n: uint) -> uint { n * n }
@@ -2133,6 +2133,7 @@ mod bench {
     use test::Bencher;
 
     use vec::Vec;
+    use MutableSeq;
 
     #[bench]
     fn iterator(b: &mut Bencher) {
diff --git a/src/libcollections/smallintmap.rs b/src/libcollections/smallintmap.rs
index ca62b1235d554..eb97215c721bc 100644
--- a/src/libcollections/smallintmap.rs
+++ b/src/libcollections/smallintmap.rs
@@ -22,7 +22,7 @@ use core::fmt;
 use core::iter::{Enumerate, FilterMap};
 use core::mem::replace;
 
-use {Collection, Mutable, Map, MutableMap};
+use {Collection, Mutable, Map, MutableMap, MutableSeq};
 use {vec, slice};
 use vec::Vec;
 
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
index 48bc492e25ce4..c0e903677de35 100644
--- a/src/libcollections/str.rs
+++ b/src/libcollections/str.rs
@@ -77,7 +77,7 @@ use core::cmp;
 use core::iter::AdditiveIterator;
 use core::mem;
 
-use Collection;
+use {Collection, MutableSeq};
 use hash;
 use string::String;
 use unicode;
@@ -562,6 +562,8 @@ pub mod raw {
     use string::String;
     use vec::Vec;
 
+    use MutableSeq;
+
     pub use core::str::raw::{from_utf8, c_str_to_static_slice, slice_bytes};
     pub use core::str::raw::{slice_unchecked};
 
@@ -818,7 +820,7 @@ mod tests {
     use std::option::{Some, None};
     use std::ptr::RawPtr;
     use std::iter::{Iterator, DoubleEndedIterator};
-    use Collection;
+    use {Collection, MutableSeq};
 
     use super::*;
     use std::slice::{Vector, ImmutableVector};
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
index b19bef685901f..d58dfdd10d131 100644
--- a/src/libcollections/string.rs
+++ b/src/libcollections/string.rs
@@ -20,7 +20,7 @@ use core::mem;
 use core::ptr;
 use core::raw::Slice;
 
-use {Collection, Mutable};
+use {Collection, Mutable, MutableSeq};
 use hash;
 use str;
 use str::{CharRange, StrAllocating, MaybeOwned, Owned, Slice};
@@ -575,7 +575,7 @@ mod tests {
     use std::prelude::*;
     use test::Bencher;
 
-    use Mutable;
+    use {Mutable, MutableSeq};
     use str;
     use str::{Str, StrSlice, Owned, Slice};
     use super::String;
diff --git a/src/libcollections/treemap.rs b/src/libcollections/treemap.rs
index 8c24326c84092..5658d07a1d175 100644
--- a/src/libcollections/treemap.rs
+++ b/src/libcollections/treemap.rs
@@ -40,7 +40,7 @@ use core::mem::{replace, swap};
 use core::ptr;
 use std::hash::{Writer, Hash};
 
-use {Collection, Mutable, Set, MutableSet, MutableMap, Map};
+use {Collection, Mutable, Set, MutableSet, MutableMap, Map, MutableSeq};
 use vec::Vec;
 
 // This is implemented as an AA tree, which is a simplified variation of
@@ -1127,7 +1127,7 @@ mod test_treemap {
     use std::rand::Rng;
     use std::rand;
 
-    use {Map, MutableMap, Mutable};
+    use {Map, MutableMap, Mutable, MutableSeq};
     use super::{TreeMap, TreeNode};
 
     #[test]
@@ -1659,7 +1659,7 @@ mod test_set {
     use std::prelude::*;
     use std::hash;
 
-    use {Set, MutableSet, Mutable, MutableMap};
+    use {Set, MutableSet, Mutable, MutableMap, MutableSeq};
     use super::{TreeMap, TreeSet};
 
     #[test]
diff --git a/src/libcollections/trie.rs b/src/libcollections/trie.rs
index 424cda92c12d4..5a00c4b85dafa 100644
--- a/src/libcollections/trie.rs
+++ b/src/libcollections/trie.rs
@@ -682,7 +682,7 @@ mod test_map {
     use std::uint;
     use std::hash;
 
-    use {MutableMap, Map};
+    use {MutableMap, Map, MutableSeq};
     use super::{TrieMap, TrieNode, Internal, External, Nothing};
 
     fn check_integrity<T>(trie: &TrieNode<T>) {
@@ -1105,7 +1105,7 @@ mod test_set {
     use std::prelude::*;
     use std::uint;
 
-    use {MutableSet, Set};
+    use {MutableSet, Set, MutableSeq};
     use super::TrieSet;
 
     #[test]
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
index 0002867495c78..dcee92f6dbced 100644
--- a/src/libcollections/vec.rs
+++ b/src/libcollections/vec.rs
@@ -23,7 +23,7 @@ use core::num;
 use core::ptr;
 use core::uint;
 
-use {Collection, Mutable};
+use {Collection, Mutable, MutableSeq};
 use slice::{MutableOrdVector, MutableVectorAllocating, CloneableVector};
 use slice::{Items, MutItems};
 
@@ -666,67 +666,6 @@ impl<T> Vec<T> {
         }
     }
 
-    /// Remove the last element from a vector and return it, or `None` if it is
-    /// empty.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// let mut vec = vec![1i, 2, 3];
-    /// assert_eq!(vec.pop(), Some(3));
-    /// assert_eq!(vec, vec![1, 2]);
-    /// ```
-    #[inline]
-    pub fn pop(&mut self) -> Option<T> {
-        if self.len == 0 {
-            None
-        } else {
-            unsafe {
-                self.len -= 1;
-                Some(ptr::read(self.as_slice().unsafe_ref(self.len())))
-            }
-        }
-    }
-
-    /// Append an element to a vector.
-    ///
-    /// # Failure
-    ///
-    /// Fails if the number of elements in the vector overflows a `uint`.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// let mut vec = vec![1i, 2];
-    /// vec.push(3);
-    /// assert_eq!(vec, vec![1, 2, 3]);
-    /// ```
-    #[inline]
-    pub fn push(&mut self, value: T) {
-        if mem::size_of::<T>() == 0 {
-            // zero-size types consume no memory, so we can't rely on the address space running out
-            self.len = self.len.checked_add(&1).expect("length overflow");
-            unsafe { mem::forget(value); }
-            return
-        }
-        if self.len == self.cap {
-            let old_size = self.cap * mem::size_of::<T>();
-            let size = max(old_size, 2 * mem::size_of::<T>()) * 2;
-            if old_size > size { fail!("capacity overflow") }
-            unsafe {
-                self.ptr = alloc_or_realloc(self.ptr, size,
-                                            self.cap * mem::size_of::<T>());
-            }
-            self.cap = max(self.cap, 2) * 2;
-        }
-
-        unsafe {
-            let end = (self.ptr as *const T).offset(self.len as int) as *mut T;
-            ptr::write(&mut *end, value);
-            self.len += 1;
-        }
-    }
-
     /// Appends one element to the vector provided. The vector itself is then
     /// returned for use again.
     ///
@@ -1042,12 +981,13 @@ impl<T> Vec<T> {
     ///
     /// # Example
     ///
-    /// ```
+    /// ```ignore
     /// let mut vec = vec![1i, 2, 3];
     /// vec.unshift(4);
     /// assert_eq!(vec, vec![4, 1, 2, 3]);
     /// ```
     #[inline]
+    #[deprecated = "use insert(0, ...)"]
     pub fn unshift(&mut self, element: T) {
         self.insert(0, element)
     }
@@ -1068,6 +1008,7 @@ impl<T> Vec<T> {
     /// assert_eq!(vec, vec![2, 3]);
     /// ```
     #[inline]
+    #[deprecated = "use remove(0)"]
     pub fn shift(&mut self) -> Option<T> {
         self.remove(0)
     }
@@ -1615,6 +1556,60 @@ impl<T:fmt::Show> fmt::Show for Vec<T> {
     }
 }
 
+impl<T> MutableSeq<T> for Vec<T> {
+    /// Append an element to the back of a collection.
+    ///
+    /// # Failure
+    ///
+    /// Fails if the number of elements in the vector overflows a `uint`.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// let mut vec = vec!(1i, 2);
+    /// vec.push(3);
+    /// assert_eq!(vec, vec!(1, 2, 3));
+    /// ```
+    #[inline]
+    fn push(&mut self, value: T) {
+        if mem::size_of::<T>() == 0 {
+            // zero-size types consume no memory, so we can't rely on the address space running out
+            self.len = self.len.checked_add(&1).expect("length overflow");
+            unsafe { mem::forget(value); }
+            return
+        }
+        if self.len == self.cap {
+            let old_size = self.cap * mem::size_of::<T>();
+            let size = max(old_size, 2 * mem::size_of::<T>()) * 2;
+            if old_size > size { fail!("capacity overflow") }
+            unsafe {
+                self.ptr = alloc_or_realloc(self.ptr, size,
+                                            self.cap * mem::size_of::<T>());
+            }
+            self.cap = max(self.cap, 2) * 2;
+        }
+
+        unsafe {
+            let end = (self.ptr as *const T).offset(self.len as int) as *mut T;
+            ptr::write(&mut *end, value);
+            self.len += 1;
+        }
+    }
+
+    #[inline]
+    fn pop(&mut self) -> Option<T> {
+        if self.len == 0 {
+            None
+        } else {
+            unsafe {
+                self.len -= 1;
+                Some(ptr::read(self.as_slice().unsafe_ref(self.len())))
+            }
+        }
+    }
+
+}
+
 /// An iterator that moves out of a vector.
 pub struct MoveItems<T> {
     allocation: *mut T, // the block of memory allocated for the vector
@@ -1704,6 +1699,8 @@ mod tests {
     use test::Bencher;
     use super::{unzip, raw, Vec};
 
+    use MutableSeq;
+
     #[test]
     fn test_small_vec_struct() {
         assert!(size_of::<Vec<u8>>() == size_of::<uint>() * 3);
diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs
index d53fed7aa80fc..a1fd62cecbed9 100644
--- a/src/libregex/parse.rs
+++ b/src/libregex/parse.rs
@@ -998,7 +998,7 @@ fn concat_flatten(x: Ast, y: Ast) -> Ast {
     match (x, y) {
         (Cat(mut xs), Cat(ys)) => { xs.push_all_move(ys); Cat(xs) }
         (Cat(mut xs), ast) => { xs.push(ast); Cat(xs) }
-        (ast, Cat(mut xs)) => { xs.unshift(ast); Cat(xs) }
+        (ast, Cat(mut xs)) => { xs.insert(0, ast); Cat(xs) }
         (ast1, ast2) => Cat(vec!(ast1, ast2)),
     }
 }
diff --git a/src/librustc/lib/llvmdeps.rs b/src/librustc/lib/llvmdeps.rs
deleted file mode 100644
index 05e5e585a63ab..0000000000000
--- a/src/librustc/lib/llvmdeps.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// WARNING: THIS IS A GENERATED FILE, DO NOT MODIFY
-//          take a look at src/etc/mklldeps.py if you're interested
-
-#[cfg(target_arch = "x86_64", target_os = "linux")]
-#[link(name = "LLVMInstrumentation", kind = "static")]
-#[link(name = "LLVMInterpreter", kind = "static")]
-#[link(name = "LLVMMCJIT", kind = "static")]
-#[link(name = "LLVMRuntimeDyld", kind = "static")]
-#[link(name = "LLVMJIT", kind = "static")]
-#[link(name = "LLVMExecutionEngine", kind = "static")]
-#[link(name = "LLVMAsmParser", kind = "static")]
-#[link(name = "LLVMLinker", kind = "static")]
-#[link(name = "LLVMBitWriter", kind = "static")]
-#[link(name = "LLVMipo", kind = "static")]
-#[link(name = "LLVMVectorize", kind = "static")]
-#[link(name = "LLVMMipsDisassembler", kind = "static")]
-#[link(name = "LLVMMipsCodeGen", kind = "static")]
-#[link(name = "LLVMMipsAsmParser", kind = "static")]
-#[link(name = "LLVMMipsDesc", kind = "static")]
-#[link(name = "LLVMMipsInfo", kind = "static")]
-#[link(name = "LLVMMipsAsmPrinter", kind = "static")]
-#[link(name = "LLVMARMDisassembler", kind = "static")]
-#[link(name = "LLVMARMCodeGen", kind = "static")]
-#[link(name = "LLVMARMAsmParser", kind = "static")]
-#[link(name = "LLVMARMDesc", kind = "static")]
-#[link(name = "LLVMARMInfo", kind = "static")]
-#[link(name = "LLVMARMAsmPrinter", kind = "static")]
-#[link(name = "LLVMX86Disassembler", kind = "static")]
-#[link(name = "LLVMX86AsmParser", kind = "static")]
-#[link(name = "LLVMX86CodeGen", kind = "static")]
-#[link(name = "LLVMSelectionDAG", kind = "static")]
-#[link(name = "LLVMAsmPrinter", kind = "static")]
-#[link(name = "LLVMMCParser", kind = "static")]
-#[link(name = "LLVMCodeGen", kind = "static")]
-#[link(name = "LLVMScalarOpts", kind = "static")]
-#[link(name = "LLVMInstCombine", kind = "static")]
-#[link(name = "LLVMTransformUtils", kind = "static")]
-#[link(name = "LLVMipa", kind = "static")]
-#[link(name = "LLVMAnalysis", kind = "static")]
-#[link(name = "LLVMTarget", kind = "static")]
-#[link(name = "LLVMX86Desc", kind = "static")]
-#[link(name = "LLVMX86Info", kind = "static")]
-#[link(name = "LLVMX86AsmPrinter", kind = "static")]
-#[link(name = "LLVMMC", kind = "static")]
-#[link(name = "LLVMObject", kind = "static")]
-#[link(name = "LLVMBitReader", kind = "static")]
-#[link(name = "LLVMCore", kind = "static")]
-#[link(name = "LLVMX86Utils", kind = "static")]
-#[link(name = "LLVMSupport", kind = "static")]
-#[link(name = "pthread")]
-#[link(name = "dl")]
-#[link(name = "m")]
-#[link(name = "stdc++")]
-extern {}
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 76b3a012dbfb0..b992a11bc6483 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -361,7 +361,7 @@ fn rust_input(cratefile: &str, externs: core::Externs, matches: &getopts::Matche
     }
     if default_passes {
         for name in DEFAULT_PASSES.iter().rev() {
-            passes.unshift(name.to_string());
+            passes.insert(0, name.to_string());
         }
     }
 
diff --git a/src/librustdoc/markdown.rs b/src/librustdoc/markdown.rs
index 47009c1f2cc15..416018cadd2a8 100644
--- a/src/librustdoc/markdown.rs
+++ b/src/librustdoc/markdown.rs
@@ -136,7 +136,7 @@ pub fn test(input: &str, libs: HashSet<Path>, externs: core::Externs,
 
     let mut collector = Collector::new(input.to_string(), libs, externs, true);
     find_testable_code(input_str.as_slice(), &mut collector);
-    test_args.unshift("rustdoctest".to_string());
+    test_args.insert(0, "rustdoctest".to_string());
     testing::test_main(test_args.as_slice(), collector.tests);
     0
 }
diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs
index 2ed35469dfa8d..aef6af1677ab0 100644
--- a/src/librustdoc/test.rs
+++ b/src/librustdoc/test.rs
@@ -97,7 +97,7 @@ pub fn run(input: &str,
                                        false);
     collector.fold_crate(krate);
 
-    test_args.unshift("rustdoctest".to_string());
+    test_args.insert(0, "rustdoctest".to_string());
 
     testing::test_main(test_args.as_slice(),
                        collector.tests.move_iter().collect());
diff --git a/src/librustrt/at_exit_imp.rs b/src/librustrt/at_exit_imp.rs
index 1faf492e498ac..c9188e81975c6 100644
--- a/src/librustrt/at_exit_imp.rs
+++ b/src/librustrt/at_exit_imp.rs
@@ -15,6 +15,7 @@
 use core::prelude::*;
 
 use alloc::boxed::Box;
+use collections::MutableSeq;
 use collections::vec::Vec;
 use core::atomics;
 use core::mem;
diff --git a/src/librustrt/local_data.rs b/src/librustrt/local_data.rs
index 7434951d3ee91..b7366f440d034 100644
--- a/src/librustrt/local_data.rs
+++ b/src/librustrt/local_data.rs
@@ -41,6 +41,7 @@ assert_eq!(*key_vector.get().unwrap(), vec![4]);
 use core::prelude::*;
 
 use alloc::boxed::Box;
+use collections::MutableSeq;
 use collections::vec::Vec;
 use core::kinds::marker;
 use core::mem;
diff --git a/src/librustuv/access.rs b/src/librustuv/access.rs
index 63d9aa7ead0a0..bcbcde3fba515 100644
--- a/src/librustuv/access.rs
+++ b/src/librustuv/access.rs
@@ -114,7 +114,7 @@ impl<'a> Drop for Guard<'a> {
             mem::transmute(self.access.inner.get())
         };
 
-        match inner.queue.shift() {
+        match inner.queue.remove(0) {
             // Here we have found a task that was waiting for access, and we
             // current have the "access lock" we need to relinquish access to
             // this sleeping task.
diff --git a/src/libserialize/collection_impls.rs b/src/libserialize/collection_impls.rs
index b74d20ffc54fa..79166935a5e7f 100644
--- a/src/libserialize/collection_impls.rs
+++ b/src/libserialize/collection_impls.rs
@@ -15,7 +15,7 @@ use std::default::Default;
 use std::hash::{Hash, Hasher};
 
 use {Decodable, Encodable, Decoder, Encoder};
-use std::collections::{DList, RingBuf, TreeMap, TreeSet, Deque, HashMap, HashSet,
+use std::collections::{DList, RingBuf, TreeMap, TreeSet, HashMap, HashSet,
                        TrieMap, TrieSet};
 use std::collections::enum_set::{EnumSet, CLike};
 
@@ -39,7 +39,7 @@ impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for DList<T> {
         d.read_seq(|d, len| {
             let mut list = DList::new();
             for i in range(0u, len) {
-                list.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
+                list.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
             }
             Ok(list)
         })
@@ -66,7 +66,7 @@ impl<E, D:Decoder<E>,T:Decodable<D, E>> Decodable<D, E> for RingBuf<T> {
         d.read_seq(|d, len| {
             let mut deque: RingBuf<T> = RingBuf::new();
             for i in range(0u, len) {
-                deque.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
+                deque.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
             }
             Ok(deque)
         })
diff --git a/src/libstd/collections/hashmap.rs b/src/libstd/collections/hashmap.rs
index a05fad3705dd5..922858e963c0a 100644
--- a/src/libstd/collections/hashmap.rs
+++ b/src/libstd/collections/hashmap.rs
@@ -1291,7 +1291,7 @@ impl<K: Eq + Hash<S>, V, S, H: Hasher<S>> HashMap<K, V, H> {
     ///         // new value based on the first letter of the key.
     ///         |key, already, new| {
     ///             if key.as_slice().starts_with("z") {
-    ///                 already.unshift(new);
+    ///                 already.insert(0, new);
     ///             } else {
     ///                 already.push(new);
     ///             }
diff --git a/src/libstd/collections/mod.rs b/src/libstd/collections/mod.rs
index ccef1c0fd2adb..d98d490a84b27 100644
--- a/src/libstd/collections/mod.rs
+++ b/src/libstd/collections/mod.rs
@@ -15,7 +15,7 @@
 #![experimental]
 
 pub use core_collections::{Collection, Mutable, Map, MutableMap};
-pub use core_collections::{Set, MutableSet, Deque};
+pub use core_collections::{Set, MutableSet, Deque, MutableSeq};
 pub use core_collections::{Bitv, BitvSet, BTree, DList, EnumSet};
 pub use core_collections::{PriorityQueue, RingBuf, SmallIntMap};
 pub use core_collections::{TreeMap, TreeSet, TrieMap, TrieSet};
diff --git a/src/libstd/dynamic_lib.rs b/src/libstd/dynamic_lib.rs
index 86283f03381dd..5980245fa79a2 100644
--- a/src/libstd/dynamic_lib.rs
+++ b/src/libstd/dynamic_lib.rs
@@ -20,6 +20,7 @@ A simple wrapper over the platform's dynamic library facilities
 #![allow(missing_doc)]
 
 use clone::Clone;
+use collections::MutableSeq;
 use c_str::ToCStr;
 use iter::Iterator;
 use mem;
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index ca3eee01575fd..5215aec5dfbfa 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -15,7 +15,7 @@
 // FIXME: Not sure how this should be structured
 // FIXME: Iteration should probably be considered separately
 
-use collections::Collection;
+use collections::{Collection, MutableSeq};
 use iter::Iterator;
 use option::{Option, Some, None};
 use result::{Ok, Err};
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index afd88ee0ed91b..c7dec49a76d1f 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -53,7 +53,7 @@ fs::unlink(&path);
 
 use c_str::ToCStr;
 use clone::Clone;
-use collections::Collection;
+use collections::{Collection, MutableSeq};
 use io::standard_error;
 use io::{FilePermission, Write, UnstableFileStat, Open, FileAccess, FileMode};
 use io::{IoResult, IoError, FileStat, SeekStyle, Seek, Writer, Reader};
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index 642654ba6ed81..cb754135bc152 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -18,6 +18,7 @@
 //! listener (socket server) implements the `Listener` and `Acceptor` traits.
 
 use clone::Clone;
+use collections::MutableSeq;
 use io::IoResult;
 use iter::Iterator;
 use slice::ImmutableVector;
diff --git a/src/libstd/io/signal.rs b/src/libstd/io/signal.rs
index d46f437cddd50..c126866e7159a 100644
--- a/src/libstd/io/signal.rs
+++ b/src/libstd/io/signal.rs
@@ -20,6 +20,7 @@ definitions for a number of signals.
 */
 
 use clone::Clone;
+use collections::MutableSeq;
 use comm::{Sender, Receiver, channel};
 use io;
 use iter::Iterator;
diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs
index e14092bc8dc16..125c3fdf5d90c 100644
--- a/src/libstd/lib.rs
+++ b/src/libstd/lib.rs
@@ -288,4 +288,6 @@ mod std {
     #[cfg(test)] pub use os = realstd::os;
     // The test runner requires std::slice::Vector, so re-export std::slice just for it.
     #[cfg(test)] pub use slice;
+
+    pub use collections; // vec!() uses MutableSeq
 }
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index cc30acf064b82..c8528e752e89a 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -14,7 +14,7 @@
 
 use char;
 use clone::Clone;
-use collections::Collection;
+use collections::{Collection, MutableSeq};
 use num::{NumCast, Zero, One, cast, Int};
 use num::{Float, FPNaN, FPInfinite, ToPrimitive};
 use num;
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 96d3b3e3e6a53..f71f1d22d009d 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -32,7 +32,7 @@
 #![allow(non_snake_case_functions)]
 
 use clone::Clone;
-use collections::Collection;
+use collections::{Collection, MutableSeq};
 use fmt;
 use io::{IoResult, IoError};
 use iter::Iterator;
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index ececfab5f7433..0c93f8e6de979 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -65,7 +65,7 @@ println!("path exists: {}", path.exists());
 
 #![experimental]
 
-use collections::Collection;
+use collections::{Collection, MutableSeq};
 use c_str::CString;
 use clone::Clone;
 use fmt;
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 007686aa05cd5..877ca2c7e013f 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -13,7 +13,7 @@
 use c_str::{CString, ToCStr};
 use clone::Clone;
 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
-use collections::Collection;
+use collections::{Collection, MutableSeq};
 use from_str::FromStr;
 use hash;
 use io::Writer;
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 4a6ed5612334c..d9b802b38fdeb 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -16,7 +16,7 @@ use ascii::AsciiCast;
 use c_str::{CString, ToCStr};
 use clone::Clone;
 use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
-use collections::Collection;
+use collections::{Collection, MutableSeq};
 use from_str::FromStr;
 use hash;
 use io::Writer;
diff --git a/src/libstd/prelude.rs b/src/libstd/prelude.rs
index 0fa223305a669..0ce7497cf300e 100644
--- a/src/libstd/prelude.rs
+++ b/src/libstd/prelude.rs
@@ -63,7 +63,7 @@
 #[doc(no_inline)] pub use clone::Clone;
 #[doc(no_inline)] pub use cmp::{PartialEq, PartialOrd, Eq, Ord};
 #[doc(no_inline)] pub use cmp::{Ordering, Less, Equal, Greater, Equiv};
-#[doc(no_inline)] pub use collections::{Collection, Mutable, Map, MutableMap};
+#[doc(no_inline)] pub use collections::{Collection, Mutable, Map, MutableMap, MutableSeq};
 #[doc(no_inline)] pub use collections::{Set, MutableSet};
 #[doc(no_inline)] pub use iter::{FromIterator, Extendable, ExactSize};
 #[doc(no_inline)] pub use iter::{Iterator, DoubleEndedIterator};
diff --git a/src/libsync/deque.rs b/src/libsync/deque.rs
index 913a58010d496..c541cc02774e0 100644
--- a/src/libsync/deque.rs
+++ b/src/libsync/deque.rs
@@ -55,7 +55,7 @@ use core::prelude::*;
 use alloc::arc::Arc;
 use alloc::heap::{allocate, deallocate};
 use alloc::boxed::Box;
-use collections::Vec;
+use collections::{Vec, MutableSeq};
 use core::kinds::marker;
 use core::mem::{forget, min_align_of, size_of, transmute};
 use core::ptr;
diff --git a/src/libsync/raw.rs b/src/libsync/raw.rs
index d056566bb9a97..1bdf24ea7dd51 100644
--- a/src/libsync/raw.rs
+++ b/src/libsync/raw.rs
@@ -22,7 +22,7 @@ use core::finally::Finally;
 use core::kinds::marker;
 use core::mem;
 use core::ty::Unsafe;
-use collections::Vec;
+use collections::{Vec, MutableSeq};
 
 use mutex;
 use comm::{Receiver, Sender, channel};
diff --git a/src/libterm/terminfo/parm.rs b/src/libterm/terminfo/parm.rs
index db76e78d1617c..1410f225a298b 100644
--- a/src/libterm/terminfo/parm.rs
+++ b/src/libterm/terminfo/parm.rs
@@ -514,12 +514,12 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<Vec<u8> ,String> {
                 FormatDigit => {
                     if flags.space && !(s[0] == '-' as u8 ||
                                         s[0] == '+' as u8) {
-                        s.unshift(' ' as u8);
+                        s.insert(0, ' ' as u8);
                     }
                 }
                 FormatOctal => {
                     if flags.alternate && s[0] != '0' as u8 {
-                        s.unshift('0' as u8);
+                        s.insert(0, '0' as u8);
                     }
                 }
                 FormatHex => {