---

yaml
---
r: 61283
b: refs/heads/try
c: b9824e1
h: refs/heads/master
i:
  61281: 4062198
  61279: 0478fe4
v: v3

Author: brendanzab

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 2d28d645422c1617be58c8ca7ad9a457264ca850
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 2d28d645422c1617be58c8ca7ad9a457264ca850
-refs/heads/try: be062db808f34983d6039d0a12c0110cba2b730e
+refs/heads/try: b9824e18c2b02d74bd1bf646fea5f05477ca5071
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/libstd/flatpipes.rs

@@ -639,6 +639,7 @@ mod test {
     use core::io::BytesWriter;
 
     #[test]
+    #[ignore(reason = "ebml failure")]
     fn test_serializing_memory_stream() {
         let writer = BytesWriter();
         let chan = serial::writer_chan(writer);
@@ -671,6 +672,7 @@ mod test {
     }
 
     #[test]
+    #[ignore(reason = "ebml failure")]
     fn test_serializing_boxes() {
         let (port, chan) = serial::pipe_stream();
 

branches/try/src/libstd/fun_treemap.rs

@@ -33,45 +33,40 @@ 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) => {
-         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)) }
-       }
-     }
+        @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)) }
+        )
+    }
 }
 
 /// 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) => {
-        if k == *kk {
-            Some(v)
-        } else if k < *kk { find(left, k) } else { find(right, k) }
-      }
+        Empty => None,
+        Node(@ref kk, @copy v, left, right) => cond!(
+            | k == *kk { Some(v)        }
+            | k <  *kk { find(left, k)  }
+            _          { 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);
+        }
     }
 }

branches/try/src/libstd/std.rc

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

branches/try/src/libsyntax/ext/expand.rs

@@ -542,7 +542,41 @@ 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+
+        );
+    )
 }";
 }
 

branches/try/src/test/compile-fail/unsafe-fn-autoderef.rs

@@ -9,11 +9,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct Rec {
-    f: int
-}
-
-fn f(p: *Rec) -> int {
+// xfail-test
+type rec = {f: int};
+fn f(p: *rec) -> int {
 
     // Test that * ptrs do not autoderef.  There is a deeper reason for
     // prohibiting this, beyond making unsafe things annoying (which doesn't
@@ -27,7 +25,7 @@ fn f(p: *Rec) -> int {
     // are prohibited by various checks, such as that the enum is
     // instantiable and so forth).
 
-    return p.f; //~ ERROR attempted access of field `f` on type `*Rec`
+    return p.f; //~ ERROR attempted access of field `f` on type `*rec`
 }
 
 fn main() {

branches/try/src/test/run-pass/cond-macro-no-default.rs

@@ -0,0 +1,23 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn clamp<T:Copy + Ord + Signed>(x: T, mn: T, mx: T) -> T {
+    cond!(
+        | x > mx { return mx; }
+        | x < mn { return mn; }
+    )
+    return x;
+}
+
+fn main() {
+    assert_eq!(clamp(1, 2, 4), 2);
+    assert_eq!(clamp(8, 2, 4), 4);
+    assert_eq!(clamp(3, 2, 4), 3);
+}

branches/try/src/test/run-pass/cond-macro.rs

@@ -0,0 +1,23 @@
+// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn clamp<T:Copy + Ord + Signed>(x: T, mn: T, mx: T) -> T {
+    cond!(
+        | x > mx { mx }
+        | x < mn { mn }
+        _        { x  }
+    )
+}
+
+fn main() {
+    assert_eq!(clamp(1, 2, 4), 2);
+    assert_eq!(clamp(8, 2, 4), 4);
+    assert_eq!(clamp(3, 2, 4), 3);
+}