core: Remove _mut functions from vec

Instead, use vec::to_mut/from_mut to transform vectors in place as
needed.

8 files changed, 14 insertions, 14 deletions

diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs
index d02d78eaab8..eb9d21ac31e 100644
--- a/src/libstd/bitv.rs
+++ b/src/libstd/bitv.rs
@@ -49,7 +49,7 @@ init - If true then the bits are initialized to 1, otherwise 0
 */
 fn create(nbits: uint, init: bool) -> t {
     let elt = if init { !0u } else { 0u };
-    let storage = vec::init_elt_mut::<uint>(nbits / uint_bits + 1u, elt);
+    let storage = vec::to_mut(vec::init_elt(nbits / uint_bits + 1u, elt));
     ret @{storage: storage, nbits: nbits};
 }
 
@@ -117,7 +117,7 @@ Function: clone
 Makes a copy of a bitvector
 */
 fn clone(v: t) -> t {
-    let storage = vec::init_elt_mut::<uint>(v.nbits / uint_bits + 1u, 0u);
+    let storage = vec::to_mut(vec::init_elt(v.nbits / uint_bits + 1u, 0u));
     let len = vec::len(v.storage);
     uint::range(0u, len) {|i| storage[i] = v.storage[i]; };
     ret @{storage: storage, nbits: v.nbits};
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index e6c30f67302..f12c72f80e1 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -127,7 +127,7 @@ fn create<T: copy>() -> t<T> {
         mutable nelts: 0u,
         mutable lo: 0u,
         mutable hi: 0u,
-        mutable elts: vec::init_elt_mut(initial_capacity, none)
+        mutable elts: vec::to_mut(vec::init_elt(initial_capacity, none))
     };
     repr as t::<T>
 }
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 7b409053cb0..62ef4839d64 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -212,7 +212,7 @@ err(fail_) - On failure. Use <fail_str> to get an error message.
 fn getopts(args: [str], opts: [opt]) -> result unsafe {
     let n_opts = vec::len::<opt>(opts);
     fn f(_x: uint) -> [optval] { ret []; }
-    let vals = vec::init_fn_mut::<[optval]>(n_opts, f);
+    let vals = vec::to_mut(vec::init_fn(n_opts, f));
     let free: [str] = [];
     let l = vec::len(args);
     let i = 0u;
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index 8d3bbac1ce4..c2320e93f29 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -243,7 +243,7 @@ mod chained {
     }
 
     fn chains<K: copy, V: copy>(nchains: uint) -> [mutable chain<K,V>] {
-        ret vec::init_elt_mut(nchains, absent);
+        ret vec::to_mut(vec::init_elt(nchains, absent));
     }
 
     fn foreach_entry<K: copy, V: copy>(chain0: chain<K,V>,
diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs
index 1d6540f04e8..2f1f455dcc4 100644
--- a/src/libstd/md4.rs
+++ b/src/libstd/md4.rs
@@ -30,7 +30,7 @@ fn md4(msg: [u8]) -> {a: u32, b: u32, c: u32, d: u32} {
     }
 
     let i = 0u, e = vec::len(msg);
-    let x = vec::init_elt_mut(16u, 0u32);
+    let x = vec::to_mut(vec::init_elt(16u, 0u32));
     while i < e {
         let aa = a, bb = b, cc = c, dd = d;
 
diff --git a/src/libstd/rope.rs b/src/libstd/rope.rs
index 6b9f7a17f74..225d59b39e1 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -181,7 +181,7 @@ fn concat(v: [rope]) -> rope {
     //Copy `v` into a mutable vector
     let len   = vec::len(v);
     if len == 0u { ret node::empty; }
-    let ropes = vec::init_elt_mut(len, v[0]);
+    let ropes = vec::to_mut(vec::init_elt(len, v[0]));
     uint::range(1u, len) {|i|
        ropes[i] = v[i];
     }
@@ -780,7 +780,7 @@ mod node {
             //Firstly, split `str` in slices of hint_max_leaf_char_len
             let leaves = uint::div_ceil(char_len, hint_max_leaf_char_len);
             //Number of leaves
-            let nodes  = vec::init_elt_mut(leaves, candidate);
+            let nodes  = vec::to_mut(vec::init_elt(leaves, candidate));
 
             let i = 0u;
             let offset = byte_start;
@@ -893,7 +893,7 @@ mod node {
     }
 
     fn serialize_node(node: @node) -> str unsafe {
-        let buf = vec::init_elt_mut(byte_len(node), 0u8);
+        let buf = vec::to_mut(vec::init_elt(byte_len(node), 0u8));
         let offset = 0u;//Current position in the buffer
         let it = leaf_iterator::start(node);
         while true {
@@ -1224,7 +1224,7 @@ mod node {
         }
 
         fn start(node: @node) -> t {
-            let stack = vec::init_elt_mut(height(node)+1u, node);
+            let stack = vec::to_mut(vec::init_elt(height(node)+1u, node));
             ret {
                 stack:             stack,
                 mutable stackpos:  0
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index 9360a84fb97..06702fc140a 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -274,13 +274,13 @@ fn mk_sha1() -> sha1 {
         }
     }
     let st = {
-        h: vec::init_elt_mut(digest_buf_len, 0u32),
+        h: vec::to_mut(vec::init_elt(digest_buf_len, 0u32)),
         mutable len_low: 0u32,
         mutable len_high: 0u32,
-        msg_block: vec::init_elt_mut(msg_block_len, 0u8),
+        msg_block: vec::to_mut(vec::init_elt(msg_block_len, 0u8)),
         mutable msg_block_idx: 0u,
         mutable computed: false,
-        work_buf: vec::init_elt_mut(work_buf_len, 0u32)
+        work_buf: vec::to_mut(vec::init_elt(work_buf_len, 0u32))
     };
     let sh = st as sha1;
     sh.reset();
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index d76e37e5071..b608ddf4a64 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -73,7 +73,7 @@ fn contains_key<T: copy>(m: smallintmap<T>, key: uint) -> bool {
 // FIXME: Are these really useful?
 
 fn truncate<T: copy>(m: smallintmap<T>, len: uint) {
-    m.v = vec::slice_mut::<option<T>>(m.v, 0u, len);
+    m.v = vec::to_mut(vec::slice::<option<T>>(m.v, 0u, len));
 }
 
 fn max_key<T>(m: smallintmap<T>) -> uint {