---

yaml
---
r: 44371
b: refs/heads/master
c: 33ae058
h: refs/heads/master
i:
  44369: bf60c8c
  44367: 57126dd
v: v3

Author: z0w0

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 195a969bb3e42e82e647e6ffead557f29884ff41
+refs/heads/master: 33ae05871cc4366897e6461a26265ae0e12ef600
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d9689399d091c3265f00434a69c551a61c28dc
 refs/heads/try: ef355f6332f83371e4acf04fc4eb940ab41d78d3

trunk/src/libcore/prelude.rs

@@ -34,7 +34,6 @@ pub use path::GenericPath;
 pub use path::Path;
 pub use path::PosixPath;
 pub use path::WindowsPath;
-pub use pipes::{GenericChan, GenericPort};
 pub use ptr::Ptr;
 pub use str::{StrSlice, Trimmable, OwnedStr};
 pub use to_bytes::IterBytes;

trunk/src/libcore/private.rs

@@ -14,7 +14,7 @@ use cast;
 use iter;
 use libc;
 use option;
-use pipes;
+use pipes::{GenericChan, GenericPort};
 use prelude::*;
 use ptr;
 use result;

trunk/src/libcore/private/weak_task.rs

@@ -22,7 +22,8 @@ use option::{Some, None, swap_unwrap};
 use private::at_exit::at_exit;
 use private::global::global_data_clone_create;
 use private::finally::Finally;
-use pipes::{Port, Chan, SharedChan, GenericSmartChan, stream};
+use pipes::{Port, Chan, SharedChan, GenericChan, GenericPort,
+            GenericSmartChan, stream};
 use task::{Task, task, spawn};
 use task::rt::{task_id, get_task_id};
 use hashmap::linear::LinearMap;

trunk/src/libcore/run.rs

@@ -14,7 +14,7 @@ use io;
 use io::ReaderUtil;
 use libc;
 use libc::{pid_t, c_void, c_int};
-use pipes::{stream, SharedChan};
+use pipes::{stream, SharedChan, GenericChan, GenericPort};
 use option::{Some, None};
 use os;
 use prelude::*;

trunk/src/libstd/treemap.rs

@@ -576,52 +576,53 @@ pure fn each_reverse<K: Ord, V>(node: &r/Option<~TreeNode<K, V>>,
 }
 
 // Remove left horizontal link by rotating right
-fn skew<K: Ord, V>(node: &mut ~TreeNode<K, V>) {
+fn skew<K: Ord, V>(mut node: ~TreeNode<K, V>) -> ~TreeNode<K, V> {
     if node.left.map_default(false, |x| x.level == node.level) {
         let mut save = node.left.swap_unwrap();
         node.left <-> save.right; // save.right now None
-        *node <-> save;
-        node.right = Some(save);
+        save.right = Some(node);
+        save
+    } else {
+        node // nothing to do
     }
 }
 
 // Remove dual horizontal link by rotating left and increasing level of
 // the parent
-fn split<K: Ord, V>(node: &mut ~TreeNode<K, V>) {
+fn split<K: Ord, V>(mut node: ~TreeNode<K, V>) -> ~TreeNode<K, V> {
     if node.right.map_default(false,
       |x| x.right.map_default(false, |y| y.level == node.level)) {
         let mut save = node.right.swap_unwrap();
         node.right <-> save.left; // save.left now None
+        save.left = Some(node);
         save.level += 1;
-        *node <-> save;
-        node.left = Some(save);
+        save
+    } else {
+        node // nothing to do
     }
 }
 
 fn insert<K: Ord, V>(node: &mut Option<~TreeNode<K, V>>, key: K,
                      value: V) -> bool {
-    match *node {
-      Some(ref mut save) => {
+    if node.is_none() {
+        *node = Some(~TreeNode::new(key, value));
+        true
+    } else {
+        let mut save = node.swap_unwrap();
         if key < save.key {
             let inserted = insert(&mut save.left, key, value);
-            skew(save);
-            split(save);
+            *node = Some(split(skew(save))); // re-balance, if necessary
             inserted
         } else if save.key < key {
             let inserted = insert(&mut save.right, key, value);
-            skew(save);
-            split(save);
+            *node = Some(split(skew(save))); // re-balance, if necessary
             inserted
         } else {
             save.key = key;
             save.value = value;
+            *node = Some(save);
             false
         }
-      }
-      None => {
-       *node = Some(~TreeNode::new(key, value));
-        true
-      }
     }
 }
 
@@ -683,24 +684,15 @@ fn remove<K: Ord, V>(node: &mut Option<~TreeNode<K, V>>, key: &K) -> bool {
                 do save.right.mutate |mut x| { x.level = save.level; x }
             }
 
-            skew(&mut save);
-
-            match save.right {
-              Some(ref mut right) => {
-                skew(right);
-                match right.right {
-                  Some(ref mut x) => { skew(x) },
-                  None => ()
-                }
-              }
-              None => ()
-            }
+            save = skew(save);
 
-            split(&mut save);
-            match save.right {
-              Some(ref mut x) => { split(x) },
-              None => ()
+            do save.right.mutate |mut right| {
+                right = skew(right);
+                right.right.mutate(skew);
+                right
             }
+            save = split(save);
+            save.right.mutate(split);
         }
 
         *node = Some(save);