Overhaul constructor naming in libs

14 files changed, 56 insertions, 58 deletions

diff --git a/src/libstd/bitv.rs b/src/libstd/bitv.rs
index 01bbc1588bb..ee210780a26 100644
--- a/src/libstd/bitv.rs
+++ b/src/libstd/bitv.rs
@@ -37,7 +37,7 @@ Constructs a bitvector
 "]
 fn create(nbits: uint, init: bool) -> t {
     let elt = if init { !0u } else { 0u };
-    let storage = vec::to_mut(vec::init_elt(nbits / uint_bits + 1u, elt));
+    let storage = vec::to_mut(vec::from_elem(nbits / uint_bits + 1u, elt));
     ret @{storage: storage, nbits: nbits};
 }
 
@@ -84,7 +84,7 @@ fn assign(v0: t, v1: t) -> bool { let sub = right; ret process(v0, v1, sub); }
 
 #[doc = "Makes a copy of a bitvector"]
 fn clone(v: t) -> t {
-    let storage = vec::to_mut(vec::init_elt(v.nbits / uint_bits + 1u, 0u));
+    let storage = vec::to_mut(vec::from_elem(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};
@@ -190,7 +190,7 @@ Each uint in the resulting vector has either value 0u or 1u.
 "]
 fn to_vec(v: t) -> [uint] {
     let sub = bind init_to_vec(v, _);
-    ret vec::init_fn::<uint>(v.nbits, sub);
+    ret vec::from_fn::<uint>(v.nbits, sub);
 }
 
 
@@ -232,7 +232,7 @@ mod tests {
         let act;
         let exp;
         act = create(0u, false);
-        exp = vec::init_elt::<uint>(0u, 0u);
+        exp = vec::from_elem::<uint>(0u, 0u);
         assert (eq_vec(act, exp));
     }
 
diff --git a/src/libstd/c_vec.rs b/src/libstd/c_vec.rs
index 99233725362..532f2903af3 100644
--- a/src/libstd/c_vec.rs
+++ b/src/libstd/c_vec.rs
@@ -26,7 +26,7 @@ taken to ensure that a reference to the c_vec::t is still held if needed.
 "];
 
 export t;
-export create, create_with_dtor;
+export c_vec, c_vec_with_dtor;
 export get, set;
 export len;
 export ptr;
@@ -60,7 +60,7 @@ Create a c_vec::t from a native buffer with a given length.
 * base - A native pointer to a buffer
 * len - The number of elements in the buffer
 "]
-unsafe fn create<T>(base: *mutable T, len: uint) -> t<T> {
+unsafe fn c_vec<T>(base: *mutable T, len: uint) -> t<T> {
     ret t({base: base,
            len: len,
            rsrc: @dtor_res(option::none)
@@ -78,7 +78,7 @@ and a function to run upon destruction.
 * dtor - A function to run when the value is destructed, useful
          for freeing the buffer, etc.
 "]
-unsafe fn create_with_dtor<T>(base: *mutable T, len: uint, dtor: fn@())
+unsafe fn c_vec_with_dtor<T>(base: *mutable T, len: uint, dtor: fn@())
   -> t<T> {
     ret t({base: base,
            len: len,
@@ -133,8 +133,8 @@ mod tests {
 
         assert mem as int != 0;
 
-        ret unsafe { create_with_dtor(mem as *mutable u8, n,
-                                      bind free(mem)) };
+        ret unsafe { c_vec_with_dtor(mem as *mutable u8, n,
+                                     bind free(mem)) };
     }
 
     #[test]
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index 83452e6ab68..dfd97978d2a 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -105,7 +105,7 @@ fn create<T: copy>() -> t<T> {
         mutable nelts: 0u,
         mutable lo: 0u,
         mutable hi: 0u,
-        mutable elts: vec::to_mut(vec::init_elt(initial_capacity, none))
+        mutable elts: vec::to_mut(vec::from_elem(initial_capacity, none))
     };
     repr as t::<T>
 }
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 9e39042ded1..931ad32551f 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -25,7 +25,6 @@ export doc_as_i16;
 export doc_as_i32;
 export doc_as_i64;
 export writer;
-export mk_writer;
 
 type ebml_tag = {id: uint, size: uint};
 
@@ -177,7 +176,7 @@ fn write_vuint(w: io::writer, n: uint) {
     fail #fmt("vint to write too big: %?", n);
 }
 
-fn mk_writer(w: io::writer) -> writer {
+fn writer(w: io::writer) -> writer {
     let size_positions: [uint] = [];
     ret {writer: w, mutable size_positions: size_positions};
 }
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 2177f2468ef..19d941fe9f8 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -171,7 +171,7 @@ 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::to_mut(vec::init_fn(n_opts, f));
+    let vals = vec::to_mut(vec::from_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 ded9e1ee208..517654d1c15 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -1,7 +1,7 @@
 #[doc = "A map type"];
 
 import chained::hashmap;
-export hashmap, hashfn, eqfn, set, map, chained, mk_hashmap, new_str_hash;
+export hashmap, hashfn, eqfn, set, map, chained, new_hashmap, new_str_hash;
 export new_bytes_hash, new_int_hash, new_uint_hash, set_add;
 
 #[doc = "
@@ -202,7 +202,7 @@ mod chained {
     }
 
     fn chains<K: copy, V: copy>(nchains: uint) -> [mutable chain<K,V>] {
-        ret vec::to_mut(vec::init_elt(nchains, absent));
+        ret vec::to_mut(vec::from_elem(nchains, absent));
     }
 
     fn foreach_entry<K: copy, V: copy>(chain0: chain<K,V>,
@@ -288,7 +288,7 @@ mod chained {
 }
 
 /*
-Function: mk_hashmap
+Function: new_hashmap
 
 Construct a hashmap.
 
@@ -297,33 +297,33 @@ Parameters:
 hasher - The hash function for key type K
 eqer - The equality function for key type K
 */
-fn mk_hashmap<K: copy, V: copy>(hasher: hashfn<K>, eqer: eqfn<K>)
+fn new_hashmap<K: copy, V: copy>(hasher: hashfn<K>, eqer: eqfn<K>)
         -> hashmap<K, V> {
     chained::mk(hasher, eqer)
 }
 
 #[doc = "Construct a hashmap for string keys"]
 fn new_str_hash<V: copy>() -> hashmap<str, V> {
-    ret mk_hashmap(str::hash, str::eq);
+    ret new_hashmap(str::hash, str::eq);
 }
 
 #[doc = "Construct a hashmap for byte string keys"]
 fn new_bytes_hash<V: copy>() -> hashmap<[u8], V> {
-    ret mk_hashmap(vec::u8::hash, vec::u8::eq);
+    ret new_hashmap(vec::u8::hash, vec::u8::eq);
 }
 
 #[doc = "Construct a hashmap for int keys"]
 fn new_int_hash<V: copy>() -> hashmap<int, V> {
     fn hash_int(&&x: int) -> uint { int::hash(x) }
     fn eq_int(&&a: int, &&b: int) -> bool { ret a == b; }
-    ret mk_hashmap(hash_int, eq_int);
+    ret new_hashmap(hash_int, eq_int);
 }
 
 #[doc = "Construct a hashmap for uint keys"]
 fn new_uint_hash<V: copy>() -> hashmap<uint, V> {
     fn hash_uint(&&x: uint) -> uint { uint::hash(x) }
     fn eq_uint(&&a: uint, &&b: uint) -> bool { ret a == b; }
-    ret mk_hashmap(hash_uint, eq_uint);
+    ret new_hashmap(hash_uint, eq_uint);
 }
 
 #[doc = "
@@ -345,7 +345,7 @@ mod tests {
         let eqer_str: map::eqfn<str> = str::eq;
         #debug("uint -> uint");
         let hm_uu: map::hashmap<uint, uint> =
-            map::mk_hashmap::<uint, uint>(hasher_uint, eqer_uint);
+            map::new_hashmap::<uint, uint>(hasher_uint, eqer_uint);
         assert (hm_uu.insert(10u, 12u));
         assert (hm_uu.insert(11u, 13u));
         assert (hm_uu.insert(12u, 14u));
@@ -361,7 +361,7 @@ mod tests {
         let twelve: str = "twelve";
         #debug("str -> uint");
         let hm_su: map::hashmap<str, uint> =
-            map::mk_hashmap::<str, uint>(hasher_str, eqer_str);
+            map::new_hashmap::<str, uint>(hasher_str, eqer_str);
         assert (hm_su.insert("ten", 12u));
         assert (hm_su.insert(eleven, 13u));
         assert (hm_su.insert("twelve", 14u));
@@ -375,7 +375,7 @@ mod tests {
         assert (hm_su.get("twelve") == 12u);
         #debug("uint -> str");
         let hm_us: map::hashmap<uint, str> =
-            map::mk_hashmap::<uint, str>(hasher_uint, eqer_uint);
+            map::new_hashmap::<uint, str>(hasher_uint, eqer_uint);
         assert (hm_us.insert(10u, "twelve"));
         assert (hm_us.insert(11u, "thirteen"));
         assert (hm_us.insert(12u, "fourteen"));
@@ -388,7 +388,7 @@ mod tests {
         assert (str::eq(hm_us.get(12u), "twelve"));
         #debug("str -> str");
         let hm_ss: map::hashmap<str, str> =
-            map::mk_hashmap::<str, str>(hasher_str, eqer_str);
+            map::new_hashmap::<str, str>(hasher_str, eqer_str);
         assert (hm_ss.insert(ten, "twelve"));
         assert (hm_ss.insert(eleven, "thirteen"));
         assert (hm_ss.insert(twelve, "fourteen"));
@@ -416,7 +416,7 @@ mod tests {
         let hasher_uint: map::hashfn<uint> = uint_id;
         let eqer_uint: map::eqfn<uint> = eq_uint;
         let hm_uu: map::hashmap<uint, uint> =
-            map::mk_hashmap::<uint, uint>(hasher_uint, eqer_uint);
+            map::new_hashmap::<uint, uint>(hasher_uint, eqer_uint);
         let i: uint = 0u;
         while i < num_to_insert {
             assert (hm_uu.insert(i, i * i));
@@ -443,7 +443,7 @@ mod tests {
         let hasher_str: map::hashfn<str> = str::hash;
         let eqer_str: map::eqfn<str> = str::eq;
         let hm_ss: map::hashmap<str, str> =
-            map::mk_hashmap::<str, str>(hasher_str, eqer_str);
+            map::new_hashmap::<str, str>(hasher_str, eqer_str);
         i = 0u;
         while i < num_to_insert {
             assert hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u));
@@ -496,7 +496,7 @@ mod tests {
         let hasher: map::hashfn<uint> = hash;
         let eqer: map::eqfn<uint> = eq;
         let hm: map::hashmap<uint, uint> =
-            map::mk_hashmap::<uint, uint>(hasher, eqer);
+            map::new_hashmap::<uint, uint>(hasher, eqer);
         let i: uint = 0u;
         while i < num_to_insert {
             assert (hm.insert(i, i * i));
@@ -559,7 +559,7 @@ mod tests {
     #[test]
     fn test_contains_key() {
         let key = "k";
-        let map = map::mk_hashmap::<str, str>(str::hash, str::eq);
+        let map = map::new_hashmap::<str, str>(str::hash, str::eq);
         assert (!map.contains_key(key));
         map.insert(key, "val");
         assert (map.contains_key(key));
@@ -568,7 +568,7 @@ mod tests {
     #[test]
     fn test_find() {
         let key = "k";
-        let map = map::mk_hashmap::<str, str>(str::hash, str::eq);
+        let map = map::new_hashmap::<str, str>(str::hash, str::eq);
         assert (option::is_none(map.find(key)));
         map.insert(key, "val");
         assert (option::get(map.find(key)) == "val");
diff --git a/src/libstd/md4.rs b/src/libstd/md4.rs
index 2f1f455dcc4..95c532129e7 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::to_mut(vec::init_elt(16u, 0u32));
+    let x = vec::to_mut(vec::from_elem(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 9c6c1b29c24..e7763050cfa 100644
--- a/src/libstd/rope.rs
+++ b/src/libstd/rope.rs
@@ -157,7 +157,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::to_mut(vec::init_elt(len, v[0]));
+    let ropes = vec::to_mut(vec::from_elem(len, v[0]));
     uint::range(1u, len) {|i|
        ropes[i] = v[i];
     }
@@ -686,7 +686,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::to_mut(vec::init_elt(leaves, candidate));
+            let nodes  = vec::to_mut(vec::from_elem(leaves, candidate));
 
             let i = 0u;
             let offset = byte_start;
@@ -797,7 +797,7 @@ mod node {
     }
 
     fn serialize_node(node: @node) -> str unsafe {
-        let buf = vec::to_mut(vec::init_elt(byte_len(node), 0u8));
+        let buf = vec::to_mut(vec::from_elem(byte_len(node), 0u8));
         let offset = 0u;//Current position in the buffer
         let it = leaf_iterator::start(node);
         loop {
@@ -1126,7 +1126,7 @@ mod node {
         }
 
         fn start(node: @node) -> t {
-            let stack = vec::to_mut(vec::init_elt(height(node)+1u, node));
+            let stack = vec::to_mut(vec::from_elem(height(node)+1u, node));
             ret {
                 stack:             stack,
                 mutable stackpos:  0
@@ -1392,7 +1392,7 @@ mod tests {
         }
 
         //Same rope, obtained with rope::concat
-        let r2 = concat(vec::init_elt(10u, chunk));
+        let r2 = concat(vec::from_elem(10u, chunk));
 
         assert eq(r, r2);
     }
diff --git a/src/libstd/serialization.rs b/src/libstd/serialization.rs
index 19cbd7a610b..c446d10b88e 100644
--- a/src/libstd/serialization.rs
+++ b/src/libstd/serialization.rs
@@ -165,7 +165,7 @@ impl of serializer for ebml::writer {
 type ebml_deserializer = {mutable parent: ebml::doc,
                           mutable pos: uint};
 
-fn mk_ebml_deserializer(d: ebml::doc) -> ebml_deserializer {
+fn ebml_deserializer(d: ebml::doc) -> ebml_deserializer {
     {mutable parent: d, mutable pos: d.start}
 }
 
@@ -401,10 +401,10 @@ fn test_option_int() {
     fn test_v(v: option<int>) {
         #debug["v == %?", v];
         let mbuf = io::mk_mem_buffer();
-        let ebml_w = ebml::mk_writer(io::mem_buffer_writer(mbuf));
+        let ebml_w = ebml::writer(io::mem_buffer_writer(mbuf));
         serialize_0(ebml_w, v);
         let ebml_doc = ebml::new_doc(@io::mem_buffer_buf(mbuf));
-        let deser = mk_ebml_deserializer(ebml_doc);
+        let deser = ebml_deserializer(ebml_doc);
         let v1 = deserialize_0(deser);
         #debug["v1 == %?", v1];
         assert v == v1;
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index 22d26fc2bd9..7d4bc705c1a 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -18,7 +18,6 @@ the `reset` method.
  * point this will want to be rewritten.
  */
 export sha1;
-export mk_sha1;
 
 #[doc = "The SHA-1 interface"]
 iface sha1 {
@@ -51,7 +50,7 @@ const k3: u32 = 0xCA62C1D6u32;
 
 
 #[doc = "Construct a `sha` object"]
-fn mk_sha1() -> sha1 {
+fn sha1() -> sha1 {
     type sha1state =
         {h: [mutable u32],
          mutable len_low: u32,
@@ -244,13 +243,13 @@ fn mk_sha1() -> sha1 {
         }
     }
     let st = {
-        h: vec::to_mut(vec::init_elt(digest_buf_len, 0u32)),
+        h: vec::to_mut(vec::from_elem(digest_buf_len, 0u32)),
         mutable len_low: 0u32,
         mutable len_high: 0u32,
-        msg_block: vec::to_mut(vec::init_elt(msg_block_len, 0u8)),
+        msg_block: vec::to_mut(vec::from_elem(msg_block_len, 0u8)),
         mutable msg_block_idx: 0u,
         mutable computed: false,
-        work_buf: vec::to_mut(vec::init_elt(work_buf_len, 0u32))
+        work_buf: vec::to_mut(vec::from_elem(work_buf_len, 0u32))
     };
     let sh = st as sha1;
     sh.reset();
@@ -327,7 +326,7 @@ mod tests {
         }
         // Test that it works when accepting the message all at once
 
-        let sh = sha1::mk_sha1();
+        let sh = sha1::sha1();
         for t: test in tests {
             sh.input_str(t.input);
             let out = sh.result();
diff --git a/src/libstd/tempfile.rs b/src/libstd/tempfile.rs
index 3ed70bb9535..eb1af5b6dbb 100644
--- a/src/libstd/tempfile.rs
+++ b/src/libstd/tempfile.rs
@@ -5,7 +5,7 @@ import option::{none, some};
 import rand;
 
 fn mkdtemp(prefix: str, suffix: str) -> option<str> {
-    let r = rand::mk_rng();
+    let r = rand::rng();
     let i = 0u;
     while (i < 1000u) {
         let s = prefix + r.gen_str(16u) + suffix;
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 540966b2a78..009da2e440d 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -357,7 +357,7 @@ fn run_test(+test: test_desc, monitor_ch: comm::chan<monitor_msg>) {
     task::spawn {||
 
         let testfn = test.fn;
-        let builder = task::mk_task_builder();
+        let builder = task::task_builder();
         let result_future = task::future_result(builder);
         task::unsupervise(builder);
         task::run(builder, testfn);
diff --git a/src/libstd/treemap.rs b/src/libstd/treemap.rs
index e8084ac4f5e..54e38483a97 100644
--- a/src/libstd/treemap.rs
+++ b/src/libstd/treemap.rs
@@ -10,7 +10,7 @@ import core::option::{some, none};
 import option = core::option;
 
 export treemap;
-export init;
+export treemap;
 export insert;
 export find;
 export traverse;
@@ -20,7 +20,7 @@ type treemap<K, V> = @mutable tree_node<K, V>;
 enum tree_node<K, V> { empty, node(@K, @V, treemap<K, V>, treemap<K, V>) }
 
 #[doc = "Create a treemap"]
-fn init<K, V>() -> treemap<K, V> { @mutable empty }
+fn treemap<K, V>() -> treemap<K, V> { @mutable empty }
 
 #[doc = "Insert a value into the map"]
 fn insert<K: copy, V: copy>(m: treemap<K, V>, k: K, v: V) {
@@ -78,36 +78,36 @@ fn traverse<K, V>(m: treemap<K, V>, f: fn(K, V)) {
 mod tests {
 
     #[test]
-    fn init_treemap() { let _m = init::<int, int>(); }
+    fn init_treemap() { let _m = treemap::<int, int>(); }
 
     #[test]
-    fn insert_one() { let m = init(); insert(m, 1, 2); }
+    fn insert_one() { let m = treemap(); insert(m, 1, 2); }
 
     #[test]
-    fn insert_two() { let m = init(); insert(m, 1, 2); insert(m, 3, 4); }
+    fn insert_two() { let m = treemap(); insert(m, 1, 2); insert(m, 3, 4); }
 
     #[test]
     fn insert_find() {
-        let m = init();
+        let m = treemap();
         insert(m, 1, 2);
         assert (find(m, 1) == some(2));
     }
 
     #[test]
     fn find_empty() {
-        let m = init::<int, int>(); assert (find(m, 1) == none);
+        let m = treemap::<int, int>(); assert (find(m, 1) == none);
     }
 
     #[test]
     fn find_not_found() {
-        let m = init();
+        let m = treemap();
         insert(m, 1, 2);
         assert (find(m, 2) == none);
     }
 
     #[test]
     fn traverse_in_order() {
-        let m = init();
+        let m = treemap();
         insert(m, 3, ());
         insert(m, 0, ());
         insert(m, 4, ());
@@ -123,7 +123,7 @@ mod tests {
 
     #[test]
     fn u8_map() {
-        let m = init();
+        let m = treemap();
 
         let k1 = str::bytes("foo");
         let k2 = str::bytes("bar");
diff --git a/src/libstd/uv.rs b/src/libstd/uv.rs
index d91f4333560..fb7a4883c05 100644
--- a/src/libstd/uv.rs
+++ b/src/libstd/uv.rs
@@ -409,7 +409,7 @@ fn do_send(h: *libc::c_void) {
     rustrt::rust_uv_async_send(h);
 }
 fn gen_handle_id() -> [u8] {
-    ret rand::mk_rng().gen_bytes(16u);
+    ret rand::rng().gen_bytes(16u);
 }
 fn get_handle_id_from(buf: *u8) -> [u8] unsafe {
     ret vec::unsafe::from_buf(buf, 16u);