core: Name is_failure to is_err, is_success to is_ok

src/libcore/comm.rs

@@ -440,7 +440,7 @@ fn test_recv_chan_wrong_task() {
     let po = port();
     let ch = chan(po);
     send(ch, "flower");
-    assert result::is_failure(task::try {||
+    assert result::is_err(task::try {||
         recv_chan(ch)
     })
 }

src/libcore/priv.rs

@@ -232,5 +232,5 @@ fn test_weaken_task_fail() unsafe {
             fail;
         }
     };
-    assert result::is_failure(res);
+    assert result::is_err(res);
 }

src/libcore/result.rs

@@ -43,16 +43,16 @@ pure fn get_err<T, U: copy>(res: result<T, U>) -> U {
 }
 
 #[doc = "Returns true if the result is `ok`"]
-pure fn is_success<T, U>(res: result<T, U>) -> bool {
+pure fn is_ok<T, U>(res: result<T, U>) -> bool {
     alt res {
       ok(_) { true }
       err(_) { false }
     }
 }
 
-#[doc = "Returns true if the result is `error`"]
-pure fn is_failure<T, U>(res: result<T, U>) -> bool {
-    !is_success(res)
+#[doc = "Returns true if the result is `err`"]
+pure fn is_err<T, U>(res: result<T, U>) -> bool {
+    !is_ok(res)
 }
 
 #[doc = "
@@ -181,9 +181,9 @@ fn map_err<T: copy, E, F: copy>(res: result<T, E>, op: fn(E) -> F)
 }
 
 impl extensions<T, E> for result<T, E> {
-    fn is_success() -> bool { is_success(self) }
+    fn is_ok() -> bool { is_ok(self) }
 
-    fn is_failure() -> bool { is_failure(self) }
+    fn is_err() -> bool { is_err(self) }
 
     fn iter(f: fn(T)) {
         alt self {

src/libstd/net_tcp.rs

@@ -813,7 +813,7 @@ fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint)
     log(debug, "starting tcp::read");
     let iotask = (*socket_data).iotask;
     let rs_result = read_start_common_impl(socket_data);
-    if result::is_failure(rs_result) {
+    if result::is_err(rs_result) {
         let err_data = result::get_err(rs_result);
         result::err(err_data)
     }
@@ -1424,7 +1424,7 @@ mod test {
 
                         let accept_result = accept(new_conn);
                         log(debug, "SERVER: after accept()");
-                        if result::is_failure(accept_result) {
+                        if result::is_err(accept_result) {
                             log(debug, "SERVER: error accept connection");
                             let err_data = result::get_err(accept_result);
                             comm::send(kill_ch, some(err_data));
@@ -1465,7 +1465,7 @@ mod test {
                 log(debug, "SERVER: recv'd on cont_ch..leaving listen cb");
             });
             // err check on listen_result
-            if result::is_failure(listen_result) {
+            if result::is_err(listen_result) {
                 let err_data = result::get_err(listen_result);
                 log(debug, #fmt("SERVER: exited abnormally name %s msg %s",
                                 err_data.err_name, err_data.err_msg));
@@ -1486,7 +1486,7 @@ mod test {
             let server_ip_addr = ip::v4::parse_addr(server_ip);
             let new_listener_result =
                 new_listener(server_ip_addr, server_port, 128u, iotask);
-            if result::is_failure(new_listener_result) {
+            if result::is_err(new_listener_result) {
                 let err_data = result::get_err(new_listener_result);
                 log(debug, #fmt("SERVER: exited abnormally name %s msg %s",
                                 err_data.err_name, err_data.err_msg));
@@ -1498,7 +1498,7 @@ mod test {
             // in a loop {}, but we're just going to take a single
             // client.. get their req, write a resp and then exit
             let new_conn_result = server_port.recv();
-            if result::is_failure(new_conn_result) {
+            if result::is_err(new_conn_result) {
                 let err_data = result::get_err(new_conn_result);
                 log(debug, #fmt("SERVER: exited abnormally name %s msg %s",
                                 err_data.err_name, err_data.err_msg));
@@ -1535,7 +1535,7 @@ mod test {
 
         log(debug, "CLIENT: starting..");
         let connect_result = connect(server_ip_addr, server_port, iotask);
-        if result::is_failure(connect_result) {
+        if result::is_err(connect_result) {
             log(debug, "CLIENT: failed to connect");
             let err_data = result::get_err(connect_result);
             log(debug, #fmt("CLIENT: connect err name: %s msg: %s",
@@ -1547,7 +1547,7 @@ mod test {
             let resp_bytes = str::bytes(resp);
             tcp_write_single(sock, resp_bytes);
             let read_result = sock.read(0u);
-            if read_result.is_failure() {
+            if read_result.is_err() {
                 log(debug, "CLIENT: failure to read");
                 ""
             }
@@ -1564,7 +1564,7 @@ mod test {
     fn tcp_write_single(sock: tcp_socket, val: [u8]) {
         let write_result_future = sock.write_future(val);
         let write_result = write_result_future.get();
-        if result::is_failure(write_result) {
+        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",

src/test/run-pass/cleanup-copy-mode.rs

@@ -2,7 +2,7 @@
 fn adder(+x: @int, +y: @int) -> int { ret *x + *y; }
 fn failer() -> @int { fail; }
 fn main() {
-    assert(result::is_failure(task::try {||
+    assert(result::is_err(task::try {||
         adder(@2, failer()); ()
     }));
 }