---

yaml
---
r: 40526
b: refs/heads/dist-snap
c: 5c0206a
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
 refs/heads/incoming: e90142e536c150df0d9b4b2f11352152177509b5
-refs/heads/dist-snap: ff4075e553ccc5be73c05332f15ef46f761b0817
+refs/heads/dist-snap: 5c0206a1e4e5049a4a5d35ea6fee10cbd3f45aa0
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libstd/map.rs

@@ -35,16 +35,16 @@ pub trait Map<K:Eq IterBytes Hash Copy, V: Copy> {
      * If the map contains a value for the key, use the function
      * to set a new value.
      */
-    fn insert_with_key(key: K, newval: V, ff: fn(K, V, V) -> V) -> bool;
+    fn update_with_key(key: K, newval: V, ff: fn(K, V, V) -> V) -> bool;
 
     /**
      * Add a value to the map.
      *
-     * If the map contains a value for the key, use the function
-     * to set a new value.  (Like insert_with_key, but with a function
-     * of only values.)
+     * If the map contains a value for the key, use the function to
+     * set a new value.  (Like `insert_or_update_with_key`, but with a
+     * function of only values.)
      */
-    fn insert_with(key: K, newval: V, ff: fn(V, V) -> V) -> bool;
+    fn update(key: K, newval: V, ff: fn(V, V) -> V) -> bool;
 
     /// Returns true if the map contains a value for the specified key
     pure fn contains_key(key: K) -> bool;
@@ -281,7 +281,7 @@ pub mod chained {
             }
         }
 
-        fn insert_with_key(key: K, newval: V, ff: fn(K, V, V) -> V) -> bool {
+        fn update_with_key(key: K, newval: V, ff: fn(K, V, V) -> V) -> bool {
 /*
             match self.find(key) {
                 None            => return self.insert(key, val),
@@ -330,8 +330,8 @@ pub mod chained {
             }
         }
 
-        fn insert_with(key: K, newval: V, ff: fn(V, V) -> V) -> bool {
-            return self.insert_with_key(key, newval, |_k, v, v1| ff(v,v1));
+        fn update(key: K, newval: V, ff: fn(V, V) -> V) -> bool {
+            return self.update_with_key(key, newval, |_k, v, v1| ff(v,v1));
         }
 
         pure fn get(k: K) -> V {
@@ -517,15 +517,15 @@ impl<K: Eq IterBytes Hash Copy, V: Copy> @Mut<LinearMap<K, V>>:
         }
     }
 
-    fn insert_with_key(key: K, newval: V, ff: fn(K, V, V) -> V) -> bool {
+    fn update_with_key(key: K, newval: V, ff: fn(K, V, V) -> V) -> bool {
         match self.find(key) {
             None            => return self.insert(key, newval),
             Some(copy orig) => return self.insert(key, ff(key, orig, newval))
         }
     }
 
-    fn insert_with(key: K, newval: V, ff: fn(V, V) -> V) -> bool {
-        return self.insert_with_key(key, newval, |_k, v, v1| ff(v,v1));
+    fn update(key: K, newval: V, ff: fn(V, V) -> V) -> bool {
+        return self.update_with_key(key, newval, |_k, v, v1| ff(v,v1));
     }
 
     fn remove(key: K) -> bool {
@@ -833,7 +833,7 @@ mod tests {
     }
 
     #[test]
-    fn test_insert_with_key() {
+    fn test_update_with_key() {
         let map = map::HashMap::<~str, uint>();
 
         // given a new key, initialize it with this new count, given
@@ -848,11 +848,11 @@ mod tests {
 
         // count the number of several types of animal,
         // adding in groups as we go
-        map.insert_with(~"cat",      1, addMoreToCount_simple);
-        map.insert_with_key(~"mongoose", 1, addMoreToCount);
-        map.insert_with(~"cat",      7, addMoreToCount_simple);
-        map.insert_with_key(~"ferret",   3, addMoreToCount);
-        map.insert_with_key(~"cat",      2, addMoreToCount);
+        map.update(~"cat",      1, addMoreToCount_simple);
+        map.update_with_key(~"mongoose", 1, addMoreToCount);
+        map.update(~"cat",      7, addMoreToCount_simple);
+        map.update_with_key(~"ferret",   3, addMoreToCount);
+        map.update_with_key(~"cat",      2, addMoreToCount);
 
         // check the total counts
         assert 10 == option::get(map.find(~"cat"));

branches/dist-snap/src/libstd/smallintmap.rs

@@ -103,15 +103,15 @@ impl<V: Copy> SmallIntMap<V>: map::Map<uint, V> {
     pure fn find(key: uint) -> Option<V> { find(self, key) }
     fn rehash() { fail }
 
-    fn insert_with_key(key: uint, val: V, ff: fn(uint, V, V) -> V) -> bool {
+    fn update_with_key(key: uint, val: V, ff: fn(uint, V, V) -> V) -> bool {
         match self.find(key) {
             None            => return self.insert(key, val),
             Some(copy orig) => return self.insert(key, ff(key, orig, val)),
         }
     }
 
-    fn insert_with(key: uint, newval: V, ff: fn(V, V) -> V) -> bool {
-        return self.insert_with_key(key, newval, |_k, v, v1| ff(v,v1));
+    fn update(key: uint, newval: V, ff: fn(V, V) -> V) -> bool {
+        return self.update_with_key(key, newval, |_k, v, v1| ff(v,v1));
     }
 
     pure fn each(it: fn(key: uint, value: V) -> bool) {
@@ -172,11 +172,11 @@ mod tests {
         }
 
         // count integers
-        map.insert_with(3, 1, addMoreToCount_simple);
-        map.insert_with_key(9, 1, addMoreToCount);
-        map.insert_with(3, 7, addMoreToCount_simple);
-        map.insert_with_key(5, 3, addMoreToCount);
-        map.insert_with_key(3, 2, addMoreToCount);
+        map.update(3, 1, addMoreToCount_simple);
+        map.update_with_key(9, 1, addMoreToCount);
+        map.update(3, 7, addMoreToCount_simple);
+        map.update_with_key(5, 3, addMoreToCount);
+        map.update_with_key(3, 2, addMoreToCount);
 
         // check the total counts
         assert 10 == option::get(map.find(3));