fixup mutability of vec::each, make iter_bytes pure

also, change DVec() to work with imm vectors rather than mut ones

7 files changed, 76 insertions, 15 deletions

diff --git a/src/libstd/arena.rs b/src/libstd/arena.rs
index a9010759ef9..173348d8dca 100644
--- a/src/libstd/arena.rs
+++ b/src/libstd/arena.rs
@@ -89,7 +89,7 @@ fn round_up_to(base: uint, align: uint) -> uint {
 // in it.
 unsafe fn destroy_chunk(chunk: Chunk) {
     let mut idx = 0;
-    let buf = vec::unsafe::to_ptr_slice(chunk.data);
+    let buf = vec::unsafe::to_ptr(chunk.data);
     let fill = chunk.fill;
 
     while idx < fill {
@@ -156,7 +156,7 @@ impl &Arena {
         //       start, n_bytes, align, head.fill);
 
         unsafe {
-            ptr::offset(vec::unsafe::to_ptr_slice(head.data), start)
+            ptr::offset(vec::unsafe::to_ptr(head.data), start)
         }
     }
 
@@ -200,7 +200,7 @@ impl &Arena {
         //       start, n_bytes, align, head.fill);
 
         unsafe {
-            let buf = vec::unsafe::to_ptr_slice(head.data);
+            let buf = vec::unsafe::to_ptr(head.data);
             return (ptr::offset(buf, tydesc_start), ptr::offset(buf, start));
         }
     }
diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index 1eac198c773..920b969eea9 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -57,7 +57,7 @@ fn create<T: Copy>() -> Deque<T> {
                 self.lo = self.elts.len() - 1u;
             } else { self.lo -= 1u; }
             if self.lo == self.hi {
-                self.elts.swap(|v| grow(self.nelts, oldlo, move v));
+                self.elts.swap_mut(|v| grow(self.nelts, oldlo, move v));
                 self.lo = self.elts.len() - 1u;
                 self.hi = self.nelts;
             }
@@ -66,7 +66,7 @@ fn create<T: Copy>() -> Deque<T> {
         }
         fn add_back(t: T) {
             if self.lo == self.hi && self.nelts != 0u {
-                self.elts.swap(|v| grow(self.nelts, self.lo, move v));
+                self.elts.swap_mut(|v| grow(self.nelts, self.lo, move v));
                 self.lo = 0u;
                 self.hi = self.nelts;
             }
@@ -108,8 +108,7 @@ fn create<T: Copy>() -> Deque<T> {
         mut hi: 0u,
         elts:
             dvec::from_vec(
-                vec::to_mut(
-                    vec::from_elem(initial_capacity, None)))
+                vec::from_elem(initial_capacity, None))
     };
     (move repr) as Deque::<T>
 }
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 79a99fb4220..182c1d61bc0 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -646,12 +646,12 @@ pure fn lt(value0: Json, value1: Json) -> bool {
                         let (d0_flat, d1_flat) = {
                             let d0_flat = dvec::DVec();
                             for d0.each |k, v| { d0_flat.push((k, v)); }
-                            let d0_flat = dvec::unwrap(move d0_flat);
+                            let mut d0_flat = dvec::unwrap(move d0_flat);
                             d0_flat.qsort();
 
                             let mut d1_flat = dvec::DVec();
                             for d1.each |k, v| { d1_flat.push((k, v)); }
-                            let d1_flat = dvec::unwrap(move d1_flat);
+                            let mut d1_flat = dvec::unwrap(move d1_flat);
                             d1_flat.qsort();
 
                             (move d0_flat, move d1_flat)
diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs
index 5652b81b55e..0e422aa1eeb 100644
--- a/src/libstd/net_url.rs
+++ b/src/libstd/net_url.rs
@@ -736,8 +736,8 @@ impl Url: Eq {
 }
 
 impl Url: IterBytes {
-    fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
-        self.to_str().iter_bytes(lsb0, f)
+    pure fn iter_bytes(lsb0: bool, f: to_bytes::Cb) {
+        unchecked { self.to_str() }.iter_bytes(lsb0, f)
     }
 }
 
@@ -1077,11 +1077,11 @@ mod tests {
         assert encode_form_urlencoded(m) == ~"";
 
         let m = str_hash();
-        m.insert(~"foo", @dvec::from_vec(~[mut @~"bar", @~"123"]));
+        m.insert(~"foo", @dvec::from_vec(~[@~"bar", @~"123"]));
         assert encode_form_urlencoded(m) == ~"foo=bar&foo=123";
 
         let m = str_hash();
-        m.insert(~"foo bar", @dvec::from_vec(~[mut @~"abc", @~"12 = 34"]));
+        m.insert(~"foo bar", @dvec::from_vec(~[@~"abc", @~"12 = 34"]));
         assert encode_form_urlencoded(m) == ~"foo+bar=abc&foo+bar=12+%3D+34";
     }
 
diff --git a/src/libstd/set.rs b/src/libstd/set.rs
new file mode 100644
index 00000000000..15c1c160ed1
--- /dev/null
+++ b/src/libstd/set.rs
@@ -0,0 +1,62 @@
+import dvec::dvec;
+import map::{hashfn, eqfn, hashmap};
+
+struct set<K: copy> {
+    mut implementation: option<set_implementation<K>>
+}
+
+struct list_set<K> {
+    hasher: hashfn<K>;
+    eqer: eqfn<K>;
+    elements: ~[K];
+}
+
+enum set_implementation<K: copy> {
+    impl_with_list(list_set<K>),
+    impl_with_map(hashmap<K, ()>)
+}
+
+const threshold: uint = 25; // completely arbitrary.
+
+impl<K> &list_set {
+    pure fn contains(element: &K) {
+        for self.elements.each |existing_element| {
+            if self.eqer(element, existing_element) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    pure fn convert_to_map() -> hashmap<K, ()> {
+        ...
+    }
+}
+
+impl<K: copy> set<K> {
+    fn add(+element: K) -> bool {
+        let mut set_impl = option::swap_unwrap(&mut self.implementation);
+        let contained_before = match set_impl {
+          impl_with_list(ref mut list_set) => {
+            if list_set.elements.len() >= threshold {
+                // convert to a map
+                self.implementation = some(list_set.convert_to_map());
+                return self.add(move element);
+            }
+
+            if list_set.contains(&element) {
+                false
+            } else {
+                vec::push(list_set.elements, element);
+                true
+            }
+          }
+
+          impl_with_map(ref map) => {
+            let contained_before = map.insert(element, ());
+          }
+        }
+        self.implementation = some(move set_impl);
+        return true;
+    }
+}
\ No newline at end of file
diff --git a/src/libstd/sha1.rs b/src/libstd/sha1.rs
index f7cdfd60f50..9808b15dc66 100644
--- a/src/libstd/sha1.rs
+++ b/src/libstd/sha1.rs
@@ -161,7 +161,7 @@ fn sha1() -> Sha1 {
     fn mk_result(st: &Sha1State) -> ~[u8] {
         if !(*st).computed { pad_msg(st); (*st).computed = true; }
         let mut rs: ~[u8] = ~[];
-        for vec::each_mut((*st).h) |ptr_hpart| {
+        for vec::each_mut_ref((*st).h) |ptr_hpart| {
             let hpart = *ptr_hpart;
             let a = (hpart >> 24u32 & 0xFFu32) as u8;
             let b = (hpart >> 16u32 & 0xFFu32) as u8;
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index 339278d3c66..1cb4adac45c 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -92,7 +92,7 @@ impl<V: Copy> SmallIntMap<V>: map::Map<uint, V> {
         old.is_some()
     }
     fn clear() {
-        self.v.set(~[mut]);
+        self.v.set(~[]);
     }
     fn contains_key(+key: uint) -> bool {
         contains_key(self, key)