std: Camel case net modules

4 files changed, 256 insertions, 252 deletions

diff --git a/src/libstd/net_ip.rs b/src/libstd/net_ip.rs
index 67b40482402..a2bccef57e5 100644
--- a/src/libstd/net_ip.rs
+++ b/src/libstd/net_ip.rs
@@ -21,21 +21,21 @@ import get_data_for_req = uv::ll::get_data_for_req;
 import ll = uv::ll;
 import comm = core::comm;
 
-export ip_addr, parse_addr_err;
+export IpAddr, parse_addr_err;
 export format_addr;
 export v4, v6;
 export get_addr;
-export ipv4, ipv6;
+export Ipv4, Ipv6;
 
 /// An IP address
-enum ip_addr {
+enum IpAddr {
     /// An IPv4 address
-    ipv4(sockaddr_in),
-    ipv6(sockaddr_in6)
+    Ipv4(sockaddr_in),
+    Ipv6(sockaddr_in6)
 }
 
 /// Human-friendly feedback on why a parse_addr attempt failed
-type parse_addr_err = {
+type ParseAddrErr = {
     err_msg: ~str
 };
 
@@ -46,16 +46,16 @@ type parse_addr_err = {
  *
  * * ip - a `std::net::ip::ip_addr`
  */
-fn format_addr(ip: ip_addr) -> ~str {
+fn format_addr(ip: IpAddr) -> ~str {
     match ip {
-      ipv4(addr) =>  unsafe {
+      Ipv4(addr) =>  unsafe {
         let result = uv_ip4_name(&addr);
         if result == ~"" {
             fail ~"failed to convert inner sockaddr_in address to str"
         }
         result
       },
-      ipv6(addr) => unsafe {
+      Ipv6(addr) => unsafe {
         let result = uv_ip6_name(&addr);
         if result == ~"" {
             fail ~"failed to convert inner sockaddr_in address to str"
@@ -66,8 +66,8 @@ fn format_addr(ip: ip_addr) -> ~str {
 }
 
 /// Represents errors returned from `net::ip::get_addr()`
-enum ip_get_addr_err {
-    get_addr_unknown_error
+enum IpGetAddrErr {
+    GetAddrUnknownError
 }
 
 /**
@@ -85,13 +85,13 @@ 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<~[IpAddr], IpGetAddrErr> {
     do core::comm::listen |output_ch| {
         do str::as_buf(node) |node_ptr, len| unsafe {
             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 = {
+            let handle_data: GetAddrData = {
                 output_ch: output_ch
             };
             let handle_data_ptr = ptr::addr_of(handle_data);
@@ -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(GetAddrUnknownError));
                   }
                 }
             };
@@ -133,7 +133,7 @@ mod v4 {
      *
      * * an `ip_addr` of the `ipv4` variant
      */
-    fn parse_addr(ip: ~str) -> ip_addr {
+    fn parse_addr(ip: ~str) -> IpAddr {
         match try_parse_addr(ip) {
           result::Ok(addr) => copy(addr),
           result::Err(err_data) => fail err_data.err_msg
@@ -141,19 +141,19 @@ mod v4 {
     }
     // the simple, old style numberic representation of
     // ipv4
-    type ipv4_rep = { a: u8, b: u8, c: u8, d:u8 };
+    type Ipv4Rep = { a: u8, b: u8, c: u8, d:u8 };
 
-    trait as_unsafe_u32 {
+    trait AsUnsafeU32 {
         unsafe fn as_u32() -> u32;
     }
 
-    impl ipv4_rep: as_unsafe_u32 {
+    impl Ipv4Rep: AsUnsafeU32 {
         // this is pretty dastardly, i know
         unsafe fn as_u32() -> u32 {
             *((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<Ipv4Rep, ~str> {
         let parts = vec::map(str::split_char(ip, '.'), |s| {
             match uint::from_str(s) {
               Some(n) if n <= 255u => n,
@@ -171,7 +171,7 @@ mod v4 {
                         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<IpAddr,ParseAddrErr> {
         unsafe {
             let INADDR_NONE = ll::get_INADDR_NONE();
             let ip_rep_result = parse_to_ipv4_rep(ip);
@@ -198,7 +198,7 @@ mod v4 {
                     {err_msg: ~"uv_ip4_name produced invalid result."})
             }
             else {
-                result::Ok(ipv4(copy(new_addr)))
+                result::Ok(Ipv4(copy(new_addr)))
             }
         }
     }
@@ -219,13 +219,13 @@ mod v6 {
      *
      * * an `ip_addr` of the `ipv6` variant
      */
-    fn parse_addr(ip: ~str) -> ip_addr {
+    fn parse_addr(ip: ~str) -> IpAddr {
         match try_parse_addr(ip) {
           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<IpAddr,ParseAddrErr> {
         unsafe {
             // need to figure out how to establish a parse failure..
             let new_addr = uv_ip6_addr(ip, 22);
@@ -239,21 +239,21 @@ mod v6 {
                                            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>>
+type GetAddrData = {
+    output_ch: comm::Chan<result::Result<~[IpAddr],IpGetAddrErr>>
 };
 
 extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
                      res: *addrinfo) unsafe {
     log(debug, ~"in get_addr_cb");
     let handle_data = get_data_for_req(handle) as
-        *get_addr_data;
+        *GetAddrData;
     if status == 0i32 {
         if res != (ptr::null::<addrinfo>()) {
             let mut out_vec = ~[];
@@ -261,18 +261,18 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
             let mut curr_addr = res;
             loop {
                 let new_ip_addr = if ll::is_ipv4_addrinfo(curr_addr) {
-                    ipv4(copy((
+                    Ipv4(copy((
                         *ll::addrinfo_as_sockaddr_in(curr_addr))))
                 }
                 else if ll::is_ipv6_addrinfo(curr_addr) {
-                    ipv6(copy((
+                    Ipv6(copy((
                         *ll::addrinfo_as_sockaddr_in6(curr_addr))))
                 }
                 else {
                     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(GetAddrUnknownError));
                     break;
                 };
                 out_vec += ~[new_ip_addr];
@@ -294,13 +294,13 @@ extern fn get_addr_cb(handle: *uv_getaddrinfo_t, status: libc::c_int,
         else {
             log(debug, ~"addrinfo pointer is NULL");
             (*handle_data).output_ch.send(
-                result::Err(get_addr_unknown_error));
+                result::Err(GetAddrUnknownError));
         }
     }
     else {
         log(debug, ~"status != 0 error in get_addr_cb");
         (*handle_data).output_ch.send(
-            result::Err(get_addr_unknown_error));
+            result::Err(GetAddrUnknownError));
     }
     if res != (ptr::null::<addrinfo>()) {
         uv_freeaddrinfo(res);
@@ -365,8 +365,8 @@ mod test {
                         localhost_name, vec::len(results)));
         for vec::each(results) |r| {
             let ipv_prefix = match r {
-              ipv4(_) => ~"IPv4",
-              ipv6(_) => ~"IPv6"
+              Ipv4(_) => ~"IPv4",
+              Ipv6(_) => ~"IPv6"
             };
             log(debug, fmt!("test_get_addr: result %s: '%s'",
                             ipv_prefix, format_addr(r)));
diff --git a/src/libstd/net_tcp.rs b/src/libstd/net_tcp.rs
index c7a5f90a857..fa799ee3e31 100644
--- a/src/libstd/net_tcp.rs
+++ b/src/libstd/net_tcp.rs
@@ -12,11 +12,11 @@ import io::{Reader, ReaderUtil, Writer};
 import comm = core::comm;
 
 // tcp interfaces
-export tcp_socket;
+export TcpSocket;
 // buffered socket
-export tcp_socket_buf, socket_buf;
+export TcpSocketBuf, SocketBuf;
 // errors
-export tcp_err_data, tcp_connect_err_data;
+export TcpErrData, TcpConnectErrData;
 // operations on a tcp_socket
 export write, write_future, read_start, read_stop;
 // tcp server stuff
@@ -38,9 +38,9 @@ extern mod rustrt {
  * underlying libuv data structures when it goes out of scope. This is the
  * data structure that is used for read/write operations over a TCP stream.
  */
-struct tcp_socket {
-  let socket_data: @tcp_socket_data;
-  new(socket_data: @tcp_socket_data) { self.socket_data = socket_data; }
+struct TcpSocket {
+  let socket_data: @TcpSocketData;
+  new(socket_data: @TcpSocketData) { self.socket_data = socket_data; }
   drop {
     unsafe {
         tear_down_socket_data(self.socket_data)
@@ -54,23 +54,23 @@ struct tcp_socket {
  * It is created with a call to `net::tcp::socket_buf()` and has impls that
  * satisfy both the `io::reader` and `io::writer` traits.
  */
-struct tcp_socket_buf {
-  let data: @tcp_buffered_socket_data;
-  new(data: @tcp_buffered_socket_data) { self.data = data; }
+struct TcpSocketBuf {
+  let data: @TcpBufferedSocketData;
+  new(data: @TcpBufferedSocketData) { self.data = data; }
 }
 
 /// Contains raw, string-based, error information returned from libuv
-type tcp_err_data = {
+type TcpErrData = {
     err_name: ~str,
     err_msg: ~str
 };
 /// Details returned as part of a `result::err` result from `tcp::listen`
-enum tcp_listen_err_data {
+enum TcpListenErrData {
     /**
      * Some unplanned-for error. The first and second fields correspond
      * to libuv's `err_name` and `err_msg` fields, respectively.
      */
-    generic_listen_err(~str, ~str),
+    GenericListenErr(~str, ~str),
     /**
      * Failed to bind to the requested IP/Port, because it is already in use.
      *
@@ -78,7 +78,7 @@ enum tcp_listen_err_data {
      *
      * * Attempting to bind to a port already bound to another listener
      */
-    address_in_use,
+    AddressInUse,
     /**
      * Request to bind to an IP/Port was denied by the system.
      *
@@ -89,17 +89,17 @@ enum tcp_listen_err_data {
      * * Attempting to bind, as a non-priv'd
      *   user, to 'privileged' ports (< 1024) on *nix
      */
-    access_denied
+    AccessDenied
 }
 /// Details returned as part of a `result::err` result from `tcp::connect`
-enum tcp_connect_err_data {
+enum TcpConnectErrData {
     /**
      * Some unplanned-for error. The first and second fields correspond
      * to libuv's `err_name` and `err_msg` fields, respectively.
      */
-    generic_connect_err(~str, ~str),
+    GenericConnectErr(~str, ~str),
     /// Invalid IP or invalid port
-    connection_refused
+    ConnectionRefused
 }
 
 /**
@@ -118,17 +118,17 @@ enum tcp_connect_err_data {
  * the remote host. In the event of failure, a
  * `net::tcp::tcp_connect_err_data` instance will be returned
  */
-fn connect(-input_ip: ip::ip_addr, port: uint,
+fn connect(-input_ip: ip::IpAddr, port: uint,
            iotask: IoTask)
-    -> result::Result<tcp_socket, tcp_connect_err_data> unsafe {
-    let result_po = core::comm::Port::<conn_attempt>();
+    -> result::Result<TcpSocket, TcpConnectErrData> unsafe {
+    let result_po = core::comm::Port::<ConnAttempt>();
     let closed_signal_po = core::comm::Port::<()>();
     let conn_data = {
         result_ch: core::comm::Chan(result_po),
         closed_signal_ch: core::comm::Chan(closed_signal_po)
     };
     let conn_data_ptr = ptr::addr_of(conn_data);
-    let reader_po = core::comm::Port::<result::Result<~[u8], tcp_err_data>>();
+    let reader_po = core::comm::Port::<result::Result<~[u8], TcpErrData>>();
     let stream_handle_ptr = malloc_uv_tcp_t();
     *(stream_handle_ptr as *mut uv::ll::uv_tcp_t) = uv::ll::tcp_t();
     let socket_data = @{
@@ -157,7 +157,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
                 ptr::addr_of((*socket_data_ptr).connect_req);
             let addr_str = ip::format_addr(input_ip);
             let connect_result = match input_ip {
-              ip::ipv4(addr) => {
+              ip::Ipv4(addr) => {
                 // have to "recreate" the sockaddr_in/6
                 // since the ip_addr discards the port
                 // info.. should probably add an additional
@@ -171,7 +171,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
                     ptr::addr_of(in_addr),
                     tcp_connect_on_connect_cb)
               }
-              ip::ipv6(addr) => {
+              ip::Ipv6(addr) => {
                 log(debug, fmt!("addr: %?", addr));
                 let in_addr = uv::ll::ip6_addr(addr_str, port as int);
                 uv::ll::tcp_connect6(
@@ -202,7 +202,7 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
                 // ip or somesuch
                 let err_data = uv::ll::get_last_err_data(loop_ptr);
                 core::comm::send((*conn_data_ptr).result_ch,
-                           conn_failure(err_data.to_tcp_err()));
+                           ConnFailure(err_data.to_tcp_err()));
                 uv::ll::set_data_for_uv_handle(stream_handle_ptr,
                                                conn_data_ptr);
                 uv::ll::close(stream_handle_ptr, stream_error_close_cb);
@@ -213,24 +213,24 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
             // failure to create a tcp handle
             let err_data = uv::ll::get_last_err_data(loop_ptr);
             core::comm::send((*conn_data_ptr).result_ch,
-                       conn_failure(err_data.to_tcp_err()));
+                       ConnFailure(err_data.to_tcp_err()));
           }
         }
     };
     match core::comm::recv(result_po) {
-      conn_success => {
+      ConnSuccess => {
         log(debug, ~"tcp::connect - received success on result_po");
-        result::Ok(tcp_socket(socket_data))
+        result::Ok(TcpSocket(socket_data))
       }
-      conn_failure(err_data) => {
+      ConnFailure(err_data) => {
         core::comm::recv(closed_signal_po);
         log(debug, ~"tcp::connect - received failure on result_po");
         // still have to free the malloc'd stream handle..
         rustrt::rust_uv_current_kernel_free(stream_handle_ptr
                                            as *libc::c_void);
         let tcp_conn_err = match err_data.err_name {
-          ~"ECONNREFUSED" => connection_refused,
-          _ => generic_connect_err(err_data.err_name, err_data.err_msg)
+          ~"ECONNREFUSED" => ConnectionRefused,
+          _ => GenericConnectErr(err_data.err_name, err_data.err_msg)
         };
         result::Err(tcp_conn_err)
       }
@@ -251,8 +251,8 @@ fn connect(-input_ip: ip::ip_addr, port: uint,
  * A `result` object with a `nil` value as the `ok` variant, or a
  * `tcp_err_data` value as the `err` variant
  */
-fn write(sock: tcp_socket, raw_write_data: ~[u8])
-    -> result::Result<(), tcp_err_data> unsafe {
+fn write(sock: TcpSocket, raw_write_data: ~[u8])
+    -> result::Result<(), TcpErrData> unsafe {
     let socket_data_ptr = ptr::addr_of(*(sock.socket_data));
     write_common_impl(socket_data_ptr, raw_write_data)
 }
@@ -288,8 +288,8 @@ fn write(sock: tcp_socket, raw_write_data: ~[u8])
  * `result` object with a `nil` value as the `ok` variant, or a `tcp_err_data`
  * value as the `err` variant
  */
-fn write_future(sock: tcp_socket, raw_write_data: ~[u8])
-    -> future::Future<result::Result<(), tcp_err_data>> unsafe {
+fn write_future(sock: TcpSocket, raw_write_data: ~[u8])
+    -> future::Future<result::Result<(), TcpErrData>> unsafe {
     let socket_data_ptr = ptr::addr_of(*(sock.socket_data));
     do future_spawn {
         let data_copy = copy(raw_write_data);
@@ -312,9 +312,9 @@ fn write_future(sock: tcp_socket, raw_write_data: ~[u8])
  * optionally, loop on) from until `read_stop` is called, or a
  * `tcp_err_data` record
  */
-fn read_start(sock: tcp_socket)
+fn read_start(sock: TcpSocket)
     -> result::Result<comm::Port<
-        result::Result<~[u8], tcp_err_data>>, tcp_err_data> unsafe {
+        result::Result<~[u8], TcpErrData>>, TcpErrData> unsafe {
     let socket_data = ptr::addr_of(*(sock.socket_data));
     read_start_common_impl(socket_data)
 }
@@ -326,9 +326,9 @@ fn read_start(sock: tcp_socket)
  *
  * * `sock` - a `net::tcp::tcp_socket` that you wish to stop reading on
  */
-fn read_stop(sock: tcp_socket,
-             -read_port: comm::Port<result::Result<~[u8], tcp_err_data>>) ->
-    result::Result<(), tcp_err_data> unsafe {
+fn read_stop(sock: TcpSocket,
+             -read_port: comm::Port<result::Result<~[u8], TcpErrData>>) ->
+    result::Result<(), TcpErrData> unsafe {
     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)
@@ -349,8 +349,8 @@ fn read_stop(sock: tcp_socket,
  * * `timeout_msecs` - a `uint` value, in msecs, to wait before dropping the
  * read attempt. Pass `0u` to wait indefinitely
  */
-fn read(sock: tcp_socket, timeout_msecs: uint)
-    -> result::Result<~[u8],tcp_err_data> {
+fn read(sock: TcpSocket, timeout_msecs: uint)
+    -> result::Result<~[u8],TcpErrData> {
     let socket_data = ptr::addr_of(*(sock.socket_data));
     read_common_impl(socket_data, timeout_msecs)
 }
@@ -384,8 +384,8 @@ fn read(sock: tcp_socket, timeout_msecs: uint)
  * * `timeout_msecs` - a `uint` value, in msecs, to wait before dropping the
  * read attempt. Pass `0u` to wait indefinitely
  */
-fn read_future(sock: tcp_socket, timeout_msecs: uint)
-    -> future::Future<result::Result<~[u8],tcp_err_data>> {
+fn read_future(sock: TcpSocket, timeout_msecs: uint)
+    -> future::Future<result::Result<~[u8],TcpErrData>> {
     let socket_data = ptr::addr_of(*(sock.socket_data));
     do future_spawn {
         read_common_impl(socket_data, timeout_msecs)
@@ -461,13 +461,13 @@ fn read_future(sock: tcp_socket, timeout_msecs: uint)
  * this function will return a `net::tcp::tcp_err_data` record
  * as the `err` variant of a `result`.
  */
-fn accept(new_conn: tcp_new_connection)
-    -> result::Result<tcp_socket, tcp_err_data> unsafe {
+fn accept(new_conn: TcpNewConnection)
+    -> result::Result<TcpSocket, TcpErrData> unsafe {
 
     match new_conn{
-      new_tcp_conn(server_handle_ptr) => {
+      NewTcpConn(server_handle_ptr) => {
         let server_data_ptr = uv::ll::get_data_for_uv_handle(
-            server_handle_ptr) as *tcp_listen_fc_data;
+            server_handle_ptr) as *TcpListenFcData;
         let reader_po = core::comm::Port();
         let iotask = (*server_data_ptr).iotask;
         let stream_handle_ptr = malloc_uv_tcp_t();
@@ -484,7 +484,7 @@ fn accept(new_conn: tcp_new_connection)
         let client_stream_handle_ptr =
             (*client_socket_data_ptr).stream_handle_ptr;
 
-        let result_po = core::comm::Port::<Option<tcp_err_data>>();
+        let result_po = core::comm::Port::<Option<TcpErrData>>();
         let result_ch = core::comm::Chan(result_po);
 
         // UNSAFE LIBUV INTERACTION BEGIN
@@ -525,7 +525,7 @@ fn accept(new_conn: tcp_new_connection)
         // UNSAFE LIBUV INTERACTION END
         match core::comm::recv(result_po) {
           Some(err_data) => result::Err(err_data),
-          None => result::Ok(tcp_socket(client_socket_data))
+          None => result::Ok(TcpSocket(client_socket_data))
         }
       }
     }
@@ -559,30 +559,30 @@ fn accept(new_conn: tcp_new_connection)
  * successful/normal shutdown, and a `tcp_listen_err_data` enum in the event
  * of listen exiting because of an error
  */
-fn listen(-host_ip: ip::ip_addr, port: uint, backlog: uint,
+fn listen(-host_ip: ip::IpAddr, port: uint, backlog: uint,
           iotask: IoTask,
-          on_establish_cb: fn~(comm::Chan<Option<tcp_err_data>>),
-          +new_connect_cb: fn~(tcp_new_connection,
-                               comm::Chan<Option<tcp_err_data>>))
-    -> result::Result<(), tcp_listen_err_data> unsafe {
+          on_establish_cb: fn~(comm::Chan<Option<TcpErrData>>),
+          +new_connect_cb: fn~(TcpNewConnection,
+                               comm::Chan<Option<TcpErrData>>))
+    -> result::Result<(), TcpListenErrData> unsafe {
     do listen_common(host_ip, port, backlog, iotask, on_establish_cb)
         // on_connect_cb
         |handle| unsafe {
             let server_data_ptr = uv::ll::get_data_for_uv_handle(handle)
-                as *tcp_listen_fc_data;
-            let new_conn = new_tcp_conn(handle);
+                as *TcpListenFcData;
+            let new_conn = NewTcpConn(handle);
             let kill_ch = (*server_data_ptr).kill_ch;
             new_connect_cb(new_conn, kill_ch);
     }
 }
 
-fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
+fn listen_common(-host_ip: ip::IpAddr, port: uint, backlog: uint,
           iotask: IoTask,
-          on_establish_cb: fn~(comm::Chan<Option<tcp_err_data>>),
+          on_establish_cb: fn~(comm::Chan<Option<TcpErrData>>),
           -on_connect_cb: fn~(*uv::ll::uv_tcp_t))
-    -> result::Result<(), tcp_listen_err_data> unsafe {
+    -> result::Result<(), TcpListenErrData> unsafe {
     let stream_closed_po = core::comm::Port::<()>();
-    let kill_po = core::comm::Port::<Option<tcp_err_data>>();
+    let kill_po = core::comm::Port::<Option<TcpErrData>>();
     let kill_ch = core::comm::Chan(kill_po);
     let server_stream = uv::ll::tcp_t();
     let server_stream_ptr = ptr::addr_of(server_stream);
@@ -612,13 +612,13 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
                     server_data_ptr);
                 let addr_str = ip::format_addr(loc_ip);
                 let bind_result = match loc_ip {
-                  ip::ipv4(addr) => {
+                  ip::Ipv4(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) => {
+                  ip::Ipv6(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,
@@ -666,17 +666,17 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
         match err_data.err_name {
           ~"EACCES" => {
             log(debug, ~"Got EACCES error");
-            result::Err(access_denied)
+            result::Err(AccessDenied)
           }
           ~"EADDRINUSE" => {
             log(debug, ~"Got EADDRINUSE error");
-            result::Err(address_in_use)
+            result::Err(AddressInUse)
           }
           _ => {
             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))
+                GenericListenErr(err_data.err_name, err_data.err_msg))
           }
         }
       }
@@ -692,7 +692,7 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
         stream_closed_po.recv();
         match kill_result {
           // some failure post bind/listen
-          Some(err_data) => result::Err(generic_listen_err(err_data.err_name,
+          Some(err_data) => result::Err(GenericListenErr(err_data.err_name,
                                                            err_data.err_msg)),
           // clean exit
           None => result::Ok(())
@@ -716,41 +716,41 @@ fn listen_common(-host_ip: ip::ip_addr, port: uint, backlog: uint,
  *
  * A buffered wrapper that you can cast as an `io::reader` or `io::writer`
  */
-fn socket_buf(-sock: tcp_socket) -> tcp_socket_buf {
-    tcp_socket_buf(@{ sock: sock, mut buf: ~[] })
+fn socket_buf(-sock: TcpSocket) -> TcpSocketBuf {
+    TcpSocketBuf(@{ sock: sock, mut buf: ~[] })
 }
 
 /// Convenience methods extending `net::tcp::tcp_socket`
-impl tcp_socket {
+impl TcpSocket {
     fn read_start() -> result::Result<comm::Port<
-        result::Result<~[u8], tcp_err_data>>, tcp_err_data> {
+        result::Result<~[u8], TcpErrData>>, TcpErrData> {
         read_start(self)
     }
     fn read_stop(-read_port:
-                 comm::Port<result::Result<~[u8], tcp_err_data>>) ->
-        result::Result<(), tcp_err_data> {
+                 comm::Port<result::Result<~[u8], TcpErrData>>) ->
+        result::Result<(), TcpErrData> {
         read_stop(self, read_port)
     }
     fn read(timeout_msecs: uint) ->
-        result::Result<~[u8], tcp_err_data> {
+        result::Result<~[u8], TcpErrData> {
         read(self, timeout_msecs)
     }
     fn read_future(timeout_msecs: uint) ->
-        future::Future<result::Result<~[u8], tcp_err_data>> {
+        future::Future<result::Result<~[u8], TcpErrData>> {
         read_future(self, timeout_msecs)
     }
     fn write(raw_write_data: ~[u8])
-        -> result::Result<(), tcp_err_data> {
+        -> result::Result<(), TcpErrData> {
         write(self, raw_write_data)
     }
     fn write_future(raw_write_data: ~[u8])
-        -> future::Future<result::Result<(), tcp_err_data>> {
+        -> future::Future<result::Result<(), TcpErrData>> {
         write_future(self, raw_write_data)
     }
 }
 
 /// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket`
-impl tcp_socket_buf: io::Reader {
+impl TcpSocketBuf: io::Reader {
     fn read(buf: &[mut u8], len: uint) -> uint {
         // Loop until our buffer has enough data in it for us to read from.
         while self.data.buf.len() < len {
@@ -803,7 +803,7 @@ impl tcp_socket_buf: io::Reader {
 }
 
 /// Implementation of `io::reader` trait for a buffered `net::tcp::tcp_socket`
-impl tcp_socket_buf: io::Writer {
+impl TcpSocketBuf: io::Writer {
     fn write(data: &[const u8]) unsafe {
         let socket_data_ptr =
             ptr::addr_of(*((*(self.data)).sock).socket_data);
@@ -832,7 +832,7 @@ impl tcp_socket_buf: io::Writer {
 
 // INTERNAL API
 
-fn tear_down_socket_data(socket_data: @tcp_socket_data) unsafe {
+fn tear_down_socket_data(socket_data: @TcpSocketData) unsafe {
     let closed_po = core::comm::Port::<()>();
     let closed_ch = core::comm::Chan(closed_po);
     let close_data = {
@@ -855,8 +855,8 @@ fn tear_down_socket_data(socket_data: @tcp_socket_data) unsafe {
 }
 
 // shared implementation for tcp::read
-fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint)
-    -> result::Result<~[u8],tcp_err_data> unsafe {
+fn read_common_impl(socket_data: *TcpSocketData, timeout_msecs: uint)
+    -> result::Result<~[u8],TcpErrData> unsafe {
     log(debug, ~"starting tcp::read");
     let iotask = (*socket_data).iotask;
     let rs_result = read_start_common_impl(socket_data);
@@ -893,10 +893,10 @@ fn read_common_impl(socket_data: *tcp_socket_data, timeout_msecs: uint)
 }
 
 // shared impl for read_stop
-fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
-    result::Result<(), tcp_err_data> unsafe {
+fn read_stop_common_impl(socket_data: *TcpSocketData) ->
+    result::Result<(), TcpErrData> unsafe {
     let stream_handle_ptr = (*socket_data).stream_handle_ptr;
-    let stop_po = core::comm::Port::<Option<tcp_err_data>>();
+    let stop_po = core::comm::Port::<Option<TcpErrData>>();
     let stop_ch = core::comm::Chan(stop_po);
     do iotask::interact((*socket_data).iotask) |loop_ptr| unsafe {
         log(debug, ~"in interact cb for tcp::read_stop");
@@ -919,9 +919,9 @@ fn read_stop_common_impl(socket_data: *tcp_socket_data) ->
 }
 
 // shared impl for read_start
-fn read_start_common_impl(socket_data: *tcp_socket_data)
+fn read_start_common_impl(socket_data: *TcpSocketData)
     -> result::Result<comm::Port<
-        result::Result<~[u8], tcp_err_data>>, tcp_err_data> unsafe {
+        result::Result<~[u8], TcpErrData>>, TcpErrData> unsafe {
     let stream_handle_ptr = (*socket_data).stream_handle_ptr;
     let start_po = core::comm::Port::<Option<uv::ll::uv_err_data>>();
     let start_ch = core::comm::Chan(start_po);
@@ -951,9 +951,9 @@ fn read_start_common_impl(socket_data: *tcp_socket_data)
 // helper to convert a "class" vector of [u8] to a *[uv::ll::uv_buf_t]
 
 // shared implementation used by write and write_future
-fn write_common_impl(socket_data_ptr: *tcp_socket_data,
+fn write_common_impl(socket_data_ptr: *TcpSocketData,
                      raw_write_data: ~[u8])
-    -> result::Result<(), tcp_err_data> unsafe {
+    -> result::Result<(), TcpErrData> unsafe {
     let write_req_ptr = ptr::addr_of((*socket_data_ptr).write_req);
     let stream_handle_ptr =
         (*socket_data_ptr).stream_handle_ptr;
@@ -961,7 +961,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
         vec::unsafe::to_ptr(raw_write_data),
         vec::len(raw_write_data)) ];
     let write_buf_vec_ptr = ptr::addr_of(write_buf_vec);
-    let result_po = core::comm::Port::<tcp_write_result>();
+    let result_po = core::comm::Port::<TcpWriteResult>();
     let write_data = {
         result_ch: core::comm::Chan(result_po)
     };
@@ -980,7 +980,7 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
             log(debug, ~"error invoking uv_write()");
             let err_data = uv::ll::get_last_err_data(loop_ptr);
             core::comm::send((*write_data_ptr).result_ch,
-                       tcp_write_error(err_data.to_tcp_err()));
+                       TcpWriteError(err_data.to_tcp_err()));
           }
         }
     };
@@ -989,19 +989,19 @@ fn write_common_impl(socket_data_ptr: *tcp_socket_data,
     // ownership of everything to the I/O task and let it deal with the
     // aftermath, so we don't have to sit here blocking.
     match core::comm::recv(result_po) {
-      tcp_write_success => result::Ok(()),
-      tcp_write_error(err_data) => result::Err(err_data.to_tcp_err())
+      TcpWriteSuccess => result::Ok(()),
+      TcpWriteError(err_data) => result::Err(err_data.to_tcp_err())
     }
 }
 
-enum tcp_new_connection {
-    new_tcp_conn(*uv::ll::uv_tcp_t)
+enum TcpNewConnection {
+    NewTcpConn(*uv::ll::uv_tcp_t)
 }
 
-type tcp_listen_fc_data = {
+type TcpListenFcData = {
     server_stream_ptr: *uv::ll::uv_tcp_t,
     stream_closed_ch: comm::Chan<()>,
-    kill_ch: comm::Chan<Option<tcp_err_data>>,
+    kill_ch: comm::Chan<Option<TcpErrData>>,
     on_connect_cb: fn~(*uv::ll::uv_tcp_t),
     iotask: IoTask,
     mut active: bool
@@ -1009,14 +1009,14 @@ type tcp_listen_fc_data = {
 
 extern fn tcp_lfc_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
     let server_data_ptr = uv::ll::get_data_for_uv_handle(
-        handle) as *tcp_listen_fc_data;
+        handle) as *TcpListenFcData;
     core::comm::send((*server_data_ptr).stream_closed_ch, ());
 }
 
 extern fn tcp_lfc_on_connection_cb(handle: *uv::ll::uv_tcp_t,
                                      status: libc::c_int) unsafe {
     let server_data_ptr = uv::ll::get_data_for_uv_handle(handle)
-        as *tcp_listen_fc_data;
+        as *TcpListenFcData;
     let kill_ch = (*server_data_ptr).kill_ch;
     if (*server_data_ptr).active {
         match status {
@@ -1037,33 +1037,33 @@ fn malloc_uv_tcp_t() -> *uv::ll::uv_tcp_t unsafe {
         rustrt::rust_uv_helper_uv_tcp_t_size()) as *uv::ll::uv_tcp_t
 }
 
-enum tcp_connect_result {
-    tcp_connected(tcp_socket),
-    tcp_connect_error(tcp_err_data)
+enum TcpConnectResult {
+    TcpConnected(TcpSocket),
+    TcpConnectError(TcpErrData)
 }
 
-enum tcp_write_result {
-    tcp_write_success,
-    tcp_write_error(tcp_err_data)
+enum TcpWriteResult {
+    TcpWriteSuccess,
+    TcpWriteError(TcpErrData)
 }
 
-enum tcp_read_start_result {
-    tcp_read_start_success(comm::Port<tcp_read_result>),
-    tcp_read_start_error(tcp_err_data)
+enum TcpReadStartResult {
+    TcpReadStartSuccess(comm::Port<TcpReadResult>),
+    TcpReadStartError(TcpErrData)
 }
 
-enum tcp_read_result {
-    tcp_read_data(~[u8]),
-    tcp_read_done,
-    tcp_read_err(tcp_err_data)
+enum TcpReadResult {
+    TcpReadData(~[u8]),
+    TcpReadDone,
+    TcpReadErr(TcpErrData)
 }
 
-trait to_tcp_err {
-    fn to_tcp_err() -> tcp_err_data;
+trait ToTcpErr {
+    fn to_tcp_err() -> TcpErrData;
 }
 
-impl uv::ll::uv_err_data: to_tcp_err {
-    fn to_tcp_err() -> tcp_err_data {
+impl uv::ll::uv_err_data: ToTcpErr {
+    fn to_tcp_err() -> TcpErrData {
         { err_name: self.err_name, err_msg: self.err_msg }
     }
 }
@@ -1075,7 +1075,7 @@ extern fn on_tcp_read_cb(stream: *uv::ll::uv_stream_t,
                     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;
+        as *TcpSocketData;
     match nread as int {
       // incoming err.. probably eof
       -1 => {
@@ -1113,13 +1113,13 @@ extern fn on_alloc_cb(handle: *libc::c_void,
     uv::ll::buf_init(char_ptr, suggested_size as uint)
 }
 
-type tcp_socket_close_data = {
+type TcpSocketCloseData = {
     closed_ch: comm::Chan<()>
 };
 
 extern fn tcp_socket_dtor_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
     let data = uv::ll::get_data_for_uv_handle(handle)
-        as *tcp_socket_close_data;
+        as *TcpSocketCloseData;
     let closed_ch = (*data).closed_ch;
     core::comm::send(closed_ch, ());
     log(debug, ~"tcp_socket_dtor_close_cb exiting..");
@@ -1128,10 +1128,10 @@ extern fn tcp_socket_dtor_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
 extern fn tcp_write_complete_cb(write_req: *uv::ll::uv_write_t,
                               status: libc::c_int) unsafe {
     let write_data_ptr = uv::ll::get_data_for_req(write_req)
-        as *write_req_data;
+        as *WriteReqData;
     if status == 0i32 {
         log(debug, ~"successful write complete");
-        core::comm::send((*write_data_ptr).result_ch, tcp_write_success);
+        core::comm::send((*write_data_ptr).result_ch, TcpWriteSuccess);
     } else {
         let stream_handle_ptr = uv::ll::get_stream_handle_from_write_req(
             write_req);
@@ -1139,22 +1139,22 @@ extern fn tcp_write_complete_cb(write_req: *uv::ll::uv_write_t,
         let err_data = uv::ll::get_last_err_data(loop_ptr);
         log(debug, ~"failure to write");
         core::comm::send((*write_data_ptr).result_ch,
-                         tcp_write_error(err_data));
+                         TcpWriteError(err_data));
     }
 }
 
-type write_req_data = {
-    result_ch: comm::Chan<tcp_write_result>
+type WriteReqData = {
+    result_ch: comm::Chan<TcpWriteResult>
 };
 
-type connect_req_data = {
-    result_ch: comm::Chan<conn_attempt>,
+type ConnectReqData = {
+    result_ch: comm::Chan<ConnAttempt>,
     closed_signal_ch: comm::Chan<()>
 };
 
 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;
+        *ConnectReqData;
     core::comm::send((*data).closed_signal_ch, ());
     log(debug, fmt!("exiting steam_error_close_cb for %?", handle));
 }
@@ -1166,7 +1166,7 @@ extern fn tcp_connect_close_cb(handle: *uv::ll::uv_tcp_t) unsafe {
 extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
                                    status: libc::c_int) unsafe {
     let conn_data_ptr = (uv::ll::get_data_for_req(connect_req_ptr)
-                      as *connect_req_data);
+                      as *ConnectReqData);
     let result_ch = (*conn_data_ptr).result_ch;
     log(debug, fmt!("tcp_connect result_ch %?", result_ch));
     let tcp_stream_ptr =
@@ -1174,7 +1174,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
     match status {
       0i32 => {
         log(debug, ~"successful tcp connection!");
-        core::comm::send(result_ch, conn_success);
+        core::comm::send(result_ch, ConnSuccess);
       }
       _ => {
         log(debug, ~"error in tcp_connect_on_connect_cb");
@@ -1182,7 +1182,7 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
         let err_data = uv::ll::get_last_err_data(loop_ptr);
         log(debug, fmt!("err_data %? %?", err_data.err_name,
                         err_data.err_msg));
-        core::comm::send(result_ch, conn_failure(err_data));
+        core::comm::send(result_ch, ConnFailure(err_data));
         uv::ll::set_data_for_uv_handle(tcp_stream_ptr,
                                        conn_data_ptr);
         uv::ll::close(tcp_stream_ptr, stream_error_close_cb);
@@ -1191,22 +1191,22 @@ extern fn tcp_connect_on_connect_cb(connect_req_ptr: *uv::ll::uv_connect_t,
     log(debug, ~"leaving tcp_connect_on_connect_cb");
 }
 
-enum conn_attempt {
-    conn_success,
-    conn_failure(uv::ll::uv_err_data)
+enum ConnAttempt {
+    ConnSuccess,
+    ConnFailure(uv::ll::uv_err_data)
 }
 
-type tcp_socket_data = {
-    reader_po: comm::Port<result::Result<~[u8], tcp_err_data>>,
-    reader_ch: comm::Chan<result::Result<~[u8], tcp_err_data>>,
+type TcpSocketData = {
+    reader_po: comm::Port<result::Result<~[u8], TcpErrData>>,
+    reader_ch: comm::Chan<result::Result<~[u8], TcpErrData>>,
     stream_handle_ptr: *uv::ll::uv_tcp_t,
     connect_req: uv::ll::uv_connect_t,
     write_req: uv::ll::uv_write_t,
     iotask: IoTask
 };
 
-type tcp_buffered_socket_data = {
-    sock: tcp_socket,
+type TcpBufferedSocketData = {
+    sock: TcpSocket,
     mut buf: ~[u8]
 };
 
@@ -1333,7 +1333,7 @@ mod test {
                 hl_loop)
         };
         match actual_resp_result.get_err() {
-          connection_refused => (),
+          ConnectionRefused => (),
           _ => fail ~"unknown error.. expected connection_refused"
         }
     }
@@ -1379,7 +1379,7 @@ mod test {
                 hl_loop)
         };
         match listen_err {
-          address_in_use => {
+          AddressInUse => {
             assert true;
           }
           _ => {
@@ -1398,7 +1398,7 @@ mod test {
                             server_port,
                             hl_loop);
         match listen_err {
-          access_denied => {
+          AccessDenied => {
             assert true;
           }
           _ => {
@@ -1544,14 +1544,14 @@ mod test {
         // err check on listen_result
         if result::is_err(listen_result) {
             match result::get_err(listen_result) {
-              generic_listen_err(name, msg) => {
+              GenericListenErr(name, msg) => {
                 fail fmt!("SERVER: exited abnormally name %s msg %s",
                                 name, msg);
               }
-              access_denied => {
+              AccessDenied => {
                 fail ~"SERVER: exited abnormally, got access denied..";
               }
-              address_in_use => {
+              AddressInUse => {
                 fail ~"SERVER: exited abnormally, got address in use...";
               }
             }
@@ -1562,7 +1562,7 @@ mod test {
     }
 
     fn run_tcp_test_server_fail(server_ip: ~str, server_port: uint,
-                          iotask: IoTask) -> tcp_listen_err_data {
+                          iotask: IoTask) -> TcpListenErrData {
         let server_ip_addr = ip::v4::parse_addr(server_ip);
         let listen_result = listen(server_ip_addr, server_port, 128u, iotask,
             // on_establish_cb -- called when listener is set up
@@ -1586,7 +1586,7 @@ mod test {
     fn run_tcp_test_client(server_ip: ~str, server_port: uint, resp: ~str,
                           client_ch: comm::Chan<~str>,
                           iotask: IoTask) -> result::Result<~str,
-                                                    tcp_connect_err_data> {
+                                                    TcpConnectErrData> {
         let server_ip_addr = ip::v4::parse_addr(server_ip);
 
         log(debug, ~"CLIENT: starting..");
@@ -1615,7 +1615,7 @@ mod test {
         }
     }
 
-    fn tcp_write_single(sock: tcp_socket, val: ~[u8]) {
+    fn tcp_write_single(sock: TcpSocket, val: ~[u8]) {
         let write_result_future = sock.write_future(val);
         let write_result = write_result_future.get();
         if result::is_err(write_result) {
diff --git a/src/libstd/net_url.rs b/src/libstd/net_url.rs
index ad987320fd8..b1e1209cbb5 100644
--- a/src/libstd/net_url.rs
+++ b/src/libstd/net_url.rs
@@ -6,7 +6,7 @@ import map::{hashmap, str_hash};
 import io::{Reader, ReaderUtil};
 import dvec::DVec;
 
-export url, userinfo, query;
+export Url, userinfo, query;
 export from_str, to_str;
 export get_scheme;
 
@@ -14,31 +14,31 @@ export encode, decode;
 export encode_component, decode_component;
 export encode_form_urlencoded, decode_form_urlencoded;
 
-type url = {
+type Url = {
     scheme: ~str,
-    user: Option<userinfo>,
+    user: Option<UserInfo>,
     host: ~str,
     port: Option<~str>,
     path: ~str,
-    query: query,
+    query: Query,
     fragment: Option<~str>
 };
 
-type userinfo = {
+type UserInfo = {
     user: ~str,
     pass: Option<~str>
 };
 
-type query = ~[(~str, ~str)];
+type Query = ~[(~str, ~str)];
 
-fn url(-scheme: ~str, -user: Option<userinfo>, -host: ~str,
-       -port: Option<~str>, -path: ~str, -query: query,
-       -fragment: Option<~str>) -> url {
+fn url(-scheme: ~str, -user: Option<UserInfo>, -host: ~str,
+       -port: Option<~str>, -path: ~str, -query: Query,
+       -fragment: Option<~str>) -> Url {
     { scheme: scheme, user: user, host: host, port: port,
      path: path, query: query, fragment: fragment }
 }
 
-fn userinfo(-user: ~str, -pass: Option<~str>) -> userinfo {
+fn userinfo(-user: ~str, -pass: Option<~str>) -> UserInfo {
     {user: user, pass: pass}
 }
 
@@ -290,7 +290,7 @@ fn split_char_first(s: ~str, c: char) -> (~str, ~str) {
     }
 }
 
-fn userinfo_from_str(uinfo: ~str) -> userinfo {
+fn userinfo_from_str(uinfo: ~str) -> UserInfo {
     let (user, p) = split_char_first(uinfo, ':');
     let pass = if str::len(p) == 0 {
         option::None
@@ -300,7 +300,7 @@ fn userinfo_from_str(uinfo: ~str) -> userinfo {
     return userinfo(user, pass);
 }
 
-fn userinfo_to_str(-userinfo: userinfo) -> ~str {
+fn userinfo_to_str(-userinfo: UserInfo) -> ~str {
     if option::is_some(userinfo.pass) {
         return str::concat(~[copy userinfo.user, ~":",
                           option::unwrap(copy userinfo.pass),
@@ -310,14 +310,14 @@ fn userinfo_to_str(-userinfo: userinfo) -> ~str {
     }
 }
 
-impl userinfo : Eq {
-    pure fn eq(&&other: userinfo) -> bool {
+impl UserInfo : Eq {
+    pure fn eq(&&other: UserInfo) -> bool {
         self.user == other.user && self.pass == other.pass
     }
 }
 
-fn query_from_str(rawquery: ~str) -> query {
-    let mut query: query = ~[];
+fn query_from_str(rawquery: ~str) -> Query {
+    let mut query: Query = ~[];
     if str::len(rawquery) != 0 {
         for str::split_char(rawquery, '&').each |p| {
             let (k, v) = split_char_first(p, '=');
@@ -327,7 +327,7 @@ fn query_from_str(rawquery: ~str) -> query {
     return query;
 }
 
-fn query_to_str(query: query) -> ~str {
+fn query_to_str(query: Query) -> ~str {
     let mut strvec = ~[];
     for query.each |kv| {
         let (k, v) = copy kv;
@@ -363,47 +363,47 @@ fn get_scheme(rawurl: ~str) -> result::Result<(~str, ~str), @~str> {
     return result::Err(@~"url: Scheme must be terminated with a colon.");
 }
 
-enum input {
-    digit, // all digits
-    hex, // digits and letters a-f
-    unreserved // all other legal characters
+enum Input {
+    Digit, // all digits
+    Hex, // digits and letters a-f
+    Unreserved // all other legal characters
 }
 
-impl input: Eq {
-    pure fn eq(&&other: input) -> bool {
+impl Input: Eq {
+    pure fn eq(&&other: Input) -> bool {
         match (self, other) {
-            (digit, digit) => true,
-            (hex, hex) => true,
-            (unreserved, unreserved) => true,
-            (digit, _) => false,
-            (hex, _) => false,
-            (unreserved, _) => false
+            (Digit, Digit) => true,
+            (Hex, Hex) => true,
+            (Unreserved, Unreserved) => true,
+            (Digit, _) => false,
+            (Hex, _) => false,
+            (Unreserved, _) => false
         }
     }
 }
 
 // returns userinfo, host, port, and unparsed part, or an error
 fn get_authority(rawurl: ~str) ->
-    result::Result<(Option<userinfo>, ~str, Option<~str>, ~str), @~str> {
+    result::Result<(Option<UserInfo>, ~str, Option<~str>, ~str), @~str> {
     if !str::starts_with(rawurl, ~"//") {
         // there is no authority.
         return result::Ok((option::None, ~"", option::None, copy rawurl));
     }
 
-    enum state {
-        start, // starting state
-        pass_host_port, // could be in user or port
-        ip6_port, // either in ipv6 host or port
-        ip6_host, // are in an ipv6 host
-        in_host, // are in a host - may be ipv6, but don't know yet
-        in_port // are in port
+    enum State {
+        Start, // starting state
+        PassHostPort, // could be in user or port
+        Ip6Port, // either in ipv6 host or port
+        Ip6Host, // are in an ipv6 host
+        InHost, // are in a host - may be ipv6, but don't know yet
+        InPort // are in port
     }
 
     let len = str::len(rawurl);
-    let mut st : state = start;
-    let mut in : input = digit; // most restricted, start here.
+    let mut st : State = Start;
+    let mut in : Input = Digit; // most restricted, start here.
 
-    let mut userinfo : Option<userinfo> = option::None;
+    let mut userinfo : Option<UserInfo> = option::None;
     let mut host : ~str = ~"";
     let mut port : option::Option<~str> = option::None;
 
@@ -417,13 +417,13 @@ fn get_authority(rawurl: ~str) ->
         match c {
           '0' to '9' => (),
           'A' to 'F' | 'a' to 'f' => {
-            if in == digit {
-                in = hex;
+            if in == Digit {
+                in = Hex;
             }
           }
           'G' to 'Z' | 'g' to 'z' | '-' | '.' | '_' | '~' | '%' |
           '&' |'\'' | '(' | ')' | '+' | '!' | '*' | ',' | ';' | '=' => {
-            in = unreserved;
+            in = Unreserved;
           }
           ':' | '@' | '?' | '#' | '/' => {
             // separators, don't change anything
@@ -438,62 +438,62 @@ fn get_authority(rawurl: ~str) ->
           ':' => {
             colon_count += 1;
             match st {
-              start => {
+              Start => {
                 pos = i;
-                st = pass_host_port;
+                st = PassHostPort;
               }
-              pass_host_port => {
+              PassHostPort => {
                 // multiple colons means ipv6 address.
-                if in == unreserved {
+                if in == Unreserved {
                     return result::Err(
                         @~"Illegal characters in IPv6 address.");
                 }
-                st = ip6_host;
+                st = Ip6Host;
               }
-              in_host => {
+              InHost => {
                 pos = i;
                 // can't be sure whether this is an ipv6 address or a port
-                if in == unreserved {
+                if in == Unreserved {
                     return result::Err(@~"Illegal characters in authority.");
                 }
-                st = ip6_port;
+                st = Ip6Port;
               }
-              ip6_port => {
-                if in == unreserved {
+              Ip6Port => {
+                if in == Unreserved {
                     return result::Err(@~"Illegal characters in authority.");
                 }
-                st = ip6_host;
+                st = Ip6Host;
               }
-              ip6_host => {
+              Ip6Host => {
                 if colon_count > 7 {
                     host = str::slice(rawurl, begin, i);
                     pos = i;
-                    st = in_port;
+                    st = InPort;
                 }
               }
               _ => {
                 return result::Err(@~"Invalid ':' in authority.");
               }
             }
-            in = digit; // reset input class
+            in = Digit; // reset input class
           }
 
           '@' => {
-            in = digit; // reset input class
+            in = Digit; // reset input class
             colon_count = 0; // reset count
             match st {
-              start => {
+              Start => {
                 let user = str::slice(rawurl, begin, i);
                 userinfo = option::Some({user : user,
                                          pass: option::None});
-                st = in_host;
+                st = InHost;
               }
-              pass_host_port => {
+              PassHostPort => {
                 let user = str::slice(rawurl, begin, pos);
                 let pass = str::slice(rawurl, pos+1, i);
                 userinfo = option::Some({user: user,
                                          pass: option::Some(pass)});
-                st = in_host;
+                st = InHost;
               }
               _ => {
                 return result::Err(@~"Invalid '@' in authority.");
@@ -520,25 +520,25 @@ fn get_authority(rawurl: ~str) ->
 
     // finish up
     match st {
-      start => {
+      Start => {
         if host_is_end_plus_one() {
             host = str::slice(rawurl, begin, end+1);
         } else {
             host = str::slice(rawurl, begin, end);
         }
       }
-      pass_host_port | ip6_port => {
-        if in != digit {
+      PassHostPort | Ip6Port => {
+        if in != Digit {
             return result::Err(@~"Non-digit characters in port.");
         }
         host = str::slice(rawurl, begin, pos);
         port = option::Some(str::slice(rawurl, pos+1, end));
       }
-      ip6_host | in_host => {
+      Ip6Host | InHost => {
         host = str::slice(rawurl, begin, end);
       }
-      in_port => {
-        if in != digit {
+      InPort => {
+        if in != Digit {
             return result::Err(@~"Non-digit characters in port.");
         }
         port = option::Some(str::slice(rawurl, pos+1, end));
@@ -584,7 +584,7 @@ fn get_path(rawurl: ~str, authority : bool) ->
 
 // returns the parsed query and the fragment, if present
 fn get_query_fragment(rawurl: ~str) ->
-    result::Result<(query, Option<~str>), @~str> {
+    result::Result<(Query, Option<~str>), @~str> {
     if !str::starts_with(rawurl, ~"?") {
         if str::starts_with(rawurl, ~"#") {
             let f = decode_component(str::slice(rawurl,
@@ -615,7 +615,7 @@ fn get_query_fragment(rawurl: ~str) ->
  *
  */
 
-fn from_str(rawurl: ~str) -> result::Result<url, ~str> {
+fn from_str(rawurl: ~str) -> result::Result<Url, ~str> {
     // scheme
     let mut schm = get_scheme(rawurl);
     if result::is_err(schm) {
@@ -664,7 +664,7 @@ fn from_str(rawurl: ~str) -> result::Result<url, ~str> {
  * result in just "http://somehost.com".
  *
  */
-fn to_str(url: url) -> ~str {
+fn to_str(url: Url) -> ~str {
     let user = if option::is_some(url.user) {
       userinfo_to_str(option::unwrap(copy url.user))
     } else {
@@ -695,7 +695,7 @@ fn to_str(url: url) -> ~str {
                       fragment]);
 }
 
-impl url: to_str::ToStr {
+impl Url: to_str::ToStr {
     fn to_str() -> ~str {
         to_str(self)
     }
diff --git a/src/libstd/std.rc b/src/libstd/std.rc
index 956f9f4692b..f8a61cda0de 100644
--- a/src/libstd/std.rc
+++ b/src/libstd/std.rc
@@ -30,9 +30,13 @@ export cell;
 
 // General io and system-services modules
 
+#[warn(non_camel_case_types)]
 mod net;
+#[warn(non_camel_case_types)]
 mod net_ip;
+#[warn(non_camel_case_types)]
 mod net_tcp;
+#[warn(non_camel_case_types)]
 mod net_url;
 
 // libuv modules