Convert core::result to camel case

1 files changed, 27 insertions, 27 deletions

diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index 16598274986..9458aca8db4 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -85,7 +85,7 @@ enum ip_get_addr_err {
  * object in the case of failure
  */
 fn get_addr(++node: ~str, iotask: iotask)
-        -> result::result<~[ip_addr], ip_get_addr_err> {
+        -> result::Result<~[ip_addr], ip_get_addr_err> {
     do core::comm::listen |output_ch| {
         do str::as_buf(node) |node_ptr, len| unsafe {
             log(debug, fmt!("slice len %?", len));
@@ -108,7 +108,7 @@ fn get_addr(++node: ~str, iotask: iotask)
                     set_data_for_req(handle_ptr, handle_data_ptr);
                   }
                   _ => {
-                    output_ch.send(result::err(get_addr_unknown_error));
+                    output_ch.send(result::Err(get_addr_unknown_error));
                   }
                 }
             };
@@ -135,8 +135,8 @@ mod v4 {
      */
     fn parse_addr(ip: ~str) -> ip_addr {
         match try_parse_addr(ip) {
-          result::ok(addr) => copy(addr),
-          result::err(err_data) => fail err_data.err_msg
+          result::Ok(addr) => copy(addr),
+          result::Err(err_data) => fail err_data.err_msg
         }
     }
     // the simple, old style numberic representation of
@@ -153,7 +153,7 @@ mod v4 {
             *((ptr::addr_of(self)) as *u32)
         }
     }
-    fn parse_to_ipv4_rep(ip: ~str) -> result::result<ipv4_rep, ~str> {
+    fn parse_to_ipv4_rep(ip: ~str) -> result::Result<ipv4_rep, ~str> {
         let parts = vec::map(str::split_char(ip, '.'), |s| {
             match uint::from_str(s) {
               Some(n) if n <= 255u => n,
@@ -161,23 +161,23 @@ 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,
+            result::Ok({a: parts[0] as u8, b: parts[1] as u8,
                         c: parts[2] as u8, d: parts[3] as u8})
         }
     }
-    fn try_parse_addr(ip: ~str) -> result::result<ip_addr,parse_addr_err> {
+    fn try_parse_addr(ip: ~str) -> result::Result<ip_addr,parse_addr_err> {
         unsafe {
             let INADDR_NONE = ll::get_INADDR_NONE();
             let ip_rep_result = parse_to_ipv4_rep(ip);
             if result::is_err(ip_rep_result) {
                 let err_str = result::get_err(ip_rep_result);
-                return result::err({err_msg: err_str})
+                return result::Err({err_msg: err_str})
             }
             // ipv4_rep.as_u32 is unsafe :/
             let input_is_inaddr_none =
@@ -190,15 +190,15 @@ mod v4 {
             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);
-                return result::err({err_msg: err_str})
+                return result::Err({err_msg: err_str})
             }
             if result::get(ref_ip_rep_result).as_u32() == INADDR_NONE &&
                  !input_is_inaddr_none {
-                return result::err(
+                return result::Err(
                     {err_msg: ~"uv_ip4_name produced invalid result."})
             }
             else {
-                result::ok(ipv4(copy(new_addr)))
+                result::Ok(ipv4(copy(new_addr)))
             }
         }
     }
@@ -221,11 +221,11 @@ mod v6 {
      */
     fn parse_addr(ip: ~str) -> ip_addr {
         match try_parse_addr(ip) {
-          result::ok(addr) => copy(addr),
-          result::err(err_data) => fail err_data.err_msg
+          result::Ok(addr) => copy(addr),
+          result::Err(err_data) => fail err_data.err_msg
         }
     }
-    fn try_parse_addr(ip: ~str) -> result::result<ip_addr,parse_addr_err> {
+    fn try_parse_addr(ip: ~str) -> result::Result<ip_addr,parse_addr_err> {
         unsafe {
             // need to figure out how to establish a parse failure..
             let new_addr = uv_ip6_addr(ip, 22);
@@ -235,18 +235,18 @@ mod v6 {
             // '::' appears to be uv_ip6_name() returns for bogus
             // parses..
             if  ip != ~"::" && reparsed_name == ~"::" {
-                result::err({err_msg:fmt!("failed to parse '%s'",
+                result::Err({err_msg:fmt!("failed to parse '%s'",
                                            ip)})
             }
             else {
-                result::ok(ipv6(new_addr))
+                result::Ok(ipv6(new_addr))
             }
         }
     }
 }
 
 type get_addr_data = {
-    output_ch: comm::Chan<result::result<~[ip_addr],ip_get_addr_err>>
+    output_ch: comm::Chan<result::Result<~[ip_addr],ip_get_addr_err>>
 };
 
 extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
@@ -272,7 +272,7 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
                     log(debug, ~"curr_addr is not of family AF_INET or "+
                         ~"AF_INET6. Error.");
                     (*handle_data).output_ch.send(
-                        result::err(get_addr_unknown_error));
+                        result::Err(get_addr_unknown_error));
                     break;
                 };
                 out_vec += ~[new_ip_addr];
@@ -289,18 +289,18 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
             }
             log(debug, fmt!("successful process addrinfo result, len: %?",
                             vec::len(out_vec)));
-            (*handle_data).output_ch.send(result::ok(out_vec));
+            (*handle_data).output_ch.send(result::Ok(out_vec));
         }
         else {
             log(debug, ~"addrinfo pointer is NULL");
             (*handle_data).output_ch.send(
-                result::err(get_addr_unknown_error));
+                result::Err(get_addr_unknown_error));
         }
     }
     else {
         log(debug, ~"status != 0 error in get_addr_cb");
         (*handle_data).output_ch.send(
-            result::err(get_addr_unknown_error));
+            result::Err(get_addr_unknown_error));
     }
     if res != (ptr::null::<addrinfo>()) {
         uv_freeaddrinfo(res);
@@ -327,11 +327,11 @@ mod test {
     #[test]
     fn test_ip_ipv4_bad_parse() {
         match v4::try_parse_addr(~"b4df00d") {
-          result::err(err_info) => {
+          result::Err(err_info) => {
             log(debug, fmt!("got error as expected %?", err_info));
             assert true;
           }
-          result::ok(addr) => {
+          result::Ok(addr) => {
             fail fmt!("Expected failure, but got addr %?", addr);
           }
         }
@@ -340,11 +340,11 @@ mod test {
     #[ignore(target_os="win32")]
     fn test_ip_ipv6_bad_parse() {
         match v6::try_parse_addr(~"::,~2234k;") {
-          result::err(err_info) => {
+          result::Err(err_info) => {
             log(debug, fmt!("got error as expected %?", err_info));
             assert true;
           }
-          result::ok(addr) => {
+          result::Ok(addr) => {
             fail fmt!("Expected failure, but got addr %?", addr);
           }
         }