---

yaml
---
r: 60321
b: refs/heads/master
c: 043d022
h: refs/heads/master
i:
  60319: 71a2d74
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: b9824e18c2b02d74bd1bf646fea5f05477ca5071
+refs/heads/master: 043d02213e19c5a5cffb781e5a11accbe28bf0de
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/try: c50a9d5b664478e533ba1d1d353213d70c8ad589

trunk/src/libcore/vec.rs

@@ -2071,6 +2071,8 @@ pub trait ImmutableVector<'self, T> {
     fn initn(&self, n: uint) -> &'self [T];
     fn last(&self) -> &'self T;
     fn last_opt(&self) -> Option<&'self T>;
+    fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint>;
+    fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint>;
     #[cfg(stage0)]
     fn each_reverse(&self, blk: &fn(&T) -> bool);
     #[cfg(not(stage0))]
@@ -2138,6 +2140,30 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
     #[inline]
     fn last_opt(&self) -> Option<&'self T> { last_opt(*self) }
 
+    /**
+     * Find the first index matching some predicate
+     *
+     * Apply function `f` to each element of `v`.  When function `f` returns
+     * true then an option containing the index is returned. If `f` matches no
+     * elements then none is returned.
+     */
+    #[inline]
+    fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint> {
+        position(*self, f)
+    }
+
+    /**
+     * Find the last index matching some predicate
+     *
+     * Apply function `f` to each element of `v` in reverse order.  When
+     * function `f` returns true then an option containing the index is
+     * returned. If `f` matches no elements then none is returned.
+     */
+    #[inline]
+    fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint> {
+        rposition(*self, f)
+    }
+
     /// Iterates over a vector's elements in reverse.
     #[inline]
     #[cfg(stage0)]
@@ -2230,43 +2256,17 @@ impl<'self,T> ImmutableVector<'self, T> for &'self [T] {
 }
 
 pub trait ImmutableEqVector<T:Eq> {
-    fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint>;
     fn position_elem(&self, t: &T) -> Option<uint>;
-    fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint>;
     fn rposition_elem(&self, t: &T) -> Option<uint>;
 }
 
 impl<'self,T:Eq> ImmutableEqVector<T> for &'self [T] {
-    /**
-     * Find the first index matching some predicate
-     *
-     * Apply function `f` to each element of `v`.  When function `f` returns
-     * true then an option containing the index is returned. If `f` matches no
-     * elements then none is returned.
-     */
-    #[inline]
-    fn position(&self, f: &fn(t: &T) -> bool) -> Option<uint> {
-        position(*self, f)
-    }
-
     /// Find the first index containing a matching value
     #[inline]
     fn position_elem(&self, x: &T) -> Option<uint> {
         position_elem(*self, x)
     }
 
-    /**
-     * Find the last index matching some predicate
-     *
-     * Apply function `f` to each element of `v` in reverse order.  When
-     * function `f` returns true then an option containing the index is
-     * returned. If `f` matches no elements then none is returned.
-     */
-    #[inline]
-    fn rposition(&self, f: &fn(t: &T) -> bool) -> Option<uint> {
-        rposition(*self, f)
-    }
-
     /// Find the last index containing a matching value
     #[inline]
     fn rposition_elem(&self, t: &T) -> Option<uint> {

trunk/src/libstd/fun_treemap.rs

@@ -33,40 +33,45 @@ enum TreeNode<K, V> {
 pub fn init<K, V>() -> Treemap<K, V> { @Empty }
 
 /// Insert a value into the map
-pub fn insert<K:Copy + Eq + Ord,V:Copy>(m: Treemap<K, V>, k: K, v: V) -> Treemap<K, V> {
+pub fn insert<K:Copy + Eq + Ord,V:Copy>(m: Treemap<K, V>, k: K, v: V)
+  -> Treemap<K, V> {
     @match m {
-        @Empty => Node(@k, @v, @Empty, @Empty),
-        @Node(@copy kk, vv, left, right) => cond!(
-            | k <  kk { Node(@kk, vv, insert(left, k, v), right) }
-            | k == kk { Node(@kk, @v, left, right)               }
-            _         { Node(@kk, vv, left, insert(right, k, v)) }
-        )
-    }
+       @Empty => Node(@k, @v, @Empty, @Empty),
+       @Node(@copy kk, vv, left, right) => {
+         if k < kk {
+             Node(@kk, vv, insert(left, k, v), right)
+         } else if k == kk {
+             Node(@kk, @v, left, right)
+         } else { Node(@kk, vv, left, insert(right, k, v)) }
+       }
+     }
 }
 
 /// Find a value based on the key
 pub fn find<K:Eq + Ord,V:Copy>(m: Treemap<K, V>, k: K) -> Option<V> {
     match *m {
-        Empty => None,
-        Node(@ref kk, @copy v, left, right) => cond!(
-            | k == *kk { Some(v)        }
-            | k <  *kk { find(left, k)  }
-            _          { find(right, k) }
-        )
+      Empty => None,
+      Node(@ref kk, @copy v, left, right) => {
+        if k == *kk {
+            Some(v)
+        } else if k < *kk { find(left, k) } else { find(right, k) }
+      }
     }
 }
 
 /// Visit all pairs in the map in order.
 pub fn traverse<K, V: Copy>(m: Treemap<K, V>, f: &fn(&K, &V)) {
     match *m {
-        Empty => (),
-        // Previously, this had what looked like redundant
-        // matches to me, so I changed it. but that may be a
-        // de-optimization -- tjc
-        Node(@ref k, @ref v, left, right) => {
-            traverse(left, f);
-            f(k, v);
-            traverse(right, f);
-        }
+      Empty => (),
+      /*
+        Previously, this had what looked like redundant
+        matches to me, so I changed it. but that may be a
+        de-optimization -- tjc
+       */
+      Node(@ref k, @ref v, left, right) => {
+        traverse(left, f);
+        f(k, v);
+        traverse(right, f);
+      }
     }
 }

trunk/src/libstd/std.rc

@@ -63,7 +63,6 @@ pub mod flatpipes;
 
 pub mod bitv;
 pub mod deque;
-#[cfg(not(stage0))]
 pub mod fun_treemap;
 pub mod list;
 pub mod priority_queue;

trunk/src/libsyntax/ext/expand.rs

@@ -542,41 +542,7 @@ pub fn core_macros() -> ~str {
         }
     )
 
-    //
-    // A scheme-style conditional that helps to improve code clarity in some instances when
-    // the `if`, `else if`, and `else` keywords obscure predicates undesirably.
-    //
-    // # Example
-    //
-    // ~~~
-    // let clamped =
-    //     if x > mx { mx }
-    //     else if x < mn { mn }
-    //     else { x };
-    // ~~~
-    //
-    // Using `cond!`, the above could be written as:
-    //
-    // ~~~
-    // let clamped = cond!(
-    //     | x > mx { mx }
-    //     | x < mn { mn }
-    //     _        { x  }
-    // );
-    // ~~~
-    //
-    // The optional default case is denoted by `_`.
-    //
-    macro_rules! cond (
-        ($( | $pred:expr $body:block)+ _ $default:block ) => (
-            $(if $pred $body else)+
-            $default
-        );
-        // for if the default case was ommitted
-        ( $( | $pred:expr $body:block )+ ) => (
-            $(if $pred $body)else+
-        );
-    )
+
 }";
 }