`m1!{...}` -> `m1!(...)`

17 files changed, 367 insertions, 367 deletions

diff --git a/src/libstd/deque.rs b/src/libstd/deque.rs
index 7b8c0e9fcad..2e280747d20 100644
--- a/src/libstd/deque.rs
+++ b/src/libstd/deque.rs
@@ -274,37 +274,37 @@ mod tests {
         fn reccyeq(a: reccy, b: reccy) -> bool {
             return a.x == b.x && a.y == b.y && taggyeq(a.t, b.t);
         }
-        debug!{"*** test boxes"};
+        debug!("*** test boxes");
         test_boxes(@5, @72, @64, @175);
-        debug!{"*** end test boxes"};
-        debug!{"test parameterized: int"};
+        debug!("*** end test boxes");
+        debug!("test parameterized: int");
         let eq1: eqfn<int> = inteq;
         test_parameterized::<int>(eq1, 5, 72, 64, 175);
-        debug!{"*** test parameterized: @int"};
+        debug!("*** test parameterized: @int");
         let eq2: eqfn<@int> = intboxeq;
         test_parameterized::<@int>(eq2, @5, @72, @64, @175);
-        debug!{"*** end test parameterized @int"};
-        debug!{"test parameterized: taggy"};
+        debug!("*** end test parameterized @int");
+        debug!("test parameterized: taggy");
         let eq3: eqfn<taggy> = taggyeq;
         test_parameterized::<taggy>(eq3, one(1), two(1, 2), three(1, 2, 3),
                                     two(17, 42));
 
-        debug!{"*** test parameterized: taggypar<int>"};
+        debug!("*** test parameterized: taggypar<int>");
         let eq4: eqfn<taggypar<int>> = |x,y| taggypareq::<int>(x, y);
         test_parameterized::<taggypar<int>>(eq4, onepar::<int>(1),
                                             twopar::<int>(1, 2),
                                             threepar::<int>(1, 2, 3),
                                             twopar::<int>(17, 42));
-        debug!{"*** end test parameterized: taggypar::<int>"};
+        debug!("*** end test parameterized: taggypar::<int>");
 
-        debug!{"*** test parameterized: reccy"};
+        debug!("*** test parameterized: reccy");
         let reccy1: reccy = {x: 1, y: 2, t: one(1)};
         let reccy2: reccy = {x: 345, y: 2, t: two(1, 2)};
         let reccy3: reccy = {x: 1, y: 777, t: three(1, 2, 3)};
         let reccy4: reccy = {x: 19, y: 252, t: two(17, 42)};
         let eq5: eqfn<reccy> = reccyeq;
         test_parameterized::<reccy>(eq5, reccy1, reccy2, reccy3, reccy4);
-        debug!{"*** end test parameterized: reccy"};
-        debug!{"*** done"};
+        debug!("*** end test parameterized: reccy");
+        debug!("*** done");
     }
 }
diff --git a/src/libstd/ebml.rs b/src/libstd/ebml.rs
index 260a746bf85..758dcf4eebf 100644
--- a/src/libstd/ebml.rs
+++ b/src/libstd/ebml.rs
@@ -70,7 +70,7 @@ fn vuint_at(data: &[u8], start: uint) -> {val: uint, next: uint} {
                  (data[start + 2u] as uint) << 8u |
                  (data[start + 3u] as uint),
              next: start + 4u};
-    } else { error!{"vint too big"}; fail; }
+    } else { error!("vint too big"); fail; }
 }
 
 fn doc(data: @~[u8]) -> doc {
@@ -106,7 +106,7 @@ fn get_doc(d: doc, tg: uint) -> doc {
     match maybe_get_doc(d, tg) {
       some(d) => return d,
       none => {
-        error!{"failed to find block with tag %u", tg};
+        error!("failed to find block with tag %u", tg);
         fail;
       }
     }
@@ -186,7 +186,7 @@ fn write_sized_vuint(w: io::Writer, n: uint, size: uint) {
                       n as u8]),
       4u => w.write(&[0x10u8 | ((n >> 24_u) as u8), (n >> 16_u) as u8,
                       (n >> 8_u) as u8, n as u8]),
-      _ => fail fmt!{"vint to write too big: %?", n}
+      _ => fail fmt!("vint to write too big: %?", n)
     };
 }
 
@@ -195,7 +195,7 @@ fn write_vuint(w: io::Writer, n: uint) {
     if n < 0x4000_u { write_sized_vuint(w, n, 2u); return; }
     if n < 0x200000_u { write_sized_vuint(w, n, 3u); return; }
     if n < 0x10000000_u { write_sized_vuint(w, n, 4u); return; }
-    fail fmt!{"vint to write too big: %?", n};
+    fail fmt!("vint to write too big: %?", n);
 }
 
 fn writer(w: io::Writer) -> writer {
@@ -206,7 +206,7 @@ fn writer(w: io::Writer) -> writer {
 // FIXME (#2741): Provide a function to write the standard ebml header.
 impl writer {
     fn start_tag(tag_id: uint) {
-        debug!{"Start tag %u", tag_id};
+        debug!("Start tag %u", tag_id);
 
         // Write the enum ID:
         write_vuint(self.writer, tag_id);
@@ -225,7 +225,7 @@ impl writer {
         write_sized_vuint(self.writer, size, 4u);
         self.writer.seek(cur_pos as int, io::SeekSet);
 
-        debug!{"End tag (size = %u)", size};
+        debug!("End tag (size = %u)", size);
     }
 
     fn wr_tag(tag_id: uint, blk: fn()) {
@@ -289,12 +289,12 @@ impl writer {
     }
 
     fn wr_bytes(b: &[u8]) {
-        debug!{"Write %u bytes", vec::len(b)};
+        debug!("Write %u bytes", vec::len(b));
         self.writer.write(b);
     }
 
     fn wr_str(s: ~str) {
-        debug!{"Write str: %?", s};
+        debug!("Write str: %?", s);
         self.writer.write(str::bytes(s));
     }
 }
@@ -417,29 +417,29 @@ priv impl ebml_deserializer {
                 self.pos = r_doc.end;
                 let str = ebml::doc_as_str(r_doc);
                 if lbl != str {
-                    fail fmt!{"Expected label %s but found %s", lbl, str};
+                    fail fmt!("Expected label %s but found %s", lbl, str);
                 }
             }
         }
     }
 
     fn next_doc(exp_tag: ebml_serializer_tag) -> ebml::doc {
-        debug!{". next_doc(exp_tag=%?)", exp_tag};
+        debug!(". next_doc(exp_tag=%?)", exp_tag);
         if self.pos >= self.parent.end {
             fail ~"no more documents in current node!";
         }
         let {tag: r_tag, doc: r_doc} =
             ebml::doc_at(self.parent.data, self.pos);
-        debug!{"self.parent=%?-%? self.pos=%? r_tag=%? r_doc=%?-%?",
+        debug!("self.parent=%?-%? self.pos=%? r_tag=%? r_doc=%?-%?",
                copy self.parent.start, copy self.parent.end,
-               copy self.pos, r_tag, r_doc.start, r_doc.end};
+               copy self.pos, r_tag, r_doc.start, r_doc.end);
         if r_tag != (exp_tag as uint) {
-            fail fmt!{"expected EMBL doc with tag %? but found tag %?",
-                      exp_tag, r_tag};
+            fail fmt!("expected EMBL doc with tag %? but found tag %?",
+                      exp_tag, r_tag);
         }
         if r_doc.end > self.parent.end {
-            fail fmt!{"invalid EBML, child extends to 0x%x, parent to 0x%x",
-                      r_doc.end, self.parent.end};
+            fail fmt!("invalid EBML, child extends to 0x%x, parent to 0x%x",
+                      r_doc.end, self.parent.end);
         }
         self.pos = r_doc.end;
         return r_doc;
@@ -458,7 +458,7 @@ priv impl ebml_deserializer {
 
     fn _next_uint(exp_tag: ebml_serializer_tag) -> uint {
         let r = ebml::doc_as_u32(self.next_doc(exp_tag));
-        debug!{"_next_uint exp_tag=%? result=%?", exp_tag, r};
+        debug!("_next_uint exp_tag=%? result=%?", exp_tag, r);
         return r as uint;
     }
 }
@@ -473,7 +473,7 @@ impl ebml_deserializer: serialization::deserializer {
     fn read_uint() -> uint {
         let v = ebml::doc_as_u64(self.next_doc(es_uint));
         if v > (core::uint::max_value as u64) {
-            fail fmt!{"uint %? too large for this architecture", v};
+            fail fmt!("uint %? too large for this architecture", v);
         }
         return v as uint;
     }
@@ -485,7 +485,7 @@ impl ebml_deserializer: serialization::deserializer {
     fn read_int() -> int {
         let v = ebml::doc_as_u64(self.next_doc(es_int)) as i64;
         if v > (int::max_value as i64) || v < (int::min_value as i64) {
-            fail fmt!{"int %? out of range for this architecture", v};
+            fail fmt!("int %? out of range for this architecture", v);
         }
         return v as int;
     }
@@ -500,67 +500,67 @@ impl ebml_deserializer: serialization::deserializer {
 
     // Compound types:
     fn read_enum<T>(name: ~str, f: fn() -> T) -> T {
-        debug!{"read_enum(%s)", name};
+        debug!("read_enum(%s)", name);
         self._check_label(name);
         self.push_doc(self.next_doc(es_enum), f)
     }
 
     fn read_enum_variant<T>(f: fn(uint) -> T) -> T {
-        debug!{"read_enum_variant()"};
+        debug!("read_enum_variant()");
         let idx = self._next_uint(es_enum_vid);
-        debug!{"  idx=%u", idx};
+        debug!("  idx=%u", idx);
         do self.push_doc(self.next_doc(es_enum_body)) {
             f(idx)
         }
     }
 
     fn read_enum_variant_arg<T>(idx: uint, f: fn() -> T) -> T {
-        debug!{"read_enum_variant_arg(idx=%u)", idx};
+        debug!("read_enum_variant_arg(idx=%u)", idx);
         f()
     }
 
     fn read_vec<T>(f: fn(uint) -> T) -> T {
-        debug!{"read_vec()"};
+        debug!("read_vec()");
         do self.push_doc(self.next_doc(es_vec)) {
             let len = self._next_uint(es_vec_len);
-            debug!{"  len=%u", len};
+            debug!("  len=%u", len);
             f(len)
         }
     }
 
     fn read_vec_elt<T>(idx: uint, f: fn() -> T) -> T {
-        debug!{"read_vec_elt(idx=%u)", idx};
+        debug!("read_vec_elt(idx=%u)", idx);
         self.push_doc(self.next_doc(es_vec_elt), f)
     }
 
     fn read_box<T>(f: fn() -> T) -> T {
-        debug!{"read_box()"};
+        debug!("read_box()");
         f()
     }
 
     fn read_uniq<T>(f: fn() -> T) -> T {
-        debug!{"read_uniq()"};
+        debug!("read_uniq()");
         f()
     }
 
     fn read_rec<T>(f: fn() -> T) -> T {
-        debug!{"read_rec()"};
+        debug!("read_rec()");
         f()
     }
 
     fn read_rec_field<T>(f_name: ~str, f_idx: uint, f: fn() -> T) -> T {
-        debug!{"read_rec_field(%s, idx=%u)", f_name, f_idx};
+        debug!("read_rec_field(%s, idx=%u)", f_name, f_idx);
         self._check_label(f_name);
         f()
     }
 
     fn read_tup<T>(sz: uint, f: fn() -> T) -> T {
-        debug!{"read_tup(sz=%u)", sz};
+        debug!("read_tup(sz=%u)", sz);
         f()
     }
 
     fn read_tup_elt<T>(idx: uint, f: fn() -> T) -> T {
-        debug!{"read_tup_elt(idx=%u)", idx};
+        debug!("read_tup_elt(idx=%u)", idx);
         f()
     }
 }
@@ -613,14 +613,14 @@ fn test_option_int() {
     }
 
     fn test_v(v: option<int>) {
-        debug!{"v == %?", v};
+        debug!("v == %?", v);
         let mbuf = io::mem_buffer();
         let ebml_w = ebml::writer(io::mem_buffer_writer(mbuf));
         serialize_0(ebml_w, v);
         let ebml_doc = ebml::doc(@io::mem_buffer_buf(mbuf));
         let deser = ebml_deserializer(ebml_doc);
         let v1 = deserialize_0(deser);
-        debug!{"v1 == %?", v1};
+        debug!("v1 == %?", v1);
         assert v == v1;
     }
 
diff --git a/src/libstd/getopts.rs b/src/libstd/getopts.rs
index 1c92fd4ce0d..f14d2e32263 100644
--- a/src/libstd/getopts.rs
+++ b/src/libstd/getopts.rs
@@ -314,7 +314,7 @@ fn opt_vals(m: matches, nm: ~str) -> ~[optval] {
     return match find_opt(m.opts, mkname(nm)) {
       some(id) => m.vals[id],
       none => {
-        error!{"No option '%s' defined", nm};
+        error!("No option '%s' defined", nm);
         fail
       }
     };
diff --git a/src/libstd/json.rs b/src/libstd/json.rs
index 715062a06c9..5523de29aeb 100644
--- a/src/libstd/json.rs
+++ b/src/libstd/json.rs
@@ -628,7 +628,7 @@ impl json: to_str::ToStr {
 
 impl error: to_str::ToStr {
     fn to_str() -> ~str {
-        fmt!{"%u:%u: %s", self.line, self.col, *self.msg}
+        fmt!("%u:%u: %s", self.line, self.col, *self.msg)
     }
 }
 
diff --git a/src/libstd/map.rs b/src/libstd/map.rs
index 3056b6b938a..7ed64c947a2 100644
--- a/src/libstd/map.rs
+++ b/src/libstd/map.rs
@@ -137,16 +137,16 @@ mod chained {
             loop {
                 match copy e0.next {
                   none => {
-                    debug!{"search_tbl: absent, comp %u, hash %u, idx %u",
-                           comp, h, idx};
+                    debug!("search_tbl: absent, comp %u, hash %u, idx %u",
+                           comp, h, idx);
                     return not_found;
                   }
                   some(e1) => {
                     comp += 1u;
                     if e1.hash == h && self.eqer(&e1.key, k) {
-                        debug!{"search_tbl: present, comp %u, \
+                        debug!("search_tbl: present, comp %u, \
                                 hash %u, idx %u",
-                               comp, h, idx};
+                               comp, h, idx);
                         return found_after(e0, e1);
                     } else {
                         e0 = e1;
@@ -160,14 +160,14 @@ mod chained {
             let idx = h % vec::len(self.chains);
             match copy self.chains[idx] {
               none => {
-                debug!{"search_tbl: none, comp %u, hash %u, idx %u",
-                       0u, h, idx};
+                debug!("search_tbl: none, comp %u, hash %u, idx %u",
+                       0u, h, idx);
                 return not_found;
               }
               some(e) => {
                 if e.hash == h && self.eqer(&e.key, k) {
-                    debug!{"search_tbl: present, comp %u, hash %u, idx %u",
-                           1u, h, idx};
+                    debug!("search_tbl: present, comp %u, hash %u, idx %u",
+                           1u, h, idx);
                     return found_first(idx, e);
                 } else {
                     return self.search_rem(k, h, idx, e);
@@ -277,7 +277,7 @@ mod chained {
         fn get(+k: K) -> V {
             let opt_v = self.find(k);
             if opt_v.is_none() {
-                fail fmt!{"Key not found in table: %?", k};
+                fail fmt!("Key not found in table: %?", k);
             }
             option::unwrap(opt_v)
         }
@@ -563,14 +563,14 @@ mod tests {
 
     #[test]
     fn test_simple() {
-        debug!{"*** starting test_simple"};
+        debug!("*** starting test_simple");
         pure fn eq_uint(x: &uint, y: &uint) -> bool { *x == *y }
         pure fn uint_id(x: &uint) -> uint { *x }
         let hasher_uint: map::hashfn<uint> = uint_id;
         let eqer_uint: map::eqfn<uint> = eq_uint;
         let hasher_str: map::hashfn<~str> = str::hash;
         let eqer_str: map::eqfn<~str> = str::eq;
-        debug!{"uint -> uint"};
+        debug!("uint -> uint");
         let hm_uu: map::hashmap<uint, uint> =
             map::hashmap::<uint, uint>(copy hasher_uint, copy eqer_uint);
         assert (hm_uu.insert(10u, 12u));
@@ -586,7 +586,7 @@ mod tests {
         let ten: ~str = ~"ten";
         let eleven: ~str = ~"eleven";
         let twelve: ~str = ~"twelve";
-        debug!{"str -> uint"};
+        debug!("str -> uint");
         let hm_su: map::hashmap<~str, uint> =
             map::hashmap::<~str, uint>(copy hasher_str, copy eqer_str);
         assert (hm_su.insert(~"ten", 12u));
@@ -600,7 +600,7 @@ mod tests {
         assert (hm_su.get(~"twelve") == 14u);
         assert (!hm_su.insert(~"twelve", 12u));
         assert (hm_su.get(~"twelve") == 12u);
-        debug!{"uint -> str"};
+        debug!("uint -> str");
         let hm_us: map::hashmap<uint, ~str> =
             map::hashmap::<uint, ~str>(copy hasher_uint, copy eqer_uint);
         assert (hm_us.insert(10u, ~"twelve"));
@@ -613,7 +613,7 @@ mod tests {
         assert hm_us.get(12u) == ~"fourteen";
         assert (!hm_us.insert(12u, ~"twelve"));
         assert hm_us.get(12u) == ~"twelve";
-        debug!{"str -> str"};
+        debug!("str -> str");
         let hm_ss: map::hashmap<~str, ~str> =
             map::hashmap::<~str, ~str>(copy hasher_str, copy eqer_str);
         assert (hm_ss.insert(ten, ~"twelve"));
@@ -626,7 +626,7 @@ mod tests {
         assert hm_ss.get(~"twelve") == ~"fourteen";
         assert (!hm_ss.insert(~"twelve", ~"twelve"));
         assert hm_ss.get(~"twelve") == ~"twelve";
-        debug!{"*** finished test_simple"};
+        debug!("*** finished test_simple");
     }
 
 
@@ -635,11 +635,11 @@ mod tests {
     */
     #[test]
     fn test_growth() {
-        debug!{"*** starting test_growth"};
+        debug!("*** starting test_growth");
         let num_to_insert: uint = 64u;
         pure fn eq_uint(x: &uint, y: &uint) -> bool { *x == *y }
         pure fn uint_id(x: &uint) -> uint { *x }
-        debug!{"uint -> uint"};
+        debug!("uint -> uint");
         let hasher_uint: map::hashfn<uint> = uint_id;
         let eqer_uint: map::eqfn<uint> = eq_uint;
         let hm_uu: map::hashmap<uint, uint> =
@@ -647,26 +647,26 @@ mod tests {
         let mut i: uint = 0u;
         while i < num_to_insert {
             assert (hm_uu.insert(i, i * i));
-            debug!{"inserting %u -> %u", i, i*i};
+            debug!("inserting %u -> %u", i, i*i);
             i += 1u;
         }
-        debug!{"-----"};
+        debug!("-----");
         i = 0u;
         while i < num_to_insert {
-            debug!{"get(%u) = %u", i, hm_uu.get(i)};
+            debug!("get(%u) = %u", i, hm_uu.get(i));
             assert (hm_uu.get(i) == i * i);
             i += 1u;
         }
         assert (hm_uu.insert(num_to_insert, 17u));
         assert (hm_uu.get(num_to_insert) == 17u);
-        debug!{"-----"};
+        debug!("-----");
         i = 0u;
         while i < num_to_insert {
-            debug!{"get(%u) = %u", i, hm_uu.get(i)};
+            debug!("get(%u) = %u", i, hm_uu.get(i));
             assert (hm_uu.get(i) == i * i);
             i += 1u;
         }
-        debug!{"str -> str"};
+        debug!("str -> str");
         let hasher_str: map::hashfn<~str> = str::hash;
         let eqer_str: map::eqfn<~str> = str::eq;
         let hm_ss: map::hashmap<~str, ~str> =
@@ -674,17 +674,17 @@ mod tests {
         i = 0u;
         while i < num_to_insert {
             assert hm_ss.insert(uint::to_str(i, 2u), uint::to_str(i * i, 2u));
-            debug!{"inserting \"%s\" -> \"%s\"",
+            debug!("inserting \"%s\" -> \"%s\"",
                    uint::to_str(i, 2u),
-                   uint::to_str(i*i, 2u)};
+                   uint::to_str(i*i, 2u));
             i += 1u;
         }
-        debug!{"-----"};
+        debug!("-----");
         i = 0u;
         while i < num_to_insert {
-            debug!{"get(\"%s\") = \"%s\"",
+            debug!("get(\"%s\") = \"%s\"",
                    uint::to_str(i, 2u),
-                   hm_ss.get(uint::to_str(i, 2u))};
+                   hm_ss.get(uint::to_str(i, 2u)));
             assert hm_ss.get(uint::to_str(i, 2u)) == uint::to_str(i * i, 2u);
             i += 1u;
         }
@@ -692,21 +692,21 @@ mod tests {
                              uint::to_str(17u, 2u)));
         assert hm_ss.get(uint::to_str(num_to_insert, 2u)) ==
             uint::to_str(17u, 2u);
-        debug!{"-----"};
+        debug!("-----");
         i = 0u;
         while i < num_to_insert {
-            debug!{"get(\"%s\") = \"%s\"",
+            debug!("get(\"%s\") = \"%s\"",
                    uint::to_str(i, 2u),
-                   hm_ss.get(uint::to_str(i, 2u))};
+                   hm_ss.get(uint::to_str(i, 2u)));
             assert hm_ss.get(uint::to_str(i, 2u)) == uint::to_str(i * i, 2u);
             i += 1u;
         }
-        debug!{"*** finished test_growth"};
+        debug!("*** finished test_growth");
     }
 
     #[test]
     fn test_removal() {
-        debug!{"*** starting test_removal"};
+        debug!("*** starting test_removal");
         let num_to_insert: uint = 64u;
         fn eq(x: &uint, y: &uint) -> bool { *x == *y }
         fn hash(u: &uint) -> uint {
@@ -724,12 +724,12 @@ mod tests {
         let mut i: uint = 0u;
         while i < num_to_insert {
             assert (hm.insert(i, i * i));
-            debug!{"inserting %u -> %u", i, i*i};
+            debug!("inserting %u -> %u", i, i*i);
             i += 1u;
         }
         assert (hm.size() == num_to_insert);
-        debug!{"-----"};
-        debug!{"removing evens"};
+        debug!("-----");
+        debug!("removing evens");
         i = 0u;
         while i < num_to_insert {
             let v = hm.remove(i);
@@ -737,44 +737,44 @@ mod tests {
             i += 2u;
         }
         assert (hm.size() == num_to_insert / 2u);
-        debug!{"-----"};
+        debug!("-----");
         i = 1u;
         while i < num_to_insert {
-            debug!{"get(%u) = %u", i, hm.get(i)};
+            debug!("get(%u) = %u", i, hm.get(i));
             assert (hm.get(i) == i * i);
             i += 2u;
         }
-        debug!{"-----"};
+        debug!("-----");
         i = 1u;
         while i < num_to_insert {
-            debug!{"get(%u) = %u", i, hm.get(i)};
+            debug!("get(%u) = %u", i, hm.get(i));
             assert (hm.get(i) == i * i);
             i += 2u;
         }
-        debug!{"-----"};
+        debug!("-----");
         i = 0u;
         while i < num_to_insert {
             assert (hm.insert(i, i * i));
-            debug!{"inserting %u -> %u", i, i*i};
+            debug!("inserting %u -> %u", i, i*i);
             i += 2u;
         }
         assert (hm.size() == num_to_insert);
-        debug!{"-----"};
+        debug!("-----");
         i = 0u;
         while i < num_to_insert {
-            debug!{"get(%u) = %u", i, hm.get(i)};
+            debug!("get(%u) = %u", i, hm.get(i));
             assert (hm.get(i) == i * i);
             i += 1u;
         }
-        debug!{"-----"};
+        debug!("-----");
         assert (hm.size() == num_to_insert);
         i = 0u;
         while i < num_to_insert {
-            debug!{"get(%u) = %u", i, hm.get(i)};
+            debug!("get(%u) = %u", i, hm.get(i));
             assert (hm.get(i) == i * i);
             i += 1u;
         }
-        debug!{"*** finished test_removal"};
+        debug!("*** finished test_removal");
     }
 
     #[test]
diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index bd4520e44a4..f7a7f42afcf 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -88,7 +88,7 @@ fn get_addr(++node: ~str, iotask: iotask)
         -> result::result<~[ip_addr], ip_get_addr_err> unsafe {
     do core::comm::listen |output_ch| {
         do str::as_buf(node) |node_ptr, len| {
-            log(debug, fmt!{"slice len %?", len});
+            log(debug, fmt!("slice len %?", len));
             let handle = create_uv_getaddrinfo_t();
             let handle_ptr = ptr::addr_of(handle);
             let handle_data: get_addr_data = {
@@ -161,10 +161,10 @@ mod v4 {
             }
         });
         if vec::len(parts) != 4u {
-                result::err(fmt!{"'%s' doesn't have 4 parts", ip})
+                result::err(fmt!("'%s' doesn't have 4 parts", ip))
                 }
         else if vec::contains(parts, 256u) {
-                result::err(fmt!{"invalid octal in addr '%s'", ip})
+                result::err(fmt!("invalid octal in addr '%s'", ip))
                 }
         else {
             result::ok({a: parts[0] as u8, b: parts[1] as u8,
@@ -185,8 +185,8 @@ mod v4 {
 
             let new_addr = uv_ip4_addr(ip, 22);
             let reformatted_name = uv_ip4_name(&new_addr);
-            log(debug, fmt!{"try_parse_addr: input ip: %s reparsed ip: %s",
-                            ip, reformatted_name});
+            log(debug, fmt!("try_parse_addr: input ip: %s reparsed ip: %s",
+                            ip, reformatted_name));
             let ref_ip_rep_result = parse_to_ipv4_rep(reformatted_name);
             if result::is_err(ref_ip_rep_result) {
                 let err_str = result::get_err(ref_ip_rep_result);
@@ -230,13 +230,13 @@ mod v6 {
             // need to figure out how to establish a parse failure..
             let new_addr = uv_ip6_addr(ip, 22);
             let reparsed_name = uv_ip6_name(&new_addr);
-            log(debug, fmt!{"v6::try_parse_addr ip: '%s' reparsed '%s'",
-                            ip, reparsed_name});
+            log(debug, fmt!("v6::try_parse_addr ip: '%s' reparsed '%s'",
+                            ip, reparsed_name));
             // '::' appears to be uv_ip6_name() returns for bogus
             // parses..
             if  ip != ~"::" && reparsed_name == ~"::" {
-                result::err({err_msg:fmt!{"failed to parse '%s'",
-                                           ip}})
+                result::err({err_msg:fmt!("failed to parse '%s'",
+                                           ip)})
             }
             else {
                 result::ok(ipv6(new_addr))
@@ -257,7 +257,7 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
     if status == 0i32 {
         if res != (ptr::null::<addrinfo>()) {
             let mut out_vec = ~[];
-            log(debug, fmt!{"initial addrinfo: %?", res});
+            log(debug, fmt!("initial addrinfo: %?", res));
             let mut curr_addr = res;
             loop {
                 let new_ip_addr = if ll::is_ipv4_addrinfo(curr_addr) {
@@ -284,11 +284,11 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
                 }
                 else {
                     curr_addr = next_addr;
-                    log(debug, fmt!{"next_addr addrinfo: %?", curr_addr});
+                    log(debug, fmt!("next_addr addrinfo: %?", curr_addr));
                 }
             }
-            log(debug, fmt!{"successful process addrinfo result, len: %?",
-                            vec::len(out_vec)});
+            log(debug, fmt!("successful process addrinfo result, len: %?",
+                            vec::len(out_vec)));
             (*handle_data).output_ch.send(result::ok(out_vec));
         }
         else {
@@ -320,19 +320,19 @@ mod test {
     fn test_ip_ipv6_parse_and_format_ip() {
         let localhost_str = ~"::1";
         let format_result = format_addr(v6::parse_addr(localhost_str));
-        log(debug, fmt!{"results: expected: '%s' actual: '%s'",
-            localhost_str, format_result});
+        log(debug, fmt!("results: expected: '%s' actual: '%s'",
+            localhost_str, format_result));
         assert format_result == localhost_str;
     }
     #[test]
     fn test_ip_ipv4_bad_parse() {
         match v4::try_parse_addr(~"b4df00d") {
           result::err(err_info) => {
-            log(debug, fmt!{"got error as expected %?", err_info});
+            log(debug, fmt!("got error as expected %?", err_info));
             assert true;
           }
           result::ok(addr) => {
-            fail fmt!{"Expected failure, but got addr %?", addr};
+            fail fmt!("Expected failure, but got addr %?", addr);
           }
         }
     }
@@ -341,11 +341,11 @@ mod test {
     fn test_ip_ipv6_bad_parse() {
         match v6::try_parse_addr(~"::,~2234k;") {
           result::err(err_info) => {
-            log(debug, fmt!{"got error as expected %?", err_info});
+            log(debug, fmt!("got error as expected %?", err_info));
             assert true;
           }
           result::ok(addr) => {
-            fail fmt!{"Expected failure, but got addr %?", addr};
+            fail fmt!("Expected failure, but got addr %?", addr);
           }
         }
     }
@@ -361,15 +361,15 @@ mod test {
         // note really sure how to realiably test/assert
         // this.. mostly just wanting to see it work, atm.
         let results = result::unwrap(ga_result);
-        log(debug, fmt!{"test_get_addr: Number of results for %s: %?",
-                        localhost_name, vec::len(results)});
+        log(debug, fmt!("test_get_addr: Number of results for %s: %?",
+                        localhost_name, vec::len(results)));
         for vec::each(results) |r| {
             let ipv_prefix = match r {
               ipv4(_) => ~"IPv4",
               ipv6(_) => ~"IPv6"
             };
-            log(debug, fmt!{"test_get_addr: result %s: '%s'",
-                            ipv_prefix, format_addr(r)});
+            log(debug, fmt!("test_get_addr: result %s: '%s'",
+                            ipv_prefix, format_addr(r)));
         }
         // at least one result.. this is going to vary from system
         // to system, based on stuff like the contents of /etc/hosts
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index aadbe09bc4e..64271eceed7 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -140,15 +140,15 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
         iotask: iotask
     };
     let socket_data_ptr = ptr::addr_of(*socket_data);
-    log(debug, fmt!{"tcp_connect result_ch %?", conn_data.result_ch});
+    log(debug, fmt!("tcp_connect result_ch %?", conn_data.result_ch));
     // get an unsafe representation of our stream_handle_ptr that
     // we can send into the interact cb to be handled in libuv..
-    log(debug, fmt!{"stream_handle_ptr outside interact %?",
-        stream_handle_ptr});
+    log(debug, fmt!("stream_handle_ptr outside interact %?",
+        stream_handle_ptr));
     do iotask::interact(iotask) |loop_ptr| {
         log(debug, ~"in interact cb for tcp client connect..");
-        log(debug, fmt!{"stream_handle_ptr in interact %?",
-            stream_handle_ptr});
+        log(debug, fmt!("stream_handle_ptr in interact %?",
+            stream_handle_ptr));
         match uv::ll::tcp_init( loop_ptr, stream_handle_ptr) {
           0i32 => {
             log(debug, ~"tcp_init successful");
@@ -165,7 +165,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
                     // info.. should probably add an additional
                     // rust type that actually is closer to
                     // what the libuv API expects (ip str + port num)
-                    log(debug, fmt!{"addr: %?", addr});
+                    log(debug, fmt!("addr: %?", addr));
                     let in_addr = uv::ll::ip4_addr(addr_str, port as int);
                     uv::ll::tcp_connect(
                         connect_req_ptr,
@@ -174,7 +174,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
                         tcp_connect_on_connect_cb)
                   }
                   ip::ipv6(addr) => {
-                    log(debug, fmt!{"addr: %?", addr});
+                    log(debug, fmt!("addr: %?", addr));
                     let in_addr = uv::ll::ip6_addr(addr_str, port as int);
                     uv::ll::tcp_connect6(
                         connect_req_ptr,
@@ -333,7 +333,7 @@ fn read_start(sock: tcp_socket)
 fn read_stop(sock: tcp_socket,
              -read_port: comm::Port<result::result<~[u8], tcp_err_data>>) ->
     result::result<(), tcp_err_data> unsafe {
-    log(debug, fmt!{"taking the read_port out of commission %?", read_port});
+    log(debug, fmt!("taking the read_port out of commission %?", read_port));
     let socket_data = ptr::addr_of(*sock.socket_data);
     read_stop_common_impl(socket_data)
 }
@@ -617,13 +617,13 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
                 let addr_str = ip::format_addr(loc_ip);
                 let bind_result = match loc_ip {
                   ip::ipv4(addr) => {
-                    log(debug, fmt!{"addr: %?", addr});
+                    log(debug, fmt!("addr: %?", addr));
                     let in_addr = uv::ll::ip4_addr(addr_str, port as int);
                     uv::ll::tcp_bind(server_stream_ptr,
                                      ptr::addr_of(in_addr))
                   }
                   ip::ipv6(addr) => {
-                    log(debug, fmt!{"addr: %?", addr});
+                    log(debug, fmt!("addr: %?", addr));
                     let in_addr = uv::ll::ip6_addr(addr_str, port as int);
                     uv::ll::tcp_bind6(server_stream_ptr,
                                      ptr::addr_of(in_addr))
@@ -661,8 +661,8 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
     match setup_result {
       some(err_data) => {
         do iotask::interact(iotask) |loop_ptr| {
-            log(debug, fmt!{"tcp::listen post-kill recv hl interact %?",
-                            loop_ptr});
+            log(debug, fmt!("tcp::listen post-kill recv hl interact %?",
+                            loop_ptr));
             (*server_data_ptr).active = false;
             uv::ll::close(server_stream_ptr, tcp_lfc_close_cb);
         };
@@ -677,8 +677,8 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
             result::err(address_in_use)
           }
           _ => {
-            log(debug, fmt!{"Got '%s' '%s' libuv error",
-                            err_data.err_name, err_data.err_msg});
+            log(debug, fmt!("Got '%s' '%s' libuv error",
+                            err_data.err_name, err_data.err_msg));
             result::err(
                 generic_listen_err(err_data.err_name, err_data.err_msg))
           }
@@ -688,8 +688,8 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
         on_establish_cb(kill_ch);
         let kill_result = core::comm::recv(kill_po);
         do iotask::interact(iotask) |loop_ptr| {
-            log(debug, fmt!{"tcp::listen post-kill recv hl interact %?",
-                            loop_ptr});
+            log(debug, fmt!("tcp::listen post-kill recv hl interact %?",
+                            loop_ptr));
             (*server_data_ptr).active = false;
             uv::ll::close(server_stream_ptr, tcp_lfc_close_cb);
         };
@@ -765,8 +765,8 @@ impl @tcp_socket_buf: io::Reader {
                 if err_data.err_name == ~"EOF" {
                     break;
                 } else {
-                    debug!{"ERROR sock_buf as io::reader.read err %? %?",
-                           err_data.err_name, err_data.err_msg};
+                    debug!("ERROR sock_buf as io::reader.read err %? %?",
+                           err_data.err_name, err_data.err_msg);
 
                     return 0;
                 }
@@ -798,7 +798,7 @@ impl @tcp_socket_buf: io::Reader {
         false // noop
     }
     fn seek(dist: int, seek: io::SeekStyle) {
-        log(debug, fmt!{"tcp_socket_buf seek stub %? %?", dist, seek});
+        log(debug, fmt!("tcp_socket_buf seek stub %? %?", dist, seek));
         // noop
     }
     fn tell() -> uint {
@@ -815,12 +815,12 @@ impl @tcp_socket_buf: io::Writer {
                                         vec::slice(data, 0, vec::len(data)));
         if w_result.is_err() {
             let err_data = w_result.get_err();
-            log(debug, fmt!{"ERROR sock_buf as io::writer.writer err: %? %?",
-                             err_data.err_name, err_data.err_msg});
+            log(debug, fmt!("ERROR sock_buf as io::writer.writer err: %? %?",
+                             err_data.err_name, err_data.err_msg));
         }
     }
     fn seek(dist: int, seek: io::SeekStyle) {
-      log(debug, fmt!{"tcp_socket_buf seek stub %? %?", dist, seek});
+      log(debug, fmt!("tcp_socket_buf seek stub %? %?", dist, seek));
         // noop
     }
     fn tell() -> uint {
@@ -845,14 +845,14 @@ fn tear_down_socket_data(socket_data: @tcp_socket_data) unsafe {
     let close_data_ptr = ptr::addr_of(close_data);
     let stream_handle_ptr = (*socket_data).stream_handle_ptr;
     do iotask::interact((*socket_data).iotask) |loop_ptr| {
-        log(debug, fmt!{"interact dtor for tcp_socket stream %? loop %?",
-            stream_handle_ptr, loop_ptr});
+        log(debug, fmt!("interact dtor for tcp_socket stream %? loop %?",
+            stream_handle_ptr, loop_ptr));
         uv::ll::set_data_for_uv_handle(stream_handle_ptr,
                                        close_data_ptr);
         uv::ll::close(stream_handle_ptr, tcp_socket_dtor_close_cb);
     };
     core::comm::recv(closed_po);
-    log(debug, fmt!{"about to free socket_data at %?", socket_data});
+    log(debug, fmt!("about to free socket_data at %?", socket_data));
     rustrt::rust_uv_current_kernel_free(stream_handle_ptr
                                        as *libc::c_void);
     log(debug, ~"exiting dtor for tcp_socket");
@@ -931,7 +931,7 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
     let start_ch = core::comm::chan(start_po);
     log(debug, ~"in tcp::read_start before interact loop");
     do iotask::interact((*socket_data).iotask) |loop_ptr| {
-        log(debug, fmt!{"in tcp::read_start interact cb %?", loop_ptr});
+        log(debug, fmt!("in tcp::read_start interact cb %?", loop_ptr));
         match uv::ll::read_start(stream_handle_ptr as *uv::ll::uv_stream_t,
                                on_alloc_cb,
                                on_tcp_read_cb) {
@@ -971,7 +971,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
     };
     let write_data_ptr = ptr::addr_of(write_data);
     do iotask::interact((*socket_data_ptr).iotask) |loop_ptr| {
-        log(debug, fmt!{"in interact cb for tcp::write %?", loop_ptr});
+        log(debug, fmt!("in interact cb for tcp::write %?", loop_ptr));
         match uv::ll::write(write_req_ptr,
                           stream_handle_ptr,
                           write_buf_vec_ptr,
@@ -1075,8 +1075,8 @@ impl uv::ll::uv_err_data: to_tcp_err {
 extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
                     nread: libc::ssize_t,
                     ++buf: uv::ll::uv_buf_t) unsafe {
-    log(debug, fmt!{"entering on_tcp_read_cb stream: %? nread: %?",
-                    stream, nread});
+    log(debug, fmt!("entering on_tcp_read_cb stream: %? nread: %?",
+                    stream, nread));
     let loop_ptr = uv::ll::get_loop_for_uv_handle(stream);
     let socket_data_ptr = uv::ll::get_data_for_uv_handle(stream)
         as *tcp_socket_data;
@@ -1084,8 +1084,8 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
       // incoming err.. probably eof
       -1 => {
         let err_data = uv::ll::get_last_err_data(loop_ptr).to_tcp_err();
-        log(debug, fmt!{"on_tcp_read_cb: incoming err.. name %? msg %?",
-                        err_data.err_name, err_data.err_msg});
+        log(debug, fmt!("on_tcp_read_cb: incoming err.. name %? msg %?",
+                        err_data.err_name, err_data.err_msg));
         let reader_ch = (*socket_data_ptr).reader_ch;
         core::comm::send(reader_ch, result::err(err_data));
       }
@@ -1094,7 +1094,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
       // have data
       _ => {
         // we have data
-        log(debug, fmt!{"tcp on_read_cb nread: %d", nread as int});
+        log(debug, fmt!("tcp on_read_cb nread: %d", nread as int));
         let reader_ch = (*socket_data_ptr).reader_ch;
         let buf_base = uv::ll::get_base_from_buf(buf);
         let new_bytes = vec::unsafe::from_buf(buf_base, nread as uint);
@@ -1110,10 +1110,10 @@ extern fn on_alloc_cb(handle: *libc::c_void,
     -> uv::ll::uv_buf_t unsafe {
     log(debug, ~"tcp read on_alloc_cb!");
     let char_ptr = uv::ll::malloc_buf_base_of(suggested_size);
-    log(debug, fmt!{"tcp read on_alloc_cb h: %? char_ptr: %u sugsize: %u",
+    log(debug, fmt!("tcp read on_alloc_cb h: %? char_ptr: %u sugsize: %u",
                      handle,
                      char_ptr as uint,
-                     suggested_size as uint});
+                     suggested_size as uint));
     uv::ll::buf_init(char_ptr, suggested_size as uint)
 }
 
@@ -1160,11 +1160,11 @@ extern fn stream_error_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
     let data = uv::ll::get_data_for_uv_handle(handle) as
         *connect_req_data;
     core::comm::send((*data).closed_signal_ch, ());
-    log(debug, fmt!{"exiting steam_error_close_cb for %?", handle});
+    log(debug, fmt!("exiting steam_error_close_cb for %?", handle));
 }
 
 extern fn tcp_connect_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
-    log(debug, fmt!{"closed client tcp handle %?", handle});
+    log(debug, fmt!("closed client tcp handle %?", handle));
 }
 
 extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
@@ -1172,7 +1172,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
     let conn_data_ptr = (uv::ll::get_data_for_req(connect_req_ptr)
                       as *connect_req_data);
     let result_ch = (*conn_data_ptr).result_ch;
-    log(debug, fmt!{"tcp_connect result_ch %?", result_ch});
+    log(debug, fmt!("tcp_connect result_ch %?", result_ch));
     let tcp_stream_ptr =
         uv::ll::get_stream_handle_from_connect_req(connect_req_ptr);
     match status {
@@ -1184,8 +1184,8 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
         log(debug, ~"error in tcp_connect_on_connect_cb");
         let loop_ptr = uv::ll::get_loop_for_uv_handle(tcp_stream_ptr);
         let err_data = uv::ll::get_last_err_data(loop_ptr);
-        log(debug, fmt!{"err_data %? %?", err_data.err_name,
-                        err_data.err_msg});
+        log(debug, fmt!("err_data %? %?", err_data.err_name,
+                        err_data.err_msg));
         core::comm::send(result_ch, conn_failure(err_data));
         uv::ll::set_data_for_uv_handle(tcp_stream_ptr,
                                        conn_data_ptr);
@@ -1314,10 +1314,10 @@ mod test {
         assert actual_resp_result.is_ok();
         let actual_resp = actual_resp_result.get();
         let actual_req = core::comm::recv(server_result_po);
-        log(debug, fmt!{"REQ: expected: '%s' actual: '%s'",
-                       expected_req, actual_req});
-        log(debug, fmt!{"RESP: expected: '%s' actual: '%s'",
-                       expected_resp, actual_resp});
+        log(debug, fmt!("REQ: expected: '%s' actual: '%s'",
+                       expected_req, actual_req));
+        log(debug, fmt!("RESP: expected: '%s' actual: '%s'",
+                       expected_resp, actual_resp));
         assert str::contains(actual_req, expected_req);
         assert str::contains(actual_resp, expected_resp);
     }
@@ -1453,27 +1453,27 @@ mod test {
         };
 
         let actual_req = core::comm::recv(server_result_po);
-        log(debug, fmt!{"REQ: expected: '%s' actual: '%s'",
-                       expected_req, actual_req});
-        log(debug, fmt!{"RESP: expected: '%s' actual: '%s'",
-                       expected_resp, actual_resp});
+        log(debug, fmt!("REQ: expected: '%s' actual: '%s'",
+                       expected_req, actual_req));
+        log(debug, fmt!("RESP: expected: '%s' actual: '%s'",
+                       expected_resp, actual_resp));
         assert str::contains(actual_req, expected_req);
         assert str::contains(actual_resp, expected_resp);
     }
 
     fn buf_write(+w: io::Writer, val: ~str) {
-        log(debug, fmt!{"BUF_WRITE: val len %?", str::len(val)});
+        log(debug, fmt!("BUF_WRITE: val len %?", str::len(val)));
         do str::byte_slice(val) |b_slice| {
-            log(debug, fmt!{"BUF_WRITE: b_slice len %?",
-                            vec::len(b_slice)});
+            log(debug, fmt!("BUF_WRITE: b_slice len %?",
+                            vec::len(b_slice)));
             w.write(b_slice)
         }
     }
 
     fn buf_read(+r: io::Reader, len: uint) -> ~str {
         let new_bytes = r.read_bytes(len);
-        log(debug, fmt!{"in buf_read.. new_bytes len: %?",
-                        vec::len(new_bytes)});
+        log(debug, fmt!("in buf_read.. new_bytes len: %?",
+                        vec::len(new_bytes)));
         str::from_bytes(new_bytes)
     }
 
@@ -1485,8 +1485,8 @@ mod test {
         let listen_result = listen(server_ip_addr, server_port, 128u, iotask,
             // on_establish_cb -- called when listener is set up
             |kill_ch| {
-                log(debug, fmt!{"establish_cb %?",
-                    kill_ch});
+                log(debug, fmt!("establish_cb %?",
+                    kill_ch));
                 core::comm::send(cont_ch, ());
             },
             // risky to run this on the loop, but some users
@@ -1518,8 +1518,8 @@ mod test {
                         match received_req_bytes {
                           result::ok(data) => {
                             log(debug, ~"SERVER: got REQ str::from_bytes..");
-                            log(debug, fmt!{"SERVER: REQ data len: %?",
-                                            vec::len(data)});
+                            log(debug, fmt!("SERVER: REQ data len: %?",
+                                            vec::len(data)));
                             server_ch.send(
                                 str::from_bytes(data));
                             log(debug, ~"SERVER: before write");
@@ -1528,8 +1528,8 @@ mod test {
                             core::comm::send(kill_ch, none);
                           }
                           result::err(err_data) => {
-                            log(debug, fmt!{"SERVER: error recvd: %s %s",
-                                err_data.err_name, err_data.err_msg});
+                            log(debug, fmt!("SERVER: error recvd: %s %s",
+                                err_data.err_name, err_data.err_msg));
                             core::comm::send(kill_ch, some(err_data));
                             server_ch.send(~"");
                           }
@@ -1546,8 +1546,8 @@ mod test {
         if result::is_err(listen_result) {
             match result::get_err(listen_result) {
               generic_listen_err(name, msg) => {
-                fail fmt!{"SERVER: exited abnormally name %s msg %s",
-                                name, msg};
+                fail fmt!("SERVER: exited abnormally name %s msg %s",
+                                name, msg);
               }
               access_denied => {
                 fail ~"SERVER: exited abnormally, got access denied..";
@@ -1558,7 +1558,7 @@ mod test {
             }
         }
         let ret_val = server_ch.recv();
-        log(debug, fmt!{"SERVER: exited and got return val: '%s'", ret_val});
+        log(debug, fmt!("SERVER: exited and got return val: '%s'", ret_val));
         ret_val
     }
 
@@ -1568,12 +1568,12 @@ mod test {
         let listen_result = listen(server_ip_addr, server_port, 128u, iotask,
             // on_establish_cb -- called when listener is set up
             |kill_ch| {
-                log(debug, fmt!{"establish_cb %?",
-                    kill_ch});
+                log(debug, fmt!("establish_cb %?",
+                    kill_ch));
             },
             |new_conn, kill_ch| {
-                fail fmt!{"SERVER: shouldn't be called.. %? %?",
-                           new_conn, kill_ch};
+                fail fmt!("SERVER: shouldn't be called.. %? %?",
+                           new_conn, kill_ch);
         });
         // err check on listen_result
         if result::is_err(listen_result) {
@@ -1609,8 +1609,8 @@ mod test {
             else {
                 client_ch.send(str::from_bytes(read_result.get()));
                 let ret_val = client_ch.recv();
-                log(debug, fmt!{"CLIENT: after client_ch recv ret: '%s'",
-                   ret_val});
+                log(debug, fmt!("CLIENT: after client_ch recv ret: '%s'",
+                   ret_val));
                 ok(ret_val)
             }
         }
@@ -1622,8 +1622,8 @@ mod test {
         if result::is_err(write_result) {
             log(debug, ~"tcp_write_single: write failed!");
             let err_data = result::get_err(write_result);
-            log(debug, fmt!{"tcp_write_single err name: %s msg: %s",
-                err_data.err_name, err_data.err_msg});
+            log(debug, fmt!("tcp_write_single err name: %s msg: %s",
+                err_data.err_name, err_data.err_msg));
             // meh. torn on what to do here.
             fail ~"tcp_write_single failed";
         }
diff --git a/src/libstd/par.rs b/src/libstd/par.rs
index 7dbb07a6aad..34ea2433bed 100644
--- a/src/libstd/par.rs
+++ b/src/libstd/par.rs
@@ -47,11 +47,11 @@ fn map_slices<A: copy send, B: copy send>(
                         let len = end - base;
                         let slice = (ptr::offset(p, base),
                                      len * sys::size_of::<A>());
-                        log(info, fmt!{"pre-slice: %?", (base, slice)});
+                        log(info, fmt!("pre-slice: %?", (base, slice)));
                         let slice : &[A] =
                             unsafe::reinterpret_cast(slice);
-                        log(info, fmt!{"slice: %?",
-                                       (base, vec::len(slice), end - base)});
+                        log(info, fmt!("slice: %?",
+                                       (base, vec::len(slice), end - base)));
                         assert(vec::len(slice) == end - base);
                         f(base, slice)
                     }
@@ -62,7 +62,7 @@ fn map_slices<A: copy send, B: copy send>(
         }
         log(info, ~"tasks spawned");
 
-        log(info, fmt!{"num_tasks: %?", (num_tasks, futures.len())});
+        log(info, fmt!("num_tasks: %?", (num_tasks, futures.len())));
         assert(num_tasks == futures.len());
 
         let r = do futures.map() |ys| {
diff --git a/src/libstd/prettyprint.rs b/src/libstd/prettyprint.rs
index 252ab3dd8e2..4e21da29fd7 100644
--- a/src/libstd/prettyprint.rs
+++ b/src/libstd/prettyprint.rs
@@ -8,63 +8,63 @@ impl Writer: serializer {
     }
 
     fn emit_uint(v: uint) {
-        self.write_str(fmt!{"%?u", v});
+        self.write_str(fmt!("%?u", v));
     }
 
     fn emit_u64(v: u64) {
-        self.write_str(fmt!{"%?_u64", v});
+        self.write_str(fmt!("%?_u64", v));
     }
 
     fn emit_u32(v: u32) {
-        self.write_str(fmt!{"%?_u32", v});
+        self.write_str(fmt!("%?_u32", v));
     }
 
     fn emit_u16(v: u16) {
-        self.write_str(fmt!{"%?_u16", v});
+        self.write_str(fmt!("%?_u16", v));
     }
 
     fn emit_u8(v: u8) {
-        self.write_str(fmt!{"%?_u8", v});
+        self.write_str(fmt!("%?_u8", v));
     }
 
     fn emit_int(v: int) {
-        self.write_str(fmt!{"%?", v});
+        self.write_str(fmt!("%?", v));
     }
 
     fn emit_i64(v: i64) {
-        self.write_str(fmt!{"%?_i64", v});
+        self.write_str(fmt!("%?_i64", v));
     }
 
     fn emit_i32(v: i32) {
-        self.write_str(fmt!{"%?_i32", v});
+        self.write_str(fmt!("%?_i32", v));
     }
 
     fn emit_i16(v: i16) {
-        self.write_str(fmt!{"%?_i16", v});
+        self.write_str(fmt!("%?_i16", v));
     }
 
     fn emit_i8(v: i8) {
-        self.write_str(fmt!{"%?_i8", v});
+        self.write_str(fmt!("%?_i8", v));
     }
 
     fn emit_bool(v: bool) {
-        self.write_str(fmt!{"%b", v});
+        self.write_str(fmt!("%b", v));
     }
 
     fn emit_float(v: float) {
-        self.write_str(fmt!{"%?_f", v});
+        self.write_str(fmt!("%?_f", v));
     }
 
     fn emit_f64(v: f64) {
-        self.write_str(fmt!{"%?_f64", v});
+        self.write_str(fmt!("%?_f64", v));
     }
 
     fn emit_f32(v: f32) {
-        self.write_str(fmt!{"%?_f32", v});
+        self.write_str(fmt!("%?_f32", v));
     }
 
     fn emit_str(v: &str) {
-        self.write_str(fmt!{"%?", v});
+        self.write_str(fmt!("%?", v));
     }
 
     fn emit_enum(_name: ~str, f: fn()) {
diff --git a/src/libstd/smallintmap.rs b/src/libstd/smallintmap.rs
index 04b04f505a4..5a7e77ead48 100644
--- a/src/libstd/smallintmap.rs
+++ b/src/libstd/smallintmap.rs
@@ -27,7 +27,7 @@ fn mk<T: copy>() -> smallintmap<T> {
  */
 #[inline(always)]
 fn insert<T: copy>(self: smallintmap<T>, key: uint, val: T) {
-    //io::println(fmt!{"%?", key});
+    //io::println(fmt!("%?", key));
     self.v.grow_set_elt(key, none, some(val));
 }
 
@@ -50,7 +50,7 @@ pure fn find<T: copy>(self: smallintmap<T>, key: uint) -> option<T> {
 pure fn get<T: copy>(self: smallintmap<T>, key: uint) -> T {
     match find(self, key) {
       none => {
-        error!{"smallintmap::get(): key not present"};
+        error!("smallintmap::get(): key not present");
         fail;
       }
       some(v) => return v
diff --git a/src/libstd/sort.rs b/src/libstd/sort.rs
index df13fcba1af..256ee4ecd73 100644
--- a/src/libstd/sort.rs
+++ b/src/libstd/sort.rs
@@ -250,7 +250,7 @@ mod test_qsort {
         let pairs = vec::zip(expected, immut_names);
         for vec::each(pairs) |p| {
             let (a, b) = p;
-            debug!{"%d %d", a, b};
+            debug!("%d %d", a, b);
             assert (a == b);
         }
     }
diff --git a/src/libstd/test.rs b/src/libstd/test.rs
index 09bde8d6b3f..a0cc26b6658 100644
--- a/src/libstd/test.rs
+++ b/src/libstd/test.rs
@@ -110,9 +110,9 @@ fn run_tests_console(opts: test_opts,
           te_filtered(filtered_tests) => {
             st.total = vec::len(filtered_tests);
             let noun = if st.total != 1u { ~"tests" } else { ~"test" };
-            st.out.write_line(fmt!{"\nrunning %u %s", st.total, noun});
+            st.out.write_line(fmt!("\nrunning %u %s", st.total, noun));
           }
-          te_wait(test) => st.out.write_str(fmt!{"test %s ... ", test.name}),
+          te_wait(test) => st.out.write_str(fmt!("test %s ... ", test.name)),
           te_result(test, result) => {
             match st.log_out {
                 some(f) => write_log(f, result, test),
@@ -145,7 +145,7 @@ fn run_tests_console(opts: test_opts,
                                             ~[io::Create, io::Truncate]) {
           result::ok(w) => some(w),
           result::err(s) => {
-              fail(fmt!{"can't open output file: %s", s})
+              fail(fmt!("can't open output file: %s", s))
           }
         },
         none => none
@@ -170,23 +170,23 @@ fn run_tests_console(opts: test_opts,
         print_failures(st);
     }
 
-    st.out.write_str(fmt!{"\nresult: "});
+    st.out.write_str(fmt!("\nresult: "));
     if success {
         // There's no parallelism at this point so it's safe to use color
         write_ok(st.out, true);
     } else { write_failed(st.out, true); }
-    st.out.write_str(fmt!{". %u passed; %u failed; %u ignored\n\n", st.passed,
-                          st.failed, st.ignored});
+    st.out.write_str(fmt!(". %u passed; %u failed; %u ignored\n\n", st.passed,
+                          st.failed, st.ignored));
 
     return success;
 
     fn write_log(out: io::Writer, result: test_result, test: test_desc) {
-        out.write_line(fmt!{"%s %s",
+        out.write_line(fmt!("%s %s",
                     match result {
                         tr_ok => ~"ok",
                         tr_failed => ~"failed",
                         tr_ignored => ~"ignored"
-                    }, test.name});
+                    }, test.name));
     }
 
     fn write_ok(out: io::Writer, use_color: bool) {
@@ -218,7 +218,7 @@ fn print_failures(st: console_test_state) {
     let failures = vec::map(failures, |test| test.name);
     let failures = sort::merge_sort(str::le, failures);
     for vec::each(failures) |name| {
-        st.out.write_line(fmt!{"    %s", name});
+        st.out.write_line(fmt!("    %s", name));
     }
 }
 
@@ -279,7 +279,7 @@ fn run_tests(opts: test_opts, tests: ~[test_desc],
     // It's tempting to just spawn all the tests at once, but since we have
     // many tests that run in other processes we would be making a big mess.
     let concurrency = get_concurrency();
-    debug!{"using %u test tasks", concurrency};
+    debug!("using %u test tasks", concurrency);
 
     let total = vec::len(filtered_tests);
     let mut run_idx = 0u;
diff --git a/src/libstd/time.rs b/src/libstd/time.rs
index 1aa6c4d74da..4f557fd9573 100644
--- a/src/libstd/time.rs
+++ b/src/libstd/time.rs
@@ -200,9 +200,9 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
         if c == ch {
             ok(next)
         } else {
-            err(fmt!{"Expected %?, found %?",
+            err(fmt!("Expected %?, found %?",
                 str::from_char(c),
-                str::from_char(ch)})
+                str::from_char(ch)))
         }
     }
 
@@ -511,7 +511,7 @@ fn strptime(s: ~str, format: ~str) -> result<tm, ~str> {
           }
           '%' => parse_char(s, pos, '%'),
           ch => {
-            err(fmt!{"unknown formatting type: %?", str::from_char(ch)})
+            err(fmt!("unknown formatting type: %?", str::from_char(ch)))
           }
         }
     }
@@ -625,70 +625,70 @@ fn strftime(format: ~str, tm: tm) -> ~str {
             11 => ~"Dec",
             _  => die()
           },
-          'C' => fmt!{"%02d", (tm.tm_year as int + 1900) / 100},
+          'C' => fmt!("%02d", (tm.tm_year as int + 1900) / 100),
           'c' => {
-            fmt!{"%s %s %s %s %s",
+            fmt!("%s %s %s %s %s",
                 parse_type('a', tm),
                 parse_type('b', tm),
                 parse_type('e', tm),
                 parse_type('T', tm),
-                parse_type('Y', tm)}
+                parse_type('Y', tm))
           }
           'D' | 'x' => {
-            fmt!{"%s/%s/%s",
+            fmt!("%s/%s/%s",
                 parse_type('m', tm),
                 parse_type('d', tm),
-                parse_type('y', tm)}
+                parse_type('y', tm))
           }
-          'd' => fmt!{"%02d", tm.tm_mday as int},
-          'e' => fmt!{"%2d", tm.tm_mday as int},
+          'd' => fmt!("%02d", tm.tm_mday as int),
+          'e' => fmt!("%2d", tm.tm_mday as int),
           'F' => {
-            fmt!{"%s-%s-%s",
+            fmt!("%s-%s-%s",
                 parse_type('Y', tm),
                 parse_type('m', tm),
-                parse_type('d', tm)}
+                parse_type('d', tm))
           }
           //'G' {}
           //'g' {}
-          'H' => fmt!{"%02d", tm.tm_hour as int},
+          'H' => fmt!("%02d", tm.tm_hour as int),
           'I' => {
             let mut h = tm.tm_hour as int;
             if h == 0 { h = 12 }
             if h > 12 { h -= 12 }
-            fmt!{"%02d", h}
+            fmt!("%02d", h)
           }
-          'j' => fmt!{"%03d", tm.tm_yday as int + 1},
-          'k' => fmt!{"%2d", tm.tm_hour as int},
+          'j' => fmt!("%03d", tm.tm_yday as int + 1),
+          'k' => fmt!("%2d", tm.tm_hour as int),
           'l' => {
             let mut h = tm.tm_hour as int;
             if h == 0 { h = 12 }
             if h > 12 { h -= 12 }
-            fmt!{"%2d", h}
+            fmt!("%2d", h)
           }
-          'M' => fmt!{"%02d", tm.tm_min as int},
-          'm' => fmt!{"%02d", tm.tm_mon as int + 1},
+          'M' => fmt!("%02d", tm.tm_min as int),
+          'm' => fmt!("%02d", tm.tm_mon as int + 1),
           'n' => ~"\n",
           'P' => if tm.tm_hour as int < 12 { ~"am" } else { ~"pm" },
           'p' => if tm.tm_hour as int < 12 { ~"AM" } else { ~"PM" },
           'R' => {
-            fmt!{"%s:%s",
+            fmt!("%s:%s",
                 parse_type('H', tm),
-                parse_type('M', tm)}
+                parse_type('M', tm))
           }
           'r' => {
-            fmt!{"%s:%s:%s %s",
+            fmt!("%s:%s:%s %s",
                 parse_type('I', tm),
                 parse_type('M', tm),
                 parse_type('S', tm),
-                parse_type('p', tm)}
+                parse_type('p', tm))
           }
-          'S' => fmt!{"%02d", tm.tm_sec as int},
-          's' => fmt!{"%d", tm.to_timespec().sec as int},
+          'S' => fmt!("%02d", tm.tm_sec as int),
+          's' => fmt!("%d", tm.to_timespec().sec as int),
           'T' | 'X' => {
-            fmt!{"%s:%s:%s",
+            fmt!("%s:%s:%s",
                 parse_type('H', tm),
                 parse_type('M', tm),
-                parse_type('S', tm)}
+                parse_type('S', tm))
           }
           't' => ~"\t",
           //'U' {}
@@ -698,24 +698,24 @@ fn strftime(format: ~str, tm: tm) -> ~str {
           }
           //'V' {}
           'v' => {
-            fmt!{"%s-%s-%s",
+            fmt!("%s-%s-%s",
                 parse_type('e', tm),
                 parse_type('b', tm),
-                parse_type('Y', tm)}
+                parse_type('Y', tm))
           }
           //'W' {}
           'w' => int::str(tm.tm_wday as int),
           //'X' {}
           //'x' {}
           'Y' => int::str(tm.tm_year as int + 1900),
-          'y' => fmt!{"%02d", (tm.tm_year as int + 1900) % 100},
+          'y' => fmt!("%02d", (tm.tm_year as int + 1900) % 100),
           'Z' => tm.tm_zone,
           'z' => {
             let sign = if tm.tm_gmtoff > 0_i32 { '+' } else { '-' };
             let mut m = i32::abs(tm.tm_gmtoff) / 60_i32;
             let h = m / 60_i32;
             m -= h * 60_i32;
-            fmt!{"%c%02d%02d", sign, h as int, m as int}
+            fmt!("%c%02d%02d", sign, h as int, m as int)
           }
           //'+' {}
           '%' => ~"%",
@@ -807,7 +807,7 @@ impl tm {
             let mut m = i32::abs(self.tm_gmtoff) / 60_i32;
             let h = m / 60_i32;
             m -= h * 60_i32;
-            s + fmt!{"%c%02d:%02d", sign, h as int, m as int}
+            s + fmt!("%c%02d:%02d", sign, h as int, m as int)
         }
     }
 }
@@ -888,7 +888,7 @@ mod tests {
         let time = { sec: 1234567890_i64, nsec: 54321_i32 };
         let local = at(time);
 
-        error!{"time_at: %?", local};
+        error!("time_at: %?", local);
 
         assert local.tm_sec == 30_i32;
         assert local.tm_min == 31_i32;
@@ -1094,7 +1094,7 @@ mod tests {
         let utc   = at_utc(time);
         let local = at(time);
 
-        error!{"test_ctime: %? %?", utc.ctime(), local.ctime()};
+        error!("test_ctime: %? %?", utc.ctime(), local.ctime());
 
         assert utc.ctime()   == ~"Fri Feb 13 23:31:30 2009";
         assert local.ctime() == ~"Fri Feb 13 15:31:30 2009";
diff --git a/src/libstd/timer.rs b/src/libstd/timer.rs
index 67df1e9e190..02c2294f8c4 100644
--- a/src/libstd/timer.rs
+++ b/src/libstd/timer.rs
@@ -108,8 +108,8 @@ fn recv_timeout<T: copy send>(iotask: iotask,
     // FIXME: This could be written clearer (#2618)
     either::either(
         |left_val| {
-            log(debug, fmt!{"recv_time .. left_val %?",
-                           left_val});
+            log(debug, fmt!("recv_time .. left_val %?",
+                           left_val));
             none
         }, |right_val| {
             some(*right_val)
@@ -120,7 +120,7 @@ fn recv_timeout<T: copy send>(iotask: iotask,
 // INTERNAL API
 extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t,
                                 status: libc::c_int) unsafe {
-    log(debug, fmt!{"delayed_send_cb handle %? status %?", handle, status});
+    log(debug, fmt!("delayed_send_cb handle %? status %?", handle, status));
     let timer_done_ch =
         *(uv::ll::get_data_for_uv_handle(handle) as *comm::Chan<()>);
     let stop_result = uv::ll::timer_stop(handle);
@@ -136,7 +136,7 @@ extern fn delayed_send_cb(handle: *uv::ll::uv_timer_t,
 }
 
 extern fn delayed_send_close_cb(handle: *uv::ll::uv_timer_t) unsafe {
-    log(debug, fmt!{"delayed_send_close_cb handle %?", handle});
+    log(debug, fmt!("delayed_send_close_cb handle %?", handle));
     let timer_done_ch =
         *(uv::ll::get_data_for_uv_handle(handle) as *comm::Chan<()>);
     comm::send(timer_done_ch, ());
diff --git a/src/libstd/uv_global_loop.rs b/src/libstd/uv_global_loop.rs
index 669b4f16e1b..1c301a78260 100644
--- a/src/libstd/uv_global_loop.rs
+++ b/src/libstd/uv_global_loop.rs
@@ -37,10 +37,10 @@ fn get_monitor_task_gl() -> iotask unsafe {
 
     let monitor_loop_chan_ptr = rustrt::rust_uv_get_kernel_global_chan_ptr();
 
-    debug!{"ENTERING global_loop::get() loop chan: %?",
-           monitor_loop_chan_ptr};
+    debug!("ENTERING global_loop::get() loop chan: %?",
+           monitor_loop_chan_ptr);
 
-    debug!{"before priv::chan_from_global_ptr"};
+    debug!("before priv::chan_from_global_ptr");
     type monchan = Chan<iotask>;
 
     let monitor_ch =
@@ -50,31 +50,31 @@ fn get_monitor_task_gl() -> iotask unsafe {
                                                 (task::SingleThreaded)
                                                 .unlinked()
                                            }) |msg_po| {
-        debug!{"global monitor task starting"};
+        debug!("global monitor task starting");
 
         // As a weak task the runtime will notify us when to exit
         do weaken_task() |weak_exit_po| {
-            debug!{"global monitor task is now weak"};
+            debug!("global monitor task is now weak");
             let hl_loop = spawn_loop();
             loop {
-                debug!{"in outer_loop..."};
+                debug!("in outer_loop...");
                 match select2(weak_exit_po, msg_po) {
                   Left(weak_exit) => {
                     // all normal tasks have ended, tell the
                     // libuv loop to tear_down, then exit
-                    debug!{"weak_exit_po recv'd msg: %?", weak_exit};
+                    debug!("weak_exit_po recv'd msg: %?", weak_exit);
                     iotask::exit(hl_loop);
                     break;
                   }
                   Right(fetch_ch) => {
-                    debug!{"hl_loop req recv'd: %?", fetch_ch};
+                    debug!("hl_loop req recv'd: %?", fetch_ch);
                     fetch_ch.send(hl_loop);
                   }
                 }
             }
-            debug!{"global monitor task is leaving weakend state"};
+            debug!("global monitor task is leaving weakend state");
         };
-        debug!{"global monitor task exiting"};
+        debug!("global monitor task exiting");
     };
 
     // once we have a chan to the monitor loop, we ask it for
@@ -91,14 +91,14 @@ fn spawn_loop() -> iotask unsafe {
             // The I/O loop task also needs to be weak so it doesn't keep
             // the runtime alive
             do weaken_task |weak_exit_po| {
-                debug!{"global libuv task is now weak %?", weak_exit_po};
+                debug!("global libuv task is now weak %?", weak_exit_po);
                 task_body();
 
                 // We don't wait for the exit message on weak_exit_po
                 // because the monitor task will tell the uv loop when to
                 // exit
 
-                debug!{"global libuv task is leaving weakened state"};
+                debug!("global libuv task is leaving weakened state");
             }
         }
     };
@@ -112,8 +112,8 @@ mod test {
             timer_ptr as *libc::c_void) as *comm::Chan<bool>;
         let exit_ch = *exit_ch_ptr;
         core::comm::send(exit_ch, true);
-        log(debug, fmt!{"EXIT_CH_PTR simple_timer_close_cb exit_ch_ptr: %?",
-                       exit_ch_ptr});
+        log(debug, fmt!("EXIT_CH_PTR simple_timer_close_cb exit_ch_ptr: %?",
+                       exit_ch_ptr));
     }
     extern fn simple_timer_cb(timer_ptr: *ll::uv_timer_t,
                              _status: libc::c_int) unsafe {
@@ -133,8 +133,8 @@ mod test {
         let exit_po = core::comm::port::<bool>();
         let exit_ch = core::comm::chan(exit_po);
         let exit_ch_ptr = ptr::addr_of(exit_ch);
-        log(debug, fmt!{"EXIT_CH_PTR newly created exit_ch_ptr: %?",
-                       exit_ch_ptr});
+        log(debug, fmt!("EXIT_CH_PTR newly created exit_ch_ptr: %?",
+                       exit_ch_ptr));
         let timer_handle = ll::timer_t();
         let timer_ptr = ptr::addr_of(timer_handle);
         do iotask::interact(iotask) |loop_ptr| {
diff --git a/src/libstd/uv_iotask.rs b/src/libstd/uv_iotask.rs
index f6ccbeb5d0d..2643edc87bd 100644
--- a/src/libstd/uv_iotask.rs
+++ b/src/libstd/uv_iotask.rs
@@ -30,9 +30,9 @@ fn spawn_iotask(-task: task::TaskBuilder) -> iotask {
     do listen |iotask_ch| {
 
         do task.sched_mode(task::SingleThreaded).spawn {
-            debug!{"entering libuv task"};
+            debug!("entering libuv task");
             run_loop(iotask_ch);
-            debug!{"libuv task exiting"};
+            debug!("libuv task exiting");
         };
 
         iotask_ch.recv()
@@ -137,8 +137,8 @@ fn send_msg(iotask: iotask,
 extern fn wake_up_cb(async_handle: *ll::uv_async_t,
                     status: int) unsafe {
 
-    log(debug, fmt!{"wake_up_cb extern.. handle: %? status: %?",
-                     async_handle, status});
+    log(debug, fmt!("wake_up_cb extern.. handle: %? status: %?",
+                     async_handle, status));
 
     let loop_ptr = ll::get_loop_for_uv_handle(async_handle);
     let data = ll::get_data_for_uv_handle(async_handle) as *iotask_loop_data;
@@ -161,22 +161,22 @@ fn begin_teardown(data: *iotask_loop_data) unsafe {
 extern fn tear_down_close_cb(handle: *ll::uv_async_t) unsafe {
     let loop_ptr = ll::get_loop_for_uv_handle(handle);
     let loop_refs = ll::loop_refcount(loop_ptr);
-    log(debug, fmt!{"tear_down_close_cb called, closing handle at %? refs %?",
-                    handle, loop_refs});
+    log(debug, fmt!("tear_down_close_cb called, closing handle at %? refs %?",
+                    handle, loop_refs));
     assert loop_refs == 1i32;
 }
 
 #[cfg(test)]
 mod test {
     extern fn async_close_cb(handle: *ll::uv_async_t) unsafe {
-        log(debug, fmt!{"async_close_cb handle %?", handle});
+        log(debug, fmt!("async_close_cb handle %?", handle));
         let exit_ch = (*(ll::get_data_for_uv_handle(handle)
                         as *ah_data)).exit_ch;
         core::comm::send(exit_ch, ());
     }
     extern fn async_handle_cb(handle: *ll::uv_async_t, status: libc::c_int)
         unsafe {
-        log(debug, fmt!{"async_handle_cb handle %? status %?",handle,status});
+        log(debug, fmt!("async_handle_cb handle %? status %?",handle,status));
         ll::close(handle, async_close_cb);
     }
     type ah_data = {
@@ -214,13 +214,13 @@ mod test {
     }
 
     extern fn lifetime_handle_close(handle: *libc::c_void) unsafe {
-        log(debug, fmt!{"lifetime_handle_close ptr %?", handle});
+        log(debug, fmt!("lifetime_handle_close ptr %?", handle));
     }
 
     extern fn lifetime_async_callback(handle: *libc::c_void,
                                      status: libc::c_int) {
-        log(debug, fmt!{"lifetime_handle_close ptr %? status %?",
-                        handle, status});
+        log(debug, fmt!("lifetime_handle_close ptr %? status %?",
+                        handle, status));
     }
 
     #[test]
diff --git a/src/libstd/uv_ll.rs b/src/libstd/uv_ll.rs
index 0737e61a7c1..79a2856a1c7 100644
--- a/src/libstd/uv_ll.rs
+++ b/src/libstd/uv_ll.rs
@@ -707,8 +707,8 @@ unsafe fn tcp_connect(connect_ptr: *uv_connect_t,
                       addr_ptr: *sockaddr_in,
                       ++after_connect_cb: *u8)
 -> libc::c_int {
-    log(debug, fmt!{"b4 foreign tcp_connect--addr port: %u cb: %u",
-                    (*addr_ptr).sin_port as uint, after_connect_cb as uint});
+    log(debug, fmt!("b4 foreign tcp_connect--addr port: %u cb: %u",
+                    (*addr_ptr).sin_port as uint, after_connect_cb as uint));
     return rustrt::rust_uv_tcp_connect(connect_ptr, tcp_handle_ptr,
                                     after_connect_cb, addr_ptr);
 }
@@ -788,10 +788,10 @@ unsafe fn async_send(async_handle: *uv_async_t) {
 unsafe fn buf_init(++input: *u8, len: uint) -> uv_buf_t {
     let out_buf = { base: ptr::null(), len: 0 as libc::size_t };
     let out_buf_ptr = ptr::addr_of(out_buf);
-    log(debug, fmt!{"buf_init - input %u len %u out_buf: %u",
+    log(debug, fmt!("buf_init - input %u len %u out_buf: %u",
                      input as uint,
                      len as uint,
-                     out_buf_ptr as uint});
+                     out_buf_ptr as uint));
     // yuck :/
     rustrt::rust_uv_buf_init(out_buf_ptr, input, len as size_t);
     //let result = rustrt::rust_uv_buf_init_2(input, len as size_t);
@@ -799,9 +799,9 @@ unsafe fn buf_init(++input: *u8, len: uint) -> uv_buf_t {
     let res_base = get_base_from_buf(out_buf);
     let res_len = get_len_from_buf(out_buf);
     //let res_base = get_base_from_buf(result);
-    log(debug, fmt!{"buf_init - result %u len %u",
+    log(debug, fmt!("buf_init - result %u len %u",
                      res_base as uint,
-                     res_len as uint});
+                     res_len as uint));
     return out_buf;
     //return result;
 }
@@ -845,8 +845,8 @@ unsafe fn ip6_name(src: &sockaddr_in6) -> ~str {
                        0u8,0u8,0u8,0u8,0u8,0u8];
     do vec::as_buf(dst) |dst_buf, size| {
         let src_unsafe_ptr = assimilate(src);
-        log(debug, fmt!{"val of src *sockaddr_in6: %? sockaddr_in6: %?",
-                        src_unsafe_ptr, src});
+        log(debug, fmt!("val of src *sockaddr_in6: %? sockaddr_in6: %?",
+                        src_unsafe_ptr, src));
         let result = rustrt::rust_uv_ip6_name(src_unsafe_ptr,
                                               dst_buf, size as libc::size_t);
         match result {
@@ -962,8 +962,8 @@ unsafe fn get_last_err_info(uv_loop: *libc::c_void) -> ~str {
     let err_ptr = ptr::addr_of(err);
     let err_name = str::unsafe::from_c_str(err_name(err_ptr));
     let err_msg = str::unsafe::from_c_str(strerror(err_ptr));
-    return fmt!{"LIBUV ERROR: name: %s msg: %s",
-                    err_name, err_msg};
+    return fmt!("LIBUV ERROR: name: %s msg: %s",
+                    err_name, err_msg);
 }
 
 unsafe fn get_last_err_data(uv_loop: *libc::c_void) -> uv_err_data {
@@ -1013,8 +1013,8 @@ mod test {
     };
 
     extern fn after_close_cb(handle: *libc::c_void) {
-        log(debug, fmt!{"after uv_close! handle ptr: %?",
-                        handle});
+        log(debug, fmt!("after uv_close! handle ptr: %?",
+                        handle));
     }
 
     extern fn on_alloc_cb(handle: *libc::c_void,
@@ -1022,10 +1022,10 @@ mod test {
         -> uv_buf_t unsafe {
         log(debug, ~"on_alloc_cb!");
         let char_ptr = malloc_buf_base_of(suggested_size);
-        log(debug, fmt!{"on_alloc_cb h: %? char_ptr: %u sugsize: %u",
+        log(debug, fmt!("on_alloc_cb h: %? char_ptr: %u sugsize: %u",
                          handle,
                          char_ptr as uint,
-                         suggested_size as uint});
+                         suggested_size as uint));
         return buf_init(char_ptr, suggested_size as uint);
     }
 
@@ -1033,11 +1033,11 @@ mod test {
                         nread: libc::ssize_t,
                         ++buf: uv_buf_t) unsafe {
         let nread = nread as int;
-        log(debug, fmt!{"CLIENT entering on_read_cb nred: %d",
-                        nread});
+        log(debug, fmt!("CLIENT entering on_read_cb nred: %d",
+                        nread));
         if (nread > 0) {
             // we have data
-            log(debug, fmt!{"CLIENT read: data! nread: %d", nread});
+            log(debug, fmt!("CLIENT read: data! nread: %d", nread));
             read_stop(stream);
             let client_data =
                 get_data_for_uv_handle(stream as *libc::c_void)
@@ -1065,20 +1065,20 @@ mod test {
 
     extern fn on_write_complete_cb(write_req: *uv_write_t,
                                   status: libc::c_int) unsafe {
-        log(debug, fmt!{"CLIENT beginning on_write_complete_cb status: %d",
-                         status as int});
+        log(debug, fmt!("CLIENT beginning on_write_complete_cb status: %d",
+                         status as int));
         let stream = get_stream_handle_from_write_req(write_req);
-        log(debug, fmt!{"CLIENT on_write_complete_cb: tcp:%d write_handle:%d",
-            stream as int, write_req as int});
+        log(debug, fmt!("CLIENT on_write_complete_cb: tcp:%d write_handle:%d",
+            stream as int, write_req as int));
         let result = read_start(stream, on_alloc_cb, on_read_cb);
-        log(debug, fmt!{"CLIENT ending on_write_complete_cb .. status: %d",
-                         result as int});
+        log(debug, fmt!("CLIENT ending on_write_complete_cb .. status: %d",
+                         result as int));
     }
 
     extern fn on_connect_cb(connect_req_ptr: *uv_connect_t,
                                  status: libc::c_int) unsafe {
-        log(debug, fmt!{"beginning on_connect_cb .. status: %d",
-                         status as int});
+        log(debug, fmt!("beginning on_connect_cb .. status: %d",
+                         status as int));
         let stream =
             get_stream_handle_from_connect_req(connect_req_ptr);
         if (status == 0i32) {
@@ -1087,14 +1087,14 @@ mod test {
                 connect_req_ptr as *libc::c_void)
                 as *request_wrapper;
             let write_handle = (*client_data).write_req;
-            log(debug, fmt!{"on_connect_cb: tcp: %d write_hdl: %d",
-                            stream as int, write_handle as int});
+            log(debug, fmt!("on_connect_cb: tcp: %d write_hdl: %d",
+                            stream as int, write_handle as int));
             let write_result = write(write_handle,
                               stream as *libc::c_void,
                               (*client_data).req_buf,
                               on_write_complete_cb);
-            log(debug, fmt!{"on_connect_cb: write() status: %d",
-                             write_result as int});
+            log(debug, fmt!("on_connect_cb: write() status: %d",
+                             write_result as int));
         }
         else {
             let test_loop = get_loop_for_uv_handle(
@@ -1121,7 +1121,7 @@ mod test {
         // data field in our uv_connect_t struct
         let req_str_bytes = str::bytes(req_str);
         let req_msg_ptr: *u8 = vec::unsafe::to_ptr(req_str_bytes);
-        log(debug, fmt!{"req_msg ptr: %u", req_msg_ptr as uint});
+        log(debug, fmt!("req_msg ptr: %u", req_msg_ptr as uint));
         let req_msg = ~[
             buf_init(req_msg_ptr, vec::len(req_str_bytes))
         ];
@@ -1129,9 +1129,9 @@ mod test {
         // this to C..
         let write_handle = write_t();
         let write_handle_ptr = ptr::addr_of(write_handle);
-        log(debug, fmt!{"tcp req: tcp stream: %d write_handle: %d",
+        log(debug, fmt!("tcp req: tcp stream: %d write_handle: %d",
                          tcp_handle_ptr as int,
-                         write_handle_ptr as int});
+                         write_handle_ptr as int));
         let client_data = { writer_handle: write_handle_ptr,
                     req_buf: ptr::addr_of(req_msg),
                     read_chan: client_chan };
@@ -1145,12 +1145,12 @@ mod test {
             let addr = ip4_addr(ip, port);
             // FIXME ref #2064
             let addr_ptr = ptr::addr_of(addr);
-            log(debug, fmt!{"after build addr in rust. port: %u",
-                             addr.sin_port as uint});
+            log(debug, fmt!("after build addr in rust. port: %u",
+                             addr.sin_port as uint));
 
             // this should set up the connection request..
-            log(debug, fmt!{"b4 call tcp_connect connect cb: %u ",
-                            on_connect_cb as uint});
+            log(debug, fmt!("b4 call tcp_connect connect cb: %u ",
+                            on_connect_cb as uint));
             let tcp_connect_result = tcp_connect(
                 connect_req_ptr, tcp_handle_ptr,
                 addr_ptr, on_connect_cb);
@@ -1181,8 +1181,8 @@ mod test {
     }
 
     extern fn server_after_close_cb(handle: *libc::c_void) unsafe {
-        log(debug, fmt!{"SERVER server stream closed, should exit.. h: %?",
-                   handle});
+        log(debug, fmt!("SERVER server stream closed, should exit.. h: %?",
+                   handle));
     }
 
     extern fn client_stream_after_close_cb(handle: *libc::c_void)
@@ -1210,15 +1210,15 @@ mod test {
         let nread = nread as int;
         if (nread > 0) {
             // we have data
-            log(debug, fmt!{"SERVER read: data! nread: %d", nread});
+            log(debug, fmt!("SERVER read: data! nread: %d", nread));
 
             // pull out the contents of the write from the client
             let buf_base = get_base_from_buf(buf);
             let buf_len = get_len_from_buf(buf) as uint;
-            log(debug, fmt!{"SERVER buf base: %u, len: %u, nread: %d",
+            log(debug, fmt!("SERVER buf base: %u, len: %u, nread: %d",
                             buf_base as uint,
                             buf_len as uint,
-                            nread});
+                            nread));
             let bytes = vec::unsafe::from_buf(buf_base, buf_len);
             let request_str = str::from_bytes(bytes);
 
@@ -1238,8 +1238,8 @@ mod test {
                     client_stream_ptr as *libc::c_void,
                     (*client_data).server_resp_buf,
                     after_server_resp_write);
-                log(debug, fmt!{"SERVER: resp write result: %d",
-                            write_result as int});
+                log(debug, fmt!("SERVER: resp write result: %d",
+                            write_result as int));
                 if (write_result != 0i32) {
                     log(debug, ~"bad result for server resp write()");
                     log(debug, get_last_err_info(
@@ -1273,8 +1273,8 @@ mod test {
                                server_stream_ptr as *libc::c_void);
         if status != 0i32 {
             let err_msg = get_last_err_info(test_loop);
-            log(debug, fmt!{"server_connect_cb: non-zero status: %?",
-                         err_msg});
+            log(debug, fmt!("server_connect_cb: non-zero status: %?",
+                         err_msg));
             return;
         }
         let server_data = get_data_for_uv_handle(
@@ -1301,20 +1301,20 @@ mod test {
                     log(debug, ~"successful server read start");
                 }
                 else {
-                    log(debug, fmt!{"server_connection_cb: bad read:%d",
-                                    read_result as int});
+                    log(debug, fmt!("server_connection_cb: bad read:%d",
+                                    read_result as int));
                     assert false;
                 }
             }
             else {
-                log(debug, fmt!{"server_connection_cb: bad accept: %d",
-                            accept_result as int});
+                log(debug, fmt!("server_connection_cb: bad accept: %d",
+                            accept_result as int));
                 assert false;
             }
         }
         else {
-            log(debug, fmt!{"server_connection_cb: bad client init: %d",
-                        client_init_result as int});
+            log(debug, fmt!("server_connection_cb: bad client init: %d",
+                        client_init_result as int));
             assert false;
         }
     }
@@ -1333,8 +1333,8 @@ mod test {
     };
 
     extern fn async_close_cb(handle: *libc::c_void) {
-        log(debug, fmt!{"SERVER: closing async cb... h: %?",
-                   handle});
+        log(debug, fmt!("SERVER: closing async cb... h: %?",
+                   handle));
     }
 
     extern fn continue_async_cb(async_handle: *uv_async_t,
@@ -1369,7 +1369,7 @@ mod test {
 
         let resp_str_bytes = str::bytes(server_resp_msg);
         let resp_msg_ptr: *u8 = vec::unsafe::to_ptr(resp_str_bytes);
-        log(debug, fmt!{"resp_msg ptr: %u", resp_msg_ptr as uint});
+        log(debug, fmt!("resp_msg ptr: %u", resp_msg_ptr as uint));
         let resp_msg = ~[
             buf_init(resp_msg_ptr, vec::len(resp_str_bytes))
         ];
@@ -1428,26 +1428,26 @@ mod test {
                         log(debug, ~"server uv::run() has returned");
                     }
                     else {
-                        log(debug, fmt!{"uv_async_init failure: %d",
-                                async_result as int});
+                        log(debug, fmt!("uv_async_init failure: %d",
+                                async_result as int));
                         assert false;
                     }
                 }
                 else {
-                    log(debug, fmt!{"non-zero result on uv_listen: %d",
-                                listen_result as int});
+                    log(debug, fmt!("non-zero result on uv_listen: %d",
+                                listen_result as int));
                     assert false;
                 }
             }
             else {
-                log(debug, fmt!{"non-zero result on uv_tcp_bind: %d",
-                            bind_result as int});
+                log(debug, fmt!("non-zero result on uv_tcp_bind: %d",
+                            bind_result as int));
                 assert false;
             }
         }
         else {
-            log(debug, fmt!{"non-zero result on uv_tcp_init: %d",
-                        tcp_init_result as int});
+            log(debug, fmt!("non-zero result on uv_tcp_init: %d",
+                        tcp_init_result as int));
             assert false;
         }
         loop_delete(test_loop);
@@ -1524,8 +1524,8 @@ mod test {
     fn test_uv_ll_struct_size_uv_tcp_t() {
         let foreign_handle_size = rustrt::rust_uv_helper_uv_tcp_t_size();
         let rust_handle_size = sys::size_of::<uv_tcp_t>();
-        let output = fmt!{"uv_tcp_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size};
+        let output = fmt!("uv_tcp_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1535,8 +1535,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_uv_connect_t_size();
         let rust_handle_size = sys::size_of::<uv_connect_t>();
-        let output = fmt!{"uv_connect_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size};
+        let output = fmt!("uv_connect_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1546,8 +1546,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_uv_buf_t_size();
         let rust_handle_size = sys::size_of::<uv_buf_t>();
-        let output = fmt!{"uv_buf_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size};
+        let output = fmt!("uv_buf_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1557,8 +1557,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_uv_write_t_size();
         let rust_handle_size = sys::size_of::<uv_write_t>();
-        let output = fmt!{"uv_write_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size};
+        let output = fmt!("uv_write_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1569,8 +1569,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_sockaddr_in_size();
         let rust_handle_size = sys::size_of::<sockaddr_in>();
-        let output = fmt!{"sockaddr_in -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size};
+        let output = fmt!("sockaddr_in -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1580,8 +1580,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_sockaddr_in6_size();
         let rust_handle_size = sys::size_of::<sockaddr_in6>();
-        let output = fmt!{"sockaddr_in6 -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size};
+        let output = fmt!("sockaddr_in6 -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
         // FIXME #1645 .. rust appears to pad structs to the nearest byte..?
         // .. can't get the uv::ll::sockaddr_in6 to == 28 :/
@@ -1595,8 +1595,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_addr_in_size();
         let rust_handle_size = sys::size_of::<addr_in>();
-        let output = fmt!{"addr_in -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size};
+        let output = fmt!("addr_in -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
         // FIXME #1645 .. see note above about struct padding
         assert (4u+foreign_handle_size as uint) == rust_handle_size;
@@ -1608,8 +1608,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_uv_async_t_size();
         let rust_handle_size = sys::size_of::<uv_async_t>();
-        let output = fmt!{"uv_async_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size};
+        let output = fmt!("uv_async_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1620,8 +1620,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_uv_timer_t_size();
         let rust_handle_size = sys::size_of::<uv_timer_t>();
-        let output = fmt!{"uv_timer_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size};
+        let output = fmt!("uv_timer_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1633,8 +1633,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_uv_getaddrinfo_t_size();
         let rust_handle_size = sys::size_of::<uv_getaddrinfo_t>();
-        let output = fmt!{"uv_getaddrinfo_t -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size};
+        let output = fmt!("uv_getaddrinfo_t -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }
@@ -1646,8 +1646,8 @@ mod test {
         let foreign_handle_size =
             rustrt::rust_uv_helper_addrinfo_size();
         let rust_handle_size = sys::size_of::<addrinfo>();
-        let output = fmt!{"addrinfo -- foreign: %u rust: %u",
-                          foreign_handle_size as uint, rust_handle_size};
+        let output = fmt!("addrinfo -- foreign: %u rust: %u",
+                          foreign_handle_size as uint, rust_handle_size);
         log(debug, output);
         assert foreign_handle_size as uint == rust_handle_size;
     }