---

yaml
---
r: 149070
b: refs/heads/try2
c: 06a0c21
h: refs/heads/master
v: v3

Author: pnkfelix

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: 38ed4674e8054ee854871303401bffed7c05b01b
+refs/heads/try2: 06a0c21c91b161781ee1aced0f2a9aed84cb4646
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/Makefile.in

@@ -126,9 +126,9 @@ ifdef TRACE
 endif
 ifdef CFG_DISABLE_RPATH
 # NOTE: make this CFG_RUSTC_FLAGS after stage0 snapshot
-RUSTFLAGS_STAGE1 += -C no-rpath
-RUSTFLAGS_STAGE2 += -C no-rpath
-RUSTFLAGS_STAGE3 += -C no-rpath
+RUSTFLAGS_STAGE1 += --no-rpath
+RUSTFLAGS_STAGE2 += --no-rpath
+RUSTFLAGS_STAGE3 += --no-rpath
 endif
 
 # The executables crated during this compilation process have no need to include

branches/try2/src/libarena/lib.rs

@@ -40,6 +40,7 @@ use std::rc::Rc;
 use std::rt::global_heap;
 use std::unstable::intrinsics::{TyDesc, get_tydesc};
 use std::unstable::intrinsics;
+use std::util;
 use std::vec;
 
 // The way arena uses arrays is really deeply awful. The arrays are
@@ -403,7 +404,7 @@ impl TypedArenaChunk {
         }
 
         // Destroy the next chunk.
-        let next_opt = mem::replace(&mut self.next, None);
+        let next_opt = util::replace(&mut self.next, None);
         match next_opt {
             None => {}
             Some(mut next) => {

branches/try2/src/libcollections/dlist.rs

@@ -23,8 +23,8 @@
 // the reverse direction.
 
 use std::cast;
-use std::mem::{replace, swap};
 use std::ptr;
+use std::util;
 use std::iter::Rev;
 use std::iter;
 
@@ -102,7 +102,7 @@ impl<T> Rawlink<T> {
 
     /// Return the `Rawlink` and replace with `Rawlink::none()`
     fn take(&mut self) -> Rawlink<T> {
-        replace(self, Rawlink::none())
+        util::replace(self, Rawlink::none())
     }
 }
 
@@ -161,7 +161,7 @@ impl<T> DList<T> {
             Some(ref mut head) => {
                 new_head.prev = Rawlink::none();
                 head.prev = Rawlink::some(new_head);
-                swap(head, &mut new_head);
+                util::swap(head, &mut new_head);
                 head.next = Some(new_head);
             }
         }
@@ -319,7 +319,7 @@ impl<T> DList<T> {
     /// O(1)
     #[inline]
     pub fn prepend(&mut self, mut other: DList<T>) {
-        swap(self, &mut other);
+        util::swap(self, &mut other);
         self.append(other);
     }
 

branches/try2/src/libcollections/list.rs

@@ -63,26 +63,6 @@ pub fn find<T:Clone>(ls: @List<T>, f: |&T| -> bool) -> Option<T> {
     };
 }
 
-/**
- * Returns true if a list contains an element that matches a given predicate
- *
- * Apply function `f` to each element of `ls`, starting from the first.
- * When function `f` returns true then it also returns true. If `f` matches no
- * elements then false is returned.
- */
-pub fn any<T>(ls: @List<T>, f: |&T| -> bool) -> bool {
-    let mut ls = ls;
-    loop {
-        ls = match *ls {
-            Cons(ref hd, tl) => {
-                if f(hd) { return true; }
-                tl
-            }
-            Nil => return false
-        }
-    };
-}
-
 /// Returns true if a list contains an element with the given value
 pub fn has<T:Eq>(ls: @List<T>, elt: T) -> bool {
     let mut found = false;
@@ -242,15 +222,6 @@ mod tests {
         assert_eq!(list::find(empty, match_), option::None::<int>);
     }
 
-    #[test]
-    fn test_any() {
-        fn match_(i: &int) -> bool { return *i == 2; }
-        let l = from_vec([0, 1, 2]);
-        let empty = @list::Nil::<int>;
-        assert_eq!(list::any(l, match_), true);
-        assert_eq!(list::any(empty, match_), false);
-    }
-
     #[test]
     fn test_has() {
         let l = from_vec([5, 8, 6]);

branches/try2/src/libcollections/priority_queue.rs

@@ -13,7 +13,8 @@
 #[allow(missing_doc)];
 
 use std::clone::Clone;
-use std::mem::{move_val_init, init, replace, swap};
+use std::mem::{move_val_init, init};
+use std::util::{replace, swap};
 use std::vec;
 
 /// A priority queue implemented with a binary heap

branches/try2/src/libcollections/smallintmap.rs

@@ -16,7 +16,7 @@
 #[allow(missing_doc)];
 
 use std::iter::{Enumerate, FilterMap, Rev};
-use std::mem::replace;
+use std::util::replace;
 use std::vec;
 
 #[allow(missing_doc)]

branches/try2/src/libcollections/treemap.rs

@@ -12,9 +12,9 @@
 //! trees. The only requirement for the types is that the key implements
 //! `TotalOrd`.
 
+use std::util::{swap, replace};
 use std::iter::{Peekable};
 use std::cmp::Ordering;
-use std::mem::{replace, swap};
 use std::ptr;
 
 use serialize::{Encodable, Decodable, Encoder, Decoder};

branches/try2/src/libextra/num/bigint.rs

@@ -2592,8 +2592,7 @@ mod bigint_tests {
 #[cfg(test)]
 mod bench {
     use super::*;
-    use std::iter;
-    use std::mem::replace;
+    use std::{iter, util};
     use std::num::{FromPrimitive, Zero, One};
     use extra::test::BenchHarness;
 
@@ -2610,7 +2609,7 @@ mod bench {
         let mut f1: BigUint = One::one();
         for _ in range(0, n) {
             let f2 = f0 + f1;
-            f0 = replace(&mut f1, f2);
+            f0 = util::replace(&mut f1, f2);
         }
         f0
     }

branches/try2/src/libextra/stats.rs

@@ -13,8 +13,8 @@
 use std::cmp;
 use std::hashmap;
 use std::io;
-use std::mem;
 use std::num;
+use std::util;
 
 // NB: this can probably be rewritten in terms of num::Num
 // to be less f64-specific.
@@ -178,7 +178,7 @@ impl<'a> Stats for &'a [f64] {
             for i in range(0, partials.len()) {
                 let mut y = partials[i];
                 if num::abs(x) < num::abs(y) {
-                    mem::swap(&mut x, &mut y);
+                    util::swap(&mut x, &mut y);
                 }
                 // Rounded `x+y` is stored in `hi` with round-off stored in
                 // `lo`. Together `hi+lo` are exactly equal to `x+y`.