---

yaml
---
r: 32626
b: refs/heads/dist-snap
c: d0d8434
h: refs/heads/master
v: v3

Author: erickt

[refs]

@@ -7,6 +7,6 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
 refs/heads/incoming: d9317a174e434d4c99fc1a37fd7dc0d2f5328d37
-refs/heads/dist-snap: 1834249e8dff3419f33ee8595a4bf347e50c3c62
+refs/heads/dist-snap: d0d84348efd6e574ac8b7848fbf55916dc9b9fac
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/dist-snap/src/libcore/send_map.rs

@@ -16,14 +16,14 @@ trait SendMap<K:Eq Hash, V: Copy> {
     fn clear(&mut self);
     pure fn len(&const self) -> uint;
     pure fn is_empty(&const self) -> bool;
-    fn contains_key(&const self, k: &K) -> bool;
-    fn each_ref(&self, blk: fn(k: &K, v: &V) -> bool);
-    fn each_key_ref(&self, blk: fn(k: &K) -> bool);
-    fn each_value_ref(&self, blk: fn(v: &V) -> bool);
-    fn find(&const self, k: &K) -> Option<V>;
-    fn get(&const self, k: &K) -> V;
-    fn find_ref(&self, k: &K) -> Option<&self/V>;
-    fn get_ref(&self, k: &K) -> &self/V;
+    pure fn contains_key(&const self, k: &K) -> bool;
+    pure fn each_ref(&self, blk: fn(k: &K, v: &V) -> bool);
+    pure fn each_key_ref(&self, blk: fn(k: &K) -> bool);
+    pure fn each_value_ref(&self, blk: fn(v: &V) -> bool);
+    pure fn find(&const self, k: &K) -> Option<V>;
+    pure fn get(&const self, k: &K) -> V;
+    pure fn find_ref(&self, k: &K) -> Option<&self/V>;
+    pure fn get_ref(&self, k: &K) -> &self/V;
 }
 
 /// Open addressing with linear probing.
@@ -267,15 +267,15 @@ mod linear {
             self.len() == 0
         }
 
-        fn contains_key(&const self,
+        pure fn contains_key(&const self,
                         k: &K) -> bool {
             match self.bucket_for_key(self.buckets, k) {
                 FoundEntry(_) => {true}
                 TableFull | FoundHole(_) => {false}
             }
         }
 
-        fn find_ref(&self, k: &K) -> Option<&self/V> {
+        pure fn find_ref(&self, k: &K) -> Option<&self/V> {
             match self.bucket_for_key(self.buckets, k) {
                 FoundEntry(idx) => {
                     match self.buckets[idx] {
@@ -304,14 +304,14 @@ mod linear {
             }
         }
 
-        fn get_ref(&self, k: &K) -> &self/V {
+        pure fn get_ref(&self, k: &K) -> &self/V {
             match self.find_ref(k) {
                 Some(v) => v,
                 None => fail fmt!("No entry found for key: %?", k),
             }
         }
 
-        fn each_ref(&self, blk: fn(k: &K, v: &V) -> bool) {
+        pure fn each_ref(&self, blk: fn(k: &K, v: &V) -> bool) {
             for vec::each(self.buckets) |slot| {
                 let mut broke = false;
                 do slot.iter |bucket| {
@@ -323,17 +323,17 @@ mod linear {
             }
         }
 
-        fn each_key_ref(&self, blk: fn(k: &K) -> bool) {
+        pure fn each_key_ref(&self, blk: fn(k: &K) -> bool) {
             self.each_ref(|k, _v| blk(k))
         }
 
-        fn each_value_ref(&self, blk: fn(v: &V) -> bool) {
+        pure fn each_value_ref(&self, blk: fn(v: &V) -> bool) {
             self.each_ref(|_k, v| blk(v))
         }
     }
 
     impl<K:Hash IterBytes Eq, V: Copy> LinearMap<K,V> {
-        fn find(&const self, k: &K) -> Option<V> {
+        pure fn find(&const self, k: &K) -> Option<V> {
             match self.bucket_for_key(self.buckets, k) {
                 FoundEntry(idx) => {
                     // FIXME (#3148): Once we rewrite found_entry, this
@@ -349,7 +349,7 @@ mod linear {
             }
         }
 
-        fn get(&const self, k: &K) -> V {
+        pure fn get(&const self, k: &K) -> V {
             let value = self.find(k);
             if value.is_none() {
                 fail fmt!("No entry found for key: %?", k);
@@ -360,17 +360,17 @@ mod linear {
     }
 
     impl<K: Hash IterBytes Eq Copy, V: Copy> LinearMap<K,V> {
-        fn each(&self, blk: fn(+K,+V) -> bool) {
+        pure fn each(&self, blk: fn(+K,+V) -> bool) {
             self.each_ref(|k,v| blk(copy *k, copy *v));
         }
     }
     impl<K: Hash IterBytes Eq Copy, V> LinearMap<K,V> {
-        fn each_key(&self, blk: fn(+K) -> bool) {
+        pure fn each_key(&self, blk: fn(+K) -> bool) {
             self.each_key_ref(|k| blk(copy *k));
         }
     }
     impl<K: Hash IterBytes Eq, V: Copy> LinearMap<K,V> {
-        fn each_value(&self, blk: fn(+V) -> bool) {
+        pure fn each_value(&self, blk: fn(+V) -> bool) {
             self.each_value_ref(|v| blk(copy *v));
         }
     }