---

yaml
---
r: 82047
b: refs/heads/master
c: f6df7ab
h: refs/heads/master
i:
  82045: 7da9315
  82043: c1cbcb4
  82039: 43e2cd5
  82031: 7f5c862
  82015: de6181b
  81983: a224f2f
  81919: 274cca6
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1f52cf439bec551cd88010fa6d9bcdf681a8b3af
+refs/heads/master: f6df7ab839fef099af163463ae99b9541d3d12c5
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6c08cc2db4f98e9f07ae7d50338396c4123c2f0a
 refs/heads/try: 70152ff55722878cde684ee6462c14c65f2c4729

trunk/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 :=
 

trunk/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

trunk/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));
             }
 
         }

trunk/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;

trunk/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)));
         }
     }
 }

trunk/doc/tutorial.md

@@ -225,7 +225,7 @@ let hi = "hi";
 let mut count = 0;
 
 while count < 10 {
-    println!("count: {}", count);
+    println(fmt!("count: %?", count));
     count += 1;
 }
 ~~~~
@@ -388,26 +388,23 @@ assert!(y == 4u);
 but are instead provided by the libraries. To make it clear to the reader when
 a name refers to a syntax extension, the names of all syntax extensions end
 with `!`. The standard library defines a few syntax extensions, the most
-useful of which is [`format!`][fmt], a `sprintf`-like text formatter that you
-will often see in examples, and its related family of macros: `print!`,
-`println!`, and `write!`.
+useful of which is `fmt!`, a `sprintf`-style text formatter that you will
+often see in examples.
 
-`format!` draws syntax from python, but contains many of the same principles
-that [printf][pf] has. Unlike printf, `format!` will give you a compile-time
-error when the types of the directives don't match the types of the arguments.
+`fmt!` supports most of the directives that [printf][pf] supports, but unlike
+printf, will give you a compile-time error when the types of the directives
+don't match the types of the arguments.
 
 ~~~~
 # let mystery_object = ();
 
-// {} will print the "default format" of a type
-println!("{} is {}", "the answer", 43);
+println(fmt!("%s is %d", "the answer", 43));
 
-// {:?} will conveniently print any type
-println!("what is this thing: {:?}", mystery_object);
+// %? will conveniently print any type
+println(fmt!("what is this thing: %?", mystery_object));
 ~~~~
 
 [pf]: http://en.cppreference.com/w/cpp/io/c/fprintf
-[fmt]: http://static.rust-lang.org/doc/master/std/fmt/index.html
 
 You can define your own syntax extensions with the macro system. For details, see the [macro tutorial][macros].
 
@@ -740,7 +737,7 @@ fn area(sh: Shape) -> float {
     match sh {
         Circle { radius: radius, _ } => float::consts::pi * square(radius),
         Rectangle { top_left: top_left, bottom_right: bottom_right } => {
-            (bottom_right.x - top_left.x) * (top_left.y - bottom_right.y)
+            (bottom_right.x - top_left.x) * (top_left.y - bottom_right.y) 
         }
     }
 }
@@ -756,7 +753,7 @@ unit, `()`, as the empty tuple if you like).
 ~~~~
 let mytup: (int, int, float) = (10, 20, 30.0);
 match mytup {
-  (a, b, c) => info2!("{}", a + b + (c as int))
+  (a, b, c) => info!(a + b + (c as int))
 }
 ~~~~
 
@@ -772,7 +769,7 @@ For example:
 struct MyTup(int, int, float);
 let mytup: MyTup = MyTup(10, 20, 30.0);
 match mytup {
-  MyTup(a, b, c) => info2!("{}", a + b + (c as int))
+  MyTup(a, b, c) => info!(a + b + (c as int))
 }
 ~~~~
 
@@ -1241,7 +1238,7 @@ something silly like
 ~~~
 # struct Point { x: float, y: float }
 let point = &@~Point { x: 10f, y: 20f };
-println!("{:f}", point.x);
+println(fmt!("%f", point.x));
 ~~~
 
 The indexing operator (`[]`) also auto-dereferences.
@@ -1446,7 +1443,7 @@ the enclosing scope.
 fn call_closure_with_ten(b: &fn(int)) { b(10); }
 
 let captured_var = 20;
-let closure = |arg| println!("captured_var={}, arg={}", captured_var, arg);
+let closure = |arg| println(fmt!("captured_var=%d, arg=%d", captured_var, arg));
 
 call_closure_with_ten(closure);
 ~~~~
@@ -1569,7 +1566,7 @@ arguments.
 use std::task::spawn;
 
 do spawn() || {
-    debug2!("I'm a task, whatever");
+    debug!("I'm a task, whatever");
 }
 ~~~~
 
@@ -1581,7 +1578,7 @@ may be omitted from `do` expressions.
 use std::task::spawn;
 
 do spawn {
-   debug2!("Kablam!");
+   debug!("Kablam!");
 }
 ~~~~
 
@@ -1919,7 +1916,7 @@ and `~str`.
 ~~~~
 # trait Printable { fn print(&self); }
 impl Printable for int {
-    fn print(&self) { println!("{}", *self) }
+    fn print(&self) { println(fmt!("%d", *self)) }
 }
 
 impl Printable for ~str {