---

yaml
---
r: 81299
b: refs/heads/snap-stage3
c: f6df7ab
h: refs/heads/master
i:
  81297: 05a29d3
  81295: 53a4c70
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 4c6bf4872012c010f84dc7fa2cdfe87522533f89
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 1f52cf439bec551cd88010fa6d9bcdf681a8b3af
+refs/heads/snap-stage3: f6df7ab839fef099af163463ae99b9541d3d12c5
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/Makefile.in

@@ -88,7 +88,7 @@ ifneq ($(wildcard $(NON_BUILD_TARGET_TRIPLES)),)
 CFG_INFO := $(info cfg: non-build target triples $(NON_BUILD_TARGET_TRIPLES))
 endif
 
-CFG_RUSTC_FLAGS := $(RUSTFLAGS) --cfg nofmt
+CFG_RUSTC_FLAGS := $(RUSTFLAGS)
 CFG_GCCISH_CFLAGS :=
 CFG_GCCISH_LINK_FLAGS :=
 

branches/snap-stage3/doc/rust.md

@@ -683,15 +683,15 @@ mod math {
     type complex = (f64, f64);
     fn sin(f: f64) -> f64 {
         ...
-# fail2!();
+# fail!();
     }
     fn cos(f: f64) -> f64 {
         ...
-# fail2!();
+# fail!();
     }
     fn tan(f: f64) -> f64 {
         ...
-# fail2!();
+# fail!();
     }
 }
 ~~~~~~~~
@@ -817,14 +817,12 @@ An example of `use` declarations:
 use std::num::sin;
 use std::option::{Some, None};
 
-# fn foo<T>(_: T){}
-
 fn main() {
-    // Equivalent to 'std::num::sin(1.0);'
-    sin(1.0);
+    // Equivalent to 'info!(std::num::sin(1.0));'
+    info!(sin(1.0));
 
-    // Equivalent to 'foo(~[std::option::Some(1.0), std::option::None]);'
-    foo(~[Some(1.0), None]);
+    // Equivalent to 'info!(~[std::option::Some(1.0), std::option::None]);'
+    info!(~[Some(1.0), None]);
 }
 ~~~~
 
@@ -1042,8 +1040,8 @@ output slot type would normally be. For example:
 
 ~~~~
 fn my_err(s: &str) -> ! {
-    info2!("{}", s);
-    fail2!();
+    info!(s);
+    fail!();
 }
 ~~~~
 
@@ -1061,7 +1059,7 @@ were declared without the `!` annotation, the following code would not
 typecheck:
 
 ~~~~
-# fn my_err(s: &str) -> ! { fail2!() }
+# fn my_err(s: &str) -> ! { fail!() }
 
 fn f(i: int) -> int {
    if i == 42 {
@@ -2384,7 +2382,7 @@ fn ten_times(f: &fn(int)) {
     }
 }
 
-ten_times(|j| println!("hello, {}", j));
+ten_times(|j| println(fmt!("hello, %d", j)));
 
 ~~~~
 
@@ -2596,9 +2594,9 @@ enum List<X> { Nil, Cons(X, @List<X>) }
 let x: List<int> = Cons(10, @Cons(11, @Nil));
 
 match x {
-    Cons(_, @Nil) => fail2!("singleton list"),
+    Cons(_, @Nil) => fail!("singleton list"),
     Cons(*)       => return,
-    Nil           => fail2!("empty list")
+    Nil           => fail!("empty list")
 }
 ~~~~
 
@@ -2635,7 +2633,7 @@ match x {
         return;
     }
     _ => {
-        fail2!();
+        fail!();
     }
 }
 ~~~~
@@ -2689,7 +2687,7 @@ guard may refer to the variables bound within the pattern they follow.
 let message = match maybe_digit {
   Some(x) if x < 10 => process_digit(x),
   Some(x) => process_other(x),
-  None => fail2!()
+  None => fail!()
 };
 ~~~~
 
@@ -3474,20 +3472,20 @@ that demonstrates all four of them:
 
 ```rust
 fn main() {
-    error2!("This is an error log")
-    warn2!("This is a warn log")
-    info2!("this is an info log")
-    debug2!("This is a debug log")
+    error!("This is an error log")
+    warn!("This is a warn log")
+    info!("this is an info log")
+    debug!("This is a debug log")
 }
 ```
 
 These four log levels correspond to levels 1-4, as controlled by `RUST_LOG`:
 
 ```bash
 $ RUST_LOG=rust=3 ./rust
-This is an error log
-This is a warn log
-this is an info log
+rust: ~"\"This is an error log\""
+rust: ~"\"This is a warn log\""
+rust: ~"\"this is an info log\""
 ```
 
 # Appendix: Rationales and design tradeoffs

branches/snap-stage3/doc/tutorial-conditions.md

@@ -66,7 +66,7 @@ use std::int;
 fn main() {
     let pairs = read_int_pairs();
     for &(a,b) in pairs.iter() {
-        println!("{:4.4d}, {:4.4d}", a, b);
+        println(fmt!("%4.4d, %4.4d", a, b));
     }
 }
 
@@ -281,7 +281,7 @@ fn main() {
         // The protected logic.
         let pairs = read_int_pairs();
         for &(a,b) in pairs.iter() {
-            println!("{:4.4d}, {:4.4d}", a, b);
+            println(fmt!("%4.4d, %4.4d", a, b));
         }
 
     };
@@ -387,7 +387,7 @@ condition! {
 fn main() {
     let pairs = read_int_pairs();
     for &(a,b) in pairs.iter() {
-        println!("{:4.4d}, {:4.4d}", a, b);
+        println(fmt!("%4.4d, %4.4d", a, b));
     }
 }
 
@@ -462,7 +462,7 @@ fn main() {
         // The protected logic.
         let pairs = read_int_pairs();
         for &(a,b) in pairs.iter() {
-                println!("{:4.4d}, {:4.4d}", a, b);
+                println(fmt!("%4.4d, %4.4d", a, b));
         }
 
     }
@@ -540,7 +540,7 @@ fn main() {
         // The protected logic.
         let pairs = read_int_pairs();
         for &(a,b) in pairs.iter() {
-            println!("{:4.4d}, {:4.4d}", a, b);
+            println(fmt!("%4.4d, %4.4d", a, b));
         }
 
     }
@@ -636,7 +636,7 @@ fn main() {
         // The protected logic.
         let pairs = read_int_pairs();
         for &(a,b) in pairs.iter() {
-            println!("{:4.4d}, {:4.4d}", a, b);
+            println(fmt!("%4.4d, %4.4d", a, b));
         }
 
     }
@@ -766,7 +766,7 @@ fn main() {
             // The protected logic.
             let pairs = read_int_pairs();
             for &(a,b) in pairs.iter() {
-                println!("{:4.4d}, {:4.4d}", a, b);
+                println(fmt!("%4.4d, %4.4d", a, b));
             }
 
         }

branches/snap-stage3/doc/tutorial-macros.md

@@ -226,7 +226,7 @@ match x {
                 // complicated stuff goes here
                 return result + val;
             },
-            _ => fail2!("Didn't get good_2")
+            _ => fail!("Didn't get good_2")
         }
     }
     _ => return 0 // default value
@@ -268,7 +268,7 @@ macro_rules! biased_match (
 biased_match!((x)       ~ (good_1(g1, val)) else { return 0 };
               binds g1, val )
 biased_match!((g1.body) ~ (good_2(result) )
-                  else { fail2!("Didn't get good_2") };
+                  else { fail!("Didn't get good_2") };
               binds result )
 // complicated stuff goes here
 return result + val;
@@ -369,7 +369,7 @@ macro_rules! biased_match (
 # fn f(x: t1) -> uint {
 biased_match!(
     (x)       ~ (good_1(g1, val)) else { return 0 };
-    (g1.body) ~ (good_2(result) ) else { fail2!("Didn't get good_2") };
+    (g1.body) ~ (good_2(result) ) else { fail!("Didn't get good_2") };
     binds val, result )
 // complicated stuff goes here
 return result + val;

branches/snap-stage3/doc/tutorial-tasks.md

@@ -99,14 +99,15 @@ execution. Like any closure, the function passed to `spawn` may capture
 an environment that it carries across tasks.
 
 ~~~
+# use std::io::println;
 # use std::task::spawn;
 # fn generate_task_number() -> int { 0 }
 // Generate some state locally
 let child_task_number = generate_task_number();
 
 do spawn {
    // Capture it in the remote task
-   println!("I am child number {}", child_task_number);
+   println(fmt!("I am child number %d", child_task_number));
 }
 ~~~
 
@@ -281,7 +282,7 @@ fn fib(n: uint) -> uint {
 
 let mut delayed_fib = extra::future::Future::spawn (|| fib(50) );
 make_a_sandwich();
-println!("fib(50) = {:?}", delayed_fib.get())
+println(fmt!("fib(50) = %?", delayed_fib.get()))
 ~~~
 
 The call to `future::spawn` returns immediately a `future` object regardless of how long it
@@ -309,7 +310,7 @@ fn main() {
     for ft in futures.mut_iter()  {
         final_res += ft.get();
     }
-    println!("π^2/6 is not far from : {}", final_res);
+    println(fmt!("π^2/6 is not far from : %?", final_res));
 }
 ~~~
 
@@ -337,7 +338,7 @@ fn pnorm(nums: &~[float], p: uint) -> float {
 
 fn main() {
     let numbers = vec::from_fn(1000000, |_| rand::random::<float>());
-    println!("Inf-norm = {}",  *numbers.iter().max().unwrap());
+    println(fmt!("Inf-norm = %?",  *numbers.iter().max().unwrap()));
 
     let numbers_arc = Arc::new(numbers);
 
@@ -348,7 +349,7 @@ fn main() {
         do spawn {
             let local_arc : Arc<~[float]> = port.recv();
             let task_numbers = local_arc.get();
-            println!("{}-norm = {}", num, pnorm(task_numbers, num));
+            println(fmt!("%u-norm = %?", num, pnorm(task_numbers, num)));
         }
     }
 }