11 files changed, 101 insertions, 101 deletions

diff --git a/src/libstd/fmt/mod.rs b/src/libstd/fmt/mod.rs
index 354b812f675..9c70d34cc0f 100644
--- a/src/libstd/fmt/mod.rs
+++ b/src/libstd/fmt/mod.rs
@@ -702,7 +702,7 @@ pub unsafe fn write_unsafe(output: &mut io::Writer,
         curarg: args.iter(),
     };
     for piece in fmt.iter() {
-        if_ok!(formatter.run(piece, None));
+        try!(formatter.run(piece, None));
     }
     Ok(())
 }
@@ -859,13 +859,13 @@ impl<'a> Formatter<'a> {
                 for s in selectors.iter() {
                     if s.selector == value {
                         for piece in s.result.iter() {
-                            if_ok!(self.run(piece, Some(value)));
+                            try!(self.run(piece, Some(value)));
                         }
                         return Ok(());
                     }
                 }
                 for piece in default.iter() {
-                    if_ok!(self.run(piece, Some(value)));
+                    try!(self.run(piece, Some(value)));
                 }
                 Ok(())
             }
@@ -876,7 +876,7 @@ impl<'a> Formatter<'a> {
         ::uint::to_str_bytes(value, 10, |buf| {
             let valuestr = str::from_utf8(buf).unwrap();
             for piece in pieces.iter() {
-                if_ok!(self.run(piece, Some(valuestr)));
+                try!(self.run(piece, Some(valuestr)));
             }
             Ok(())
         })
@@ -917,12 +917,12 @@ impl<'a> Formatter<'a> {
         let sign = |this: &mut Formatter| {
             if !signprinted {
                 if this.flags & 1 << (FlagSignPlus as uint) != 0 && positive {
-                    if_ok!(this.buf.write(['+' as u8]));
+                    try!(this.buf.write(['+' as u8]));
                 } else if !positive {
-                    if_ok!(this.buf.write(['-' as u8]));
+                    try!(this.buf.write(['-' as u8]));
                 }
                 if this.flags & 1 << (FlagAlternate as uint) != 0 {
-                    if_ok!(this.buf.write(alternate_prefix.as_bytes()));
+                    try!(this.buf.write(alternate_prefix.as_bytes()));
                 }
                 signprinted = true;
             }
@@ -939,7 +939,7 @@ impl<'a> Formatter<'a> {
             Some(min) => {
                 if self.flags & 1 << (FlagSignAwareZeroPad as uint) != 0 {
                     self.fill = '0';
-                    if_ok!(sign(self));
+                    try!(sign(self));
                 }
                 self.with_padding(min - actual_len, parse::AlignRight, |me| {
                     emit(me)
@@ -1011,15 +1011,15 @@ impl<'a> Formatter<'a> {
             parse::AlignLeft | parse::AlignRight => self.align
         };
         if align == parse::AlignLeft {
-            if_ok!(f(self));
+            try!(f(self));
         }
         let mut fill = [0u8, ..4];
         let len = self.fill.encode_utf8(fill);
         for _ in range(0, padding) {
-            if_ok!(self.buf.write(fill.slice_to(len)));
+            try!(self.buf.write(fill.slice_to(len)));
         }
         if align == parse::AlignRight {
-            if_ok!(f(self));
+            try!(f(self));
         }
         Ok(())
     }
diff --git a/src/libstd/hashmap.rs b/src/libstd/hashmap.rs
index 1ac599d0654..5d4db106728 100644
--- a/src/libstd/hashmap.rs
+++ b/src/libstd/hashmap.rs
@@ -599,15 +599,15 @@ impl<K:Hash + Eq + Clone,V:Clone> Clone for HashMap<K,V> {
 
 impl<A: fmt::Show + Hash + Eq, B: fmt::Show> fmt::Show for HashMap<A, B> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if_ok!(write!(f.buf, r"\{"))
+        try!(write!(f.buf, r"\{"))
         let mut first = true;
         for (key, value) in self.iter() {
             if first {
                 first = false;
             } else {
-                if_ok!(write!(f.buf, ", "));
+                try!(write!(f.buf, ", "));
             }
-            if_ok!(write!(f.buf, "{}: {}", *key, *value));
+            try!(write!(f.buf, "{}: {}", *key, *value));
         }
         write!(f.buf, r"\}")
     }
@@ -877,15 +877,15 @@ impl<T:Hash + Eq + Clone> Clone for HashSet<T> {
 
 impl<A: fmt::Show + Hash + Eq> fmt::Show for HashSet<A> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if_ok!(write!(f.buf, r"\{"))
+        try!(write!(f.buf, r"\{"))
         let mut first = true;
         for x in self.iter() {
             if first {
                 first = false;
             } else {
-                if_ok!(write!(f.buf, ", "));
+                try!(write!(f.buf, ", "));
             }
-            if_ok!(write!(f.buf, "{}", *x));
+            try!(write!(f.buf, "{}", *x));
         }
         write!(f.buf, r"\}")
     }
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 227f3a0a083..df2a800c292 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -88,7 +88,7 @@ impl<R: Reader> BufferedReader<R> {
 impl<R: Reader> Buffer for BufferedReader<R> {
     fn fill<'a>(&'a mut self) -> IoResult<&'a [u8]> {
         if self.pos == self.cap {
-            self.cap = if_ok!(self.inner.read(self.buf));
+            self.cap = try!(self.inner.read(self.buf));
             self.pos = 0;
         }
         Ok(self.buf.slice(self.pos, self.cap))
@@ -103,7 +103,7 @@ impl<R: Reader> Buffer for BufferedReader<R> {
 impl<R: Reader> Reader for BufferedReader<R> {
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
         let nread = {
-            let available = if_ok!(self.fill());
+            let available = try!(self.fill());
             let nread = cmp::min(available.len(), buf.len());
             vec::bytes::copy_memory(buf, available.slice_to(nread));
             nread
@@ -182,7 +182,7 @@ impl<W: Writer> BufferedWriter<W> {
 impl<W: Writer> Writer for BufferedWriter<W> {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
         if self.pos + buf.len() > self.buf.len() {
-            if_ok!(self.flush_buf());
+            try!(self.flush_buf());
         }
 
         if buf.len() > self.buf.len() {
@@ -233,9 +233,9 @@ impl<W: Writer> Writer for LineBufferedWriter<W> {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
         match buf.iter().rposition(|&b| b == '\n' as u8) {
             Some(i) => {
-                if_ok!(self.inner.write(buf.slice_to(i + 1)));
-                if_ok!(self.inner.flush());
-                if_ok!(self.inner.write(buf.slice_from(i + 1)));
+                try!(self.inner.write(buf.slice_to(i + 1)));
+                try!(self.inner.flush());
+                try!(self.inner.write(buf.slice_from(i + 1)));
                 Ok(())
             }
             None => self.inner.write(buf),
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index cd6c6763f66..7f2af92b078 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -339,8 +339,8 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
         })
     }
 
-    let mut reader = if_ok!(File::open(from));
-    let mut writer = if_ok!(File::create(to));
+    let mut reader = try!(File::open(from));
+    let mut writer = try!(File::create(to));
     let mut buf = [0, ..io::DEFAULT_BUF_SIZE];
 
     loop {
@@ -349,10 +349,10 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
             Err(ref e) if e.kind == io::EndOfFile => { break }
             Err(e) => return Err(e)
         };
-        if_ok!(writer.write(buf.slice_to(amt)));
+        try!(writer.write(buf.slice_to(amt)));
     }
 
-    chmod(to, if_ok!(from.stat()).perm)
+    chmod(to, try!(from.stat()).perm)
 }
 
 /// Changes the permission mode bits found on a file or a directory. This
@@ -460,10 +460,10 @@ pub fn rmdir(path: &Path) -> IoResult<()> {
 /// // one possible implementation of fs::walk_dir only visiting files
 /// fn visit_dirs(dir: &Path, cb: |&Path|) -> io::IoResult<()> {
 ///     if dir.is_dir() {
-///         let contents = if_ok!(fs::readdir(dir));
+///         let contents = try!(fs::readdir(dir));
 ///         for entry in contents.iter() {
 ///             if entry.is_dir() {
-///                 if_ok!(visit_dirs(entry, |p| cb(p)));
+///                 try!(visit_dirs(entry, |p| cb(p)));
 ///             } else {
 ///                 cb(entry);
 ///             }
@@ -490,7 +490,7 @@ pub fn readdir(path: &Path) -> IoResult<~[Path]> {
 /// rooted at `path`. The path given will not be iterated over, and this will
 /// perform iteration in a top-down order.
 pub fn walk_dir(path: &Path) -> IoResult<Directories> {
-    Ok(Directories { stack: if_ok!(readdir(path)) })
+    Ok(Directories { stack: try!(readdir(path)) })
 }
 
 /// An iterator which walks over a directory
@@ -529,7 +529,7 @@ pub fn mkdir_recursive(path: &Path, mode: FilePermission) -> IoResult<()> {
         return Ok(())
     }
     if path.filename().is_some() {
-        if_ok!(mkdir_recursive(&path.dir_path(), mode));
+        try!(mkdir_recursive(&path.dir_path(), mode));
     }
     mkdir(path, mode)
 }
@@ -542,12 +542,12 @@ pub fn mkdir_recursive(path: &Path, mode: FilePermission) -> IoResult<()> {
 /// This function will return an `Err` value if an error happens. See
 /// `file::unlink` and `fs::readdir` for possible error conditions.
 pub fn rmdir_recursive(path: &Path) -> IoResult<()> {
-    let children = if_ok!(readdir(path));
+    let children = try!(readdir(path));
     for child in children.iter() {
         if child.is_dir() {
-            if_ok!(rmdir_recursive(child));
+            try!(rmdir_recursive(child));
         } else {
-            if_ok!(unlink(child));
+            try!(unlink(child));
         }
     }
     // Directory should now be empty
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index ff61ef15fa5..49c37b4520f 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -113,7 +113,7 @@ impl Writer for MemWriter {
 impl Seek for MemWriter {
     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
-        let new = if_ok!(combine(style, self.pos, self.buf.len(), pos));
+        let new = try!(combine(style, self.pos, self.buf.len(), pos));
         self.pos = new as uint;
         Ok(())
     }
@@ -183,7 +183,7 @@ impl Reader for MemReader {
 impl Seek for MemReader {
     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
-        let new = if_ok!(combine(style, self.pos, self.buf.len(), pos));
+        let new = try!(combine(style, self.pos, self.buf.len(), pos));
         self.pos = new as uint;
         Ok(())
     }
@@ -253,7 +253,7 @@ impl<'a> Writer for BufWriter<'a> {
 impl<'a> Seek for BufWriter<'a> {
     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
-        let new = if_ok!(combine(style, self.pos, self.buf.len(), pos));
+        let new = try!(combine(style, self.pos, self.buf.len(), pos));
         self.pos = new as uint;
         Ok(())
     }
@@ -313,7 +313,7 @@ impl<'a> Reader for BufReader<'a> {
 impl<'a> Seek for BufReader<'a> {
     fn tell(&self) -> IoResult<u64> { Ok(self.pos as u64) }
     fn seek(&mut self, pos: i64, style: SeekStyle) -> IoResult<()> {
-        let new = if_ok!(combine(style, self.pos, self.buf.len(), pos));
+        let new = try!(combine(style, self.pos, self.buf.len(), pos));
         self.pos = new as uint;
         Ok(())
     }
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 2eadf9a7f4f..db5ee09fa14 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -365,7 +365,7 @@ pub struct IoError {
 
 impl fmt::Show for IoError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        if_ok!(fmt.buf.write_str(self.desc));
+        try!(fmt.buf.write_str(self.desc));
         match self.detail {
             Some(ref s) => write!(fmt.buf, " ({})", *s),
             None => Ok(())
@@ -581,7 +581,7 @@ pub trait Reader {
         let mut pos = 0;
         let mut i = nbytes;
         while i > 0 {
-            val += (if_ok!(self.read_u8()) as u64) << pos;
+            val += (try!(self.read_u8()) as u64) << pos;
             pos += 8;
             i -= 1;
         }
@@ -605,7 +605,7 @@ pub trait Reader {
         let mut i = nbytes;
         while i > 0 {
             i -= 1;
-            val += (if_ok!(self.read_u8()) as u64) << i * 8;
+            val += (try!(self.read_u8()) as u64) << i * 8;
         }
         Ok(val)
     }
@@ -1191,7 +1191,7 @@ pub trait Buffer: Reader {
     /// This function will also return error if the stream does not contain a
     /// valid utf-8 encoded codepoint as the next few bytes in the stream.
     fn read_char(&mut self) -> IoResult<char> {
-        let first_byte = if_ok!(self.read_byte());
+        let first_byte = try!(self.read_byte());
         let width = str::utf8_char_width(first_byte);
         if width == 1 { return Ok(first_byte as char) }
         if width == 0 { return Err(standard_error(InvalidInput)) } // not utf8
@@ -1199,7 +1199,7 @@ pub trait Buffer: Reader {
         {
             let mut start = 1;
             while start < width {
-                match if_ok!(self.read(buf.mut_slice(start, width))) {
+                match try!(self.read(buf.mut_slice(start, width))) {
                     n if n == width - start => break,
                     n if n < width - start => { start += n; }
                     _ => return Err(standard_error(InvalidInput)),
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index 79ae9faf629..acaffd00665 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -189,7 +189,7 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
             Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
             Err(e) => return Err(e),
         };
-        if_ok!(w.write(buf.slice_to(len)));
+        try!(w.write(buf.slice_to(len)));
     }
 }
 
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index 34b33003786..3e8a4d24f3e 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -355,6 +355,6 @@ macro_rules! local_data_key(
 /// error if the value of the expression is `Err`. For more information, see
 /// `std::io`.
 #[macro_export]
-macro_rules! if_ok(
+macro_rules! try(
     ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
 )
diff --git a/src/libstd/repr.rs b/src/libstd/repr.rs
index fb2053ddaf6..d367aaa6dc4 100644
--- a/src/libstd/repr.rs
+++ b/src/libstd/repr.rs
@@ -32,7 +32,7 @@ use vec::OwnedVector;
 use unstable::intrinsics::{Disr, Opaque, TyDesc, TyVisitor, get_tydesc, visit_tydesc};
 use unstable::raw;
 
-macro_rules! if_ok( ($me:expr, $e:expr) => (
+macro_rules! try( ($me:expr, $e:expr) => (
     match $e {
         Ok(()) => {},
         Err(e) => { $me.last_err = Some(e); return false; }
@@ -181,23 +181,23 @@ impl<'a> ReprVisitor<'a> {
     #[inline]
     pub fn write<T:Repr>(&mut self) -> bool {
         self.get(|this, v:&T| {
-            if_ok!(this, v.write_repr(this.writer));
+            try!(this, v.write_repr(this.writer));
             true
         })
     }
 
     pub fn write_escaped_slice(&mut self, slice: &str) -> bool {
-        if_ok!(self, self.writer.write(['"' as u8]));
+        try!(self, self.writer.write(['"' as u8]));
         for ch in slice.chars() {
             if !self.write_escaped_char(ch, true) { return false }
         }
-        if_ok!(self, self.writer.write(['"' as u8]));
+        try!(self, self.writer.write(['"' as u8]));
         true
     }
 
     pub fn write_mut_qualifier(&mut self, mtbl: uint) -> bool {
         if mtbl == 0 {
-            if_ok!(self, self.writer.write("mut ".as_bytes()));
+            try!(self, self.writer.write("mut ".as_bytes()));
         } else if mtbl == 1 {
             // skip, this is ast::m_imm
         } else {
@@ -209,7 +209,7 @@ impl<'a> ReprVisitor<'a> {
     pub fn write_vec_range(&mut self, ptr: *(), len: uint, inner: *TyDesc) -> bool {
         let mut p = ptr as *u8;
         let (sz, al) = unsafe { ((*inner).size, (*inner).align) };
-        if_ok!(self, self.writer.write(['[' as u8]));
+        try!(self, self.writer.write(['[' as u8]));
         let mut first = true;
         let mut left = len;
         // unit structs have 0 size, and don't loop forever.
@@ -218,13 +218,13 @@ impl<'a> ReprVisitor<'a> {
             if first {
                 first = false;
             } else {
-                if_ok!(self, self.writer.write(", ".as_bytes()));
+                try!(self, self.writer.write(", ".as_bytes()));
             }
             self.visit_ptr_inner(p as *u8, inner);
             p = align(unsafe { p.offset(sz as int) as uint }, al) as *u8;
             left -= dec;
         }
-        if_ok!(self, self.writer.write([']' as u8]));
+        try!(self, self.writer.write([']' as u8]));
         true
     }
 
@@ -233,7 +233,7 @@ impl<'a> ReprVisitor<'a> {
     }
 
     fn write_escaped_char(&mut self, ch: char, is_str: bool) -> bool {
-        if_ok!(self, match ch {
+        try!(self, match ch {
             '\t' => self.writer.write("\\t".as_bytes()),
             '\r' => self.writer.write("\\r".as_bytes()),
             '\n' => self.writer.write("\\n".as_bytes()),
@@ -266,7 +266,7 @@ impl<'a> ReprVisitor<'a> {
 
 impl<'a> TyVisitor for ReprVisitor<'a> {
     fn visit_bot(&mut self) -> bool {
-        if_ok!(self, self.writer.write("!".as_bytes()));
+        try!(self, self.writer.write("!".as_bytes()));
         true
     }
     fn visit_nil(&mut self) -> bool { self.write::<()>() }
@@ -288,9 +288,9 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
 
     fn visit_char(&mut self) -> bool {
         self.get::<char>(|this, &ch| {
-            if_ok!(this, this.writer.write(['\'' as u8]));
+            try!(this, this.writer.write(['\'' as u8]));
             if !this.write_escaped_char(ch, false) { return false }
-            if_ok!(this, this.writer.write(['\'' as u8]));
+            try!(this, this.writer.write(['\'' as u8]));
             true
         })
     }
@@ -301,7 +301,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
 
     fn visit_estr_uniq(&mut self) -> bool {
         self.get::<~str>(|this, s| {
-            if_ok!(this, this.writer.write(['~' as u8]));
+            try!(this, this.writer.write(['~' as u8]));
             this.write_escaped_slice(*s)
         })
     }
@@ -315,7 +315,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
                         _align: uint) -> bool { fail!(); }
 
     fn visit_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
-        if_ok!(self, self.writer.write(['@' as u8]));
+        try!(self, self.writer.write(['@' as u8]));
         self.write_mut_qualifier(mtbl);
         self.get::<&raw::Box<()>>(|this, b| {
             let p = &b.data as *() as *u8;
@@ -324,7 +324,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
     }
 
     fn visit_uniq(&mut self, _mtbl: uint, inner: *TyDesc) -> bool {
-        if_ok!(self, self.writer.write(['~' as u8]));
+        try!(self, self.writer.write(['~' as u8]));
         self.get::<*u8>(|this, b| {
             this.visit_ptr_inner(*b, inner)
         })
@@ -332,15 +332,15 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
 
     fn visit_ptr(&mut self, mtbl: uint, _inner: *TyDesc) -> bool {
         self.get::<*u8>(|this, p| {
-            if_ok!(this, write!(this.writer, "({} as *", *p));
+            try!(this, write!(this.writer, "({} as *", *p));
             this.write_mut_qualifier(mtbl);
-            if_ok!(this, this.writer.write("())".as_bytes()));
+            try!(this, this.writer.write("())".as_bytes()));
             true
         })
     }
 
     fn visit_rptr(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
-        if_ok!(self, self.writer.write(['&' as u8]));
+        try!(self, self.writer.write(['&' as u8]));
         self.write_mut_qualifier(mtbl);
         self.get::<*u8>(|this, p| {
             this.visit_ptr_inner(*p, inner)
@@ -358,7 +358,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
 
     fn visit_evec_box(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
         self.get::<&raw::Box<raw::Vec<()>>>(|this, b| {
-            if_ok!(this, this.writer.write(['@' as u8]));
+            try!(this, this.writer.write(['@' as u8]));
             this.write_mut_qualifier(mtbl);
             this.write_unboxed_vec_repr(mtbl, &b.data, inner)
         })
@@ -366,14 +366,14 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
 
     fn visit_evec_uniq(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
         self.get::<&raw::Vec<()>>(|this, b| {
-            if_ok!(this, this.writer.write(['~' as u8]));
+            try!(this, this.writer.write(['~' as u8]));
             this.write_unboxed_vec_repr(mtbl, *b, inner)
         })
     }
 
     fn visit_evec_slice(&mut self, mtbl: uint, inner: *TyDesc) -> bool {
         self.get::<raw::Slice<()>>(|this, s| {
-            if_ok!(this, this.writer.write(['&' as u8]));
+            try!(this, this.writer.write(['&' as u8]));
             this.write_mut_qualifier(mtbl);
             let size = unsafe {
                 if (*inner).size == 0 { 1 } else { (*inner).size }
@@ -392,36 +392,36 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
 
     fn visit_enter_rec(&mut self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool {
-        if_ok!(self, self.writer.write(['{' as u8]));
+        try!(self, self.writer.write(['{' as u8]));
         true
     }
 
     fn visit_rec_field(&mut self, i: uint, name: &str,
                        mtbl: uint, inner: *TyDesc) -> bool {
         if i != 0 {
-            if_ok!(self, self.writer.write(", ".as_bytes()));
+            try!(self, self.writer.write(", ".as_bytes()));
         }
         self.write_mut_qualifier(mtbl);
-        if_ok!(self, self.writer.write(name.as_bytes()));
-        if_ok!(self, self.writer.write(": ".as_bytes()));
+        try!(self, self.writer.write(name.as_bytes()));
+        try!(self, self.writer.write(": ".as_bytes()));
         self.visit_inner(inner);
         true
     }
 
     fn visit_leave_rec(&mut self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool {
-        if_ok!(self, self.writer.write(['}' as u8]));
+        try!(self, self.writer.write(['}' as u8]));
         true
     }
 
     fn visit_enter_class(&mut self, name: &str, named_fields: bool, n_fields: uint,
                          _sz: uint, _align: uint) -> bool {
-        if_ok!(self, self.writer.write(name.as_bytes()));
+        try!(self, self.writer.write(name.as_bytes()));
         if n_fields != 0 {
             if named_fields {
-                if_ok!(self, self.writer.write(['{' as u8]));
+                try!(self, self.writer.write(['{' as u8]));
             } else {
-                if_ok!(self, self.writer.write(['(' as u8]));
+                try!(self, self.writer.write(['(' as u8]));
             }
         }
         true
@@ -430,11 +430,11 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
     fn visit_class_field(&mut self, i: uint, name: &str, named: bool,
                          _mtbl: uint, inner: *TyDesc) -> bool {
         if i != 0 {
-            if_ok!(self, self.writer.write(", ".as_bytes()));
+            try!(self, self.writer.write(", ".as_bytes()));
         }
         if named {
-            if_ok!(self, self.writer.write(name.as_bytes()));
-            if_ok!(self, self.writer.write(": ".as_bytes()));
+            try!(self, self.writer.write(name.as_bytes()));
+            try!(self, self.writer.write(": ".as_bytes()));
         }
         self.visit_inner(inner);
         true
@@ -444,9 +444,9 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
                          _sz: uint, _align: uint) -> bool {
         if n_fields != 0 {
             if named_fields {
-                if_ok!(self, self.writer.write(['}' as u8]));
+                try!(self, self.writer.write(['}' as u8]));
             } else {
-                if_ok!(self, self.writer.write([')' as u8]));
+                try!(self, self.writer.write([')' as u8]));
             }
         }
         true
@@ -454,13 +454,13 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
 
     fn visit_enter_tup(&mut self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool {
-        if_ok!(self, self.writer.write(['(' as u8]));
+        try!(self, self.writer.write(['(' as u8]));
         true
     }
 
     fn visit_tup_field(&mut self, i: uint, inner: *TyDesc) -> bool {
         if i != 0 {
-            if_ok!(self, self.writer.write(", ".as_bytes()));
+            try!(self, self.writer.write(", ".as_bytes()));
         }
         self.visit_inner(inner);
         true
@@ -469,9 +469,9 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
     fn visit_leave_tup(&mut self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool {
         if _n_fields == 1 {
-            if_ok!(self, self.writer.write([',' as u8]));
+            try!(self, self.writer.write([',' as u8]));
         }
-        if_ok!(self, self.writer.write([')' as u8]));
+        try!(self, self.writer.write([')' as u8]));
         true
     }
 
@@ -507,9 +507,9 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
         }
 
         if write {
-            if_ok!(self, self.writer.write(name.as_bytes()));
+            try!(self, self.writer.write(name.as_bytes()));
             if n_fields > 0 {
-                if_ok!(self, self.writer.write(['(' as u8]));
+                try!(self, self.writer.write(['(' as u8]));
             }
         }
         true
@@ -523,7 +523,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
         match self.var_stk[self.var_stk.len() - 1] {
             Matched => {
                 if i != 0 {
-                    if_ok!(self, self.writer.write(", ".as_bytes()));
+                    try!(self, self.writer.write(", ".as_bytes()));
                 }
                 if ! self.visit_inner(inner) {
                     return false;
@@ -541,7 +541,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
         match self.var_stk[self.var_stk.len() - 1] {
             Matched => {
                 if n_fields > 0 {
-                    if_ok!(self, self.writer.write([')' as u8]));
+                    try!(self, self.writer.write([')' as u8]));
                 }
             }
             _ => ()
@@ -563,29 +563,29 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
 
     fn visit_enter_fn(&mut self, _purity: uint, _proto: uint,
                       _n_inputs: uint, _retstyle: uint) -> bool {
-        if_ok!(self, self.writer.write("fn(".as_bytes()));
+        try!(self, self.writer.write("fn(".as_bytes()));
         true
     }
 
     fn visit_fn_input(&mut self, i: uint, _mode: uint, inner: *TyDesc) -> bool {
         if i != 0 {
-            if_ok!(self, self.writer.write(", ".as_bytes()));
+            try!(self, self.writer.write(", ".as_bytes()));
         }
         let name = unsafe { (*inner).name };
-        if_ok!(self, self.writer.write(name.as_bytes()));
+        try!(self, self.writer.write(name.as_bytes()));
         true
     }
 
     fn visit_fn_output(&mut self, _retstyle: uint, variadic: bool,
                        inner: *TyDesc) -> bool {
         if variadic {
-            if_ok!(self, self.writer.write(", ...".as_bytes()));
+            try!(self, self.writer.write(", ...".as_bytes()));
         }
-        if_ok!(self, self.writer.write(")".as_bytes()));
+        try!(self, self.writer.write(")".as_bytes()));
         let name = unsafe { (*inner).name };
         if name != "()" {
-            if_ok!(self, self.writer.write(" -> ".as_bytes()));
-            if_ok!(self, self.writer.write(name.as_bytes()));
+            try!(self, self.writer.write(" -> ".as_bytes()));
+            try!(self, self.writer.write(name.as_bytes()));
         }
         true
     }
@@ -595,7 +595,7 @@ impl<'a> TyVisitor for ReprVisitor<'a> {
 
 
     fn visit_trait(&mut self, name: &str) -> bool {
-        if_ok!(self, self.writer.write(name.as_bytes()));
+        try!(self, self.writer.write(name.as_bytes()));
         true
     }
 
diff --git a/src/libstd/tuple.rs b/src/libstd/tuple.rs
index 7a81e69f30a..b0d51cba103 100644
--- a/src/libstd/tuple.rs
+++ b/src/libstd/tuple.rs
@@ -161,9 +161,9 @@ macro_rules! write_tuple {
         write!($buf, "({},)", *$x)
     );
     ($buf:expr, $hd:expr, $($tl:expr),+) => ({
-        if_ok!(write!($buf, "("));
-        if_ok!(write!($buf, "{}", *$hd));
-        $(if_ok!(write!($buf, ", {}", *$tl));)+
+        try!(write!($buf, "("));
+        try!(write!($buf, "{}", *$hd));
+        $(try!(write!($buf, ", {}", *$tl));)+
         write!($buf, ")")
     });
 }
diff --git a/src/libstd/vec.rs b/src/libstd/vec.rs
index d16ad54a25d..5a42df0a389 100644
--- a/src/libstd/vec.rs
+++ b/src/libstd/vec.rs
@@ -2645,15 +2645,15 @@ impl<A: DeepClone> DeepClone for ~[A] {
 
 impl<'a, T: fmt::Show> fmt::Show for &'a [T] {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        if_ok!(write!(f.buf, "["));
+        try!(write!(f.buf, "["));
         let mut is_first = true;
         for x in self.iter() {
             if is_first {
                 is_first = false;
             } else {
-                if_ok!(write!(f.buf, ", "));
+                try!(write!(f.buf, ", "));
             }
-            if_ok!(write!(f.buf, "{}", *x))
+            try!(write!(f.buf, "{}", *x))
         }
         write!(f.buf, "]")
     }