auto merge of #12815 : alexcrichton/rust/chan-rename, r=brson

* Chan<T> => Sender<T>
* Port<T> => Receiver<T>
* Chan::new() => channel()
* constructor returns (Sender, Receiver) instead of (Receiver, Sender)
* local variables named `port` renamed to `rx`
* local variables named `chan` renamed to `tx`

Closes #11765

11 files changed, 246 insertions, 288 deletions

diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index f2d3d410758..f09555e93a0 100644
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -8,25 +8,26 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use prelude::*;
-
-use comm::{Port, Chan};
+use clone::Clone;
 use cmp;
+use container::Container;
+use comm::{Sender, Receiver};
 use io;
 use option::{None, Option, Some};
+use result::{Ok, Err};
 use super::{Reader, Writer, IoResult};
 use vec::{bytes, CloneableVector, MutableVector, ImmutableVector};
 
-/// Allows reading from a port.
+/// Allows reading from a rx.
 ///
 /// # Example
 ///
 /// ```
-/// use std::io::PortReader;
+/// use std::io::ChanReader;
 ///
-/// let (port, chan) = Chan::new();
-/// # drop(chan);
-/// let mut reader = PortReader::new(port);
+/// let (tx, rx) = channel();
+/// # drop(tx);
+/// let mut reader = ChanReader::new(rx);
 ///
 /// let mut buf = ~[0u8, ..100];
 /// match reader.read(buf) {
@@ -34,26 +35,26 @@ use vec::{bytes, CloneableVector, MutableVector, ImmutableVector};
 ///     Err(e) => println!("read error: {}", e),
 /// }
 /// ```
-pub struct PortReader {
+pub struct ChanReader {
     priv buf: Option<~[u8]>,  // A buffer of bytes received but not consumed.
     priv pos: uint,           // How many of the buffered bytes have already be consumed.
-    priv port: Port<~[u8]>,   // The port to pull data from.
-    priv closed: bool,        // Whether the pipe this port connects to has been closed.
+    priv rx: Receiver<~[u8]>,   // The rx to pull data from.
+    priv closed: bool,        // Whether the pipe this rx connects to has been closed.
 }
 
-impl PortReader {
-    /// Wraps a `Port` in a `PortReader` structure
-    pub fn new(port: Port<~[u8]>) -> PortReader {
-        PortReader {
+impl ChanReader {
+    /// Wraps a `Port` in a `ChanReader` structure
+    pub fn new(rx: Receiver<~[u8]>) -> ChanReader {
+        ChanReader {
             buf: None,
             pos: 0,
-            port: port,
+            rx: rx,
             closed: false,
         }
     }
 }
 
-impl Reader for PortReader {
+impl Reader for ChanReader {
     fn read(&mut self, buf: &mut [u8]) -> IoResult<uint> {
         let mut num_read = 0;
         loop {
@@ -72,7 +73,7 @@ impl Reader for PortReader {
                 break;
             }
             self.pos = 0;
-            self.buf = self.port.recv_opt();
+            self.buf = self.rx.recv_opt();
             self.closed = self.buf.is_none();
         }
         if self.closed && num_read == 0 {
@@ -83,7 +84,7 @@ impl Reader for PortReader {
     }
 }
 
-/// Allows writing to a chan.
+/// Allows writing to a tx.
 ///
 /// # Example
 ///
@@ -91,31 +92,31 @@ impl Reader for PortReader {
 /// # #[allow(unused_must_use)];
 /// use std::io::ChanWriter;
 ///
-/// let (port, chan) = Chan::new();
-/// # drop(port);
-/// let mut writer = ChanWriter::new(chan);
+/// let (tx, rx) = channel();
+/// # drop(rx);
+/// let mut writer = ChanWriter::new(tx);
 /// writer.write("hello, world".as_bytes());
 /// ```
 pub struct ChanWriter {
-    priv chan: Chan<~[u8]>,
+    priv tx: Sender<~[u8]>,
 }
 
 impl ChanWriter {
     /// Wraps a channel in a `ChanWriter` structure
-    pub fn new(chan: Chan<~[u8]>) -> ChanWriter {
-        ChanWriter { chan: chan }
+    pub fn new(tx: Sender<~[u8]>) -> ChanWriter {
+        ChanWriter { tx: tx }
     }
 }
 
 impl Clone for ChanWriter {
     fn clone(&self) -> ChanWriter {
-        ChanWriter { chan: self.chan.clone() }
+        ChanWriter { tx: self.tx.clone() }
     }
 }
 
 impl Writer for ChanWriter {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
-        if !self.chan.try_send(buf.to_owned()) {
+        if !self.tx.try_send(buf.to_owned()) {
             Err(io::IoError {
                 kind: io::BrokenPipe,
                 desc: "Pipe closed",
@@ -136,17 +137,17 @@ mod test {
     use task;
 
     #[test]
-    fn test_port_reader() {
-        let (port, chan) = Chan::new();
+    fn test_rx_reader() {
+        let (tx, rx) = channel();
         task::spawn(proc() {
-          chan.send(~[1u8, 2u8]);
-          chan.send(~[]);
-          chan.send(~[3u8, 4u8]);
-          chan.send(~[5u8, 6u8]);
-          chan.send(~[7u8, 8u8]);
+          tx.send(~[1u8, 2u8]);
+          tx.send(~[]);
+          tx.send(~[3u8, 4u8]);
+          tx.send(~[5u8, 6u8]);
+          tx.send(~[7u8, 8u8]);
         });
 
-        let mut reader = PortReader::new(port);
+        let mut reader = ChanReader::new(rx);
         let mut buf = ~[0u8, ..3];
 
 
@@ -177,12 +178,12 @@ mod test {
 
     #[test]
     fn test_chan_writer() {
-        let (port, chan) = Chan::new();
-        let mut writer = ChanWriter::new(chan);
+        let (tx, rx) = channel();
+        let mut writer = ChanWriter::new(tx);
         writer.write_be_u32(42).unwrap();
 
         let wanted = ~[0u8, 0u8, 0u8, 42u8];
-        let got = task::try(proc() { port.recv() }).unwrap();
+        let got = task::try(proc() { rx.recv() }).unwrap();
         assert_eq!(wanted, got);
 
         match writer.write_u8(1) {
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 3aaee59288f..869643336a9 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -245,7 +245,7 @@ pub use self::process::{Process, ProcessConfig};
 pub use self::mem::{MemReader, BufReader, MemWriter, BufWriter};
 pub use self::buffered::{BufferedReader, BufferedWriter, BufferedStream,
                          LineBufferedWriter};
-pub use self::comm_adapters::{PortReader, ChanWriter};
+pub use self::comm_adapters::{ChanReader, ChanWriter};
 
 pub mod test;
 
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index 53129f3df9b..edadbc7873a 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -195,16 +195,13 @@ mod test {
 
     iotest!(fn smoke_test_ip4() {
         let addr = next_test_ip4();
-        let (port, chan) = Chan::new();
+        let mut acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            port.recv();
             let mut stream = TcpStream::connect(addr);
             stream.write([99]).unwrap();
         });
 
-        let mut acceptor = TcpListener::bind(addr).listen();
-        chan.send(());
         let mut stream = acceptor.accept();
         let mut buf = [0];
         stream.read(buf).unwrap();
@@ -213,16 +210,13 @@ mod test {
 
     iotest!(fn smoke_test_ip6() {
         let addr = next_test_ip6();
-        let (port, chan) = Chan::new();
+        let mut acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            port.recv();
             let mut stream = TcpStream::connect(addr);
             stream.write([99]).unwrap();
         });
 
-        let mut acceptor = TcpListener::bind(addr).listen();
-        chan.send(());
         let mut stream = acceptor.accept();
         let mut buf = [0];
         stream.read(buf).unwrap();
@@ -231,16 +225,13 @@ mod test {
 
     iotest!(fn read_eof_ip4() {
         let addr = next_test_ip4();
-        let (port, chan) = Chan::new();
+        let mut acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            port.recv();
             let _stream = TcpStream::connect(addr);
             // Close
         });
 
-        let mut acceptor = TcpListener::bind(addr).listen();
-        chan.send(());
         let mut stream = acceptor.accept();
         let mut buf = [0];
         let nread = stream.read(buf);
@@ -249,16 +240,13 @@ mod test {
 
     iotest!(fn read_eof_ip6() {
         let addr = next_test_ip6();
-        let (port, chan) = Chan::new();
+        let mut acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            port.recv();
             let _stream = TcpStream::connect(addr);
             // Close
         });
 
-        let mut acceptor = TcpListener::bind(addr).listen();
-        chan.send(());
         let mut stream = acceptor.accept();
         let mut buf = [0];
         let nread = stream.read(buf);
@@ -267,16 +255,13 @@ mod test {
 
     iotest!(fn read_eof_twice_ip4() {
         let addr = next_test_ip4();
-        let (port, chan) = Chan::new();
+        let mut acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            port.recv();
             let _stream = TcpStream::connect(addr);
             // Close
         });
 
-        let mut acceptor = TcpListener::bind(addr).listen();
-        chan.send(());
         let mut stream = acceptor.accept();
         let mut buf = [0];
         let nread = stream.read(buf);
@@ -293,16 +278,13 @@ mod test {
 
     iotest!(fn read_eof_twice_ip6() {
         let addr = next_test_ip6();
-        let (port, chan) = Chan::new();
+        let mut acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            port.recv();
             let _stream = TcpStream::connect(addr);
             // Close
         });
 
-        let mut acceptor = TcpListener::bind(addr).listen();
-        chan.send(());
         let mut stream = acceptor.accept();
         let mut buf = [0];
         let nread = stream.read(buf);
@@ -319,16 +301,13 @@ mod test {
 
     iotest!(fn write_close_ip4() {
         let addr = next_test_ip4();
-        let (port, chan) = Chan::new();
+        let mut acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            port.recv();
             let _stream = TcpStream::connect(addr);
             // Close
         });
 
-        let mut acceptor = TcpListener::bind(addr).listen();
-        chan.send(());
         let mut stream = acceptor.accept();
         let buf = [0];
         loop {
@@ -347,16 +326,13 @@ mod test {
 
     iotest!(fn write_close_ip6() {
         let addr = next_test_ip6();
-        let (port, chan) = Chan::new();
+        let mut acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            port.recv();
             let _stream = TcpStream::connect(addr);
             // Close
         });
 
-        let mut acceptor = TcpListener::bind(addr).listen();
-        chan.send(());
         let mut stream = acceptor.accept();
         let buf = [0];
         loop {
@@ -376,18 +352,15 @@ mod test {
     iotest!(fn multiple_connect_serial_ip4() {
         let addr = next_test_ip4();
         let max = 10u;
-        let (port, chan) = Chan::new();
+        let mut acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            port.recv();
             for _ in range(0, max) {
                 let mut stream = TcpStream::connect(addr);
                 stream.write([99]).unwrap();
             }
         });
 
-        let mut acceptor = TcpListener::bind(addr).listen();
-        chan.send(());
         for ref mut stream in acceptor.incoming().take(max) {
             let mut buf = [0];
             stream.read(buf).unwrap();
@@ -398,18 +371,15 @@ mod test {
     iotest!(fn multiple_connect_serial_ip6() {
         let addr = next_test_ip6();
         let max = 10u;
-        let (port, chan) = Chan::new();
+        let mut acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            port.recv();
             for _ in range(0, max) {
                 let mut stream = TcpStream::connect(addr);
                 stream.write([99]).unwrap();
             }
         });
 
-        let mut acceptor = TcpListener::bind(addr).listen();
-        chan.send(());
         for ref mut stream in acceptor.incoming().take(max) {
             let mut buf = [0];
             stream.read(buf).unwrap();
@@ -420,11 +390,10 @@ mod test {
     iotest!(fn multiple_connect_interleaved_greedy_schedule_ip4() {
         let addr = next_test_ip4();
         static MAX: int = 10;
-        let (port, chan) = Chan::new();
+        let acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            let mut acceptor = TcpListener::bind(addr).listen();
-            chan.send(());
+            let mut acceptor = acceptor;
             for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
                 // Start another task to handle the connection
                 spawn(proc() {
@@ -437,7 +406,6 @@ mod test {
             }
         });
 
-        port.recv();
         connect(0, addr);
 
         fn connect(i: int, addr: SocketAddr) {
@@ -457,11 +425,10 @@ mod test {
     iotest!(fn multiple_connect_interleaved_greedy_schedule_ip6() {
         let addr = next_test_ip6();
         static MAX: int = 10;
-        let (port, chan) = Chan::<()>::new();
+        let acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            let mut acceptor = TcpListener::bind(addr).listen();
-            chan.send(());
+            let mut acceptor = acceptor;
             for (i, stream) in acceptor.incoming().enumerate().take(MAX as uint) {
                 // Start another task to handle the connection
                 spawn(proc() {
@@ -474,7 +441,6 @@ mod test {
             }
         });
 
-        port.recv();
         connect(0, addr);
 
         fn connect(i: int, addr: SocketAddr) {
@@ -492,13 +458,12 @@ mod test {
     })
 
     iotest!(fn multiple_connect_interleaved_lazy_schedule_ip4() {
-        let addr = next_test_ip4();
         static MAX: int = 10;
-        let (port, chan) = Chan::new();
+        let addr = next_test_ip4();
+        let acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            let mut acceptor = TcpListener::bind(addr).listen();
-            chan.send(());
+            let mut acceptor = acceptor;
             for stream in acceptor.incoming().take(MAX as uint) {
                 // Start another task to handle the connection
                 spawn(proc() {
@@ -511,7 +476,6 @@ mod test {
             }
         });
 
-        port.recv();
         connect(0, addr);
 
         fn connect(i: int, addr: SocketAddr) {
@@ -529,13 +493,12 @@ mod test {
     })
 
     iotest!(fn multiple_connect_interleaved_lazy_schedule_ip6() {
-        let addr = next_test_ip6();
         static MAX: int = 10;
-        let (port, chan) = Chan::new();
+        let addr = next_test_ip6();
+        let acceptor = TcpListener::bind(addr).listen();
 
         spawn(proc() {
-            let mut acceptor = TcpListener::bind(addr).listen();
-            chan.send(());
+            let mut acceptor = acceptor;
             for stream in acceptor.incoming().take(MAX as uint) {
                 // Start another task to handle the connection
                 spawn(proc() {
@@ -548,7 +511,6 @@ mod test {
             }
         });
 
-        port.recv();
         connect(0, addr);
 
         fn connect(i: int, addr: SocketAddr) {
@@ -576,15 +538,12 @@ mod test {
     }
 
     pub fn peer_name(addr: SocketAddr) {
-        let (port, chan) = Chan::new();
-
+        let acceptor = TcpListener::bind(addr).listen();
         spawn(proc() {
-            let mut acceptor = TcpListener::bind(addr).listen();
-            chan.send(());
+            let mut acceptor = acceptor;
             acceptor.accept().unwrap();
         });
 
-        port.recv();
         let stream = TcpStream::connect(addr);
 
         assert!(stream.is_ok());
@@ -611,23 +570,23 @@ mod test {
 
     iotest!(fn partial_read() {
         let addr = next_test_ip4();
-        let (p, c) = Chan::new();
+        let (tx, rx) = channel();
         spawn(proc() {
             let mut srv = TcpListener::bind(addr).listen().unwrap();
-            c.send(());
+            tx.send(());
             let mut cl = srv.accept().unwrap();
             cl.write([10]).unwrap();
             let mut b = [0];
             cl.read(b).unwrap();
-            c.send(());
+            tx.send(());
         });
 
-        p.recv();
+        rx.recv();
         let mut c = TcpStream::connect(addr).unwrap();
         let mut b = [0, ..10];
         assert_eq!(c.read(b), Ok(1));
         c.write([1]).unwrap();
-        p.recv();
+        rx.recv();
     })
 
     iotest!(fn double_bind() {
@@ -644,22 +603,22 @@ mod test {
 
     iotest!(fn fast_rebind() {
         let addr = next_test_ip4();
-        let (port, chan) = Chan::new();
+        let (tx, rx) = channel();
 
         spawn(proc() {
-            port.recv();
+            rx.recv();
             let _stream = TcpStream::connect(addr).unwrap();
             // Close
-            port.recv();
+            rx.recv();
         });
 
         {
             let mut acceptor = TcpListener::bind(addr).listen();
-            chan.send(());
+            tx.send(());
             {
                 let _stream = acceptor.accept().unwrap();
                 // Close client
-                chan.send(());
+                tx.send(());
             }
             // Close listener
         }
@@ -681,50 +640,50 @@ mod test {
         let mut s1 = acceptor.accept().unwrap();
         let s2 = s1.clone();
 
-        let (p1, c1) = Chan::new();
-        let (p2, c2) = Chan::new();
+        let (tx1, rx1) = channel();
+        let (tx2, rx2) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            p1.recv();
+            rx1.recv();
             s2.write([1]).unwrap();
-            c2.send(());
+            tx2.send(());
         });
-        c1.send(());
+        tx1.send(());
         let mut buf = [0, 0];
         assert_eq!(s1.read(buf), Ok(1));
-        p2.recv();
+        rx2.recv();
     })
 
     iotest!(fn tcp_clone_two_read() {
         let addr = next_test_ip6();
         let mut acceptor = TcpListener::bind(addr).listen();
-        let (p, c) = Chan::new();
-        let c2 = c.clone();
+        let (tx1, rx) = channel();
+        let tx2 = tx1.clone();
 
         spawn(proc() {
             let mut s = TcpStream::connect(addr);
             s.write([1]).unwrap();
-            p.recv();
+            rx.recv();
             s.write([2]).unwrap();
-            p.recv();
+            rx.recv();
         });
 
         let mut s1 = acceptor.accept().unwrap();
         let s2 = s1.clone();
 
-        let (p, done) = Chan::new();
+        let (done, rx) = channel();
         spawn(proc() {
             let mut s2 = s2;
             let mut buf = [0, 0];
             s2.read(buf).unwrap();
-            c2.send(());
+            tx2.send(());
             done.send(());
         });
         let mut buf = [0, 0];
         s1.read(buf).unwrap();
-        c.send(());
+        tx1.send(());
 
-        p.recv();
+        rx.recv();
     })
 
     iotest!(fn tcp_clone_two_write() {
@@ -741,7 +700,7 @@ mod test {
         let mut s1 = acceptor.accept().unwrap();
         let s2 = s1.clone();
 
-        let (p, done) = Chan::new();
+        let (done, rx) = channel();
         spawn(proc() {
             let mut s2 = s2;
             s2.write([1]).unwrap();
@@ -749,7 +708,7 @@ mod test {
         });
         s1.write([2]).unwrap();
 
-        p.recv();
+        rx.recv();
     })
 }
 
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index 8eaa86ea707..e2620556321 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -107,23 +107,23 @@ mod test {
     iotest!(fn socket_smoke_test_ip4() {
         let server_ip = next_test_ip4();
         let client_ip = next_test_ip4();
-        let (port, chan) = Chan::new();
-        let (port2, chan2) = Chan::new();
+        let (tx1, rx1) = channel();
+        let (tx2, rx2) = channel();
 
         spawn(proc() {
             match UdpSocket::bind(client_ip) {
                 Ok(ref mut client) => {
-                    port.recv();
+                    rx1.recv();
                     client.sendto([99], server_ip).unwrap()
                 }
                 Err(..) => fail!()
             }
-            chan2.send(());
+            tx2.send(());
         });
 
         match UdpSocket::bind(server_ip) {
             Ok(ref mut server) => {
-                chan.send(());
+                tx1.send(());
                 let mut buf = [0];
                 match server.recvfrom(buf) {
                     Ok((nread, src)) => {
@@ -136,18 +136,18 @@ mod test {
             }
             Err(..) => fail!()
         }
-        port2.recv();
+        rx2.recv();
     })
 
     iotest!(fn socket_smoke_test_ip6() {
         let server_ip = next_test_ip6();
         let client_ip = next_test_ip6();
-        let (port, chan) = Chan::<()>::new();
+        let (tx, rx) = channel::<()>();
 
         spawn(proc() {
             match UdpSocket::bind(client_ip) {
                 Ok(ref mut client) => {
-                    port.recv();
+                    rx.recv();
                     client.sendto([99], server_ip).unwrap()
                 }
                 Err(..) => fail!()
@@ -156,7 +156,7 @@ mod test {
 
         match UdpSocket::bind(server_ip) {
             Ok(ref mut server) => {
-                chan.send(());
+                tx.send(());
                 let mut buf = [0];
                 match server.recvfrom(buf) {
                     Ok((nread, src)) => {
@@ -174,27 +174,27 @@ mod test {
     iotest!(fn stream_smoke_test_ip4() {
         let server_ip = next_test_ip4();
         let client_ip = next_test_ip4();
-        let (port, chan) = Chan::new();
-        let (port2, chan2) = Chan::new();
+        let (tx1, rx1) = channel();
+        let (tx2, rx2) = channel();
 
         spawn(proc() {
             match UdpSocket::bind(client_ip) {
                 Ok(client) => {
                     let client = ~client;
                     let mut stream = client.connect(server_ip);
-                    port.recv();
+                    rx1.recv();
                     stream.write([99]).unwrap();
                 }
                 Err(..) => fail!()
             }
-            chan2.send(());
+            tx2.send(());
         });
 
         match UdpSocket::bind(server_ip) {
             Ok(server) => {
                 let server = ~server;
                 let mut stream = server.connect(client_ip);
-                chan.send(());
+                tx1.send(());
                 let mut buf = [0];
                 match stream.read(buf) {
                     Ok(nread) => {
@@ -206,33 +206,33 @@ mod test {
             }
             Err(..) => fail!()
         }
-        port2.recv();
+        rx2.recv();
     })
 
     iotest!(fn stream_smoke_test_ip6() {
         let server_ip = next_test_ip6();
         let client_ip = next_test_ip6();
-        let (port, chan) = Chan::new();
-        let (port2, chan2) = Chan::new();
+        let (tx1, rx1) = channel();
+        let (tx2, rx2) = channel();
 
         spawn(proc() {
             match UdpSocket::bind(client_ip) {
                 Ok(client) => {
                     let client = ~client;
                     let mut stream = client.connect(server_ip);
-                    port.recv();
+                    rx1.recv();
                     stream.write([99]).unwrap();
                 }
                 Err(..) => fail!()
             }
-            chan2.send(());
+            tx2.send(());
         });
 
         match UdpSocket::bind(server_ip) {
             Ok(server) => {
                 let server = ~server;
                 let mut stream = server.connect(client_ip);
-                chan.send(());
+                tx1.send(());
                 let mut buf = [0];
                 match stream.read(buf) {
                     Ok(nread) => {
@@ -244,7 +244,7 @@ mod test {
             }
             Err(..) => fail!()
         }
-        port2.recv();
+        rx2.recv();
     })
 
     pub fn socket_name(addr: SocketAddr) {
@@ -284,18 +284,18 @@ mod test {
 
         let sock3 = sock1.clone();
 
-        let (p1, c1) = Chan::new();
-        let (p2, c2) = Chan::new();
+        let (tx1, rx1) = channel();
+        let (tx2, rx2) = channel();
         spawn(proc() {
             let mut sock3 = sock3;
-            p1.recv();
+            rx1.recv();
             sock3.sendto([1], addr2).unwrap();
-            c2.send(());
+            tx2.send(());
         });
-        c1.send(());
+        tx1.send(());
         let mut buf = [0, 0];
         assert_eq!(sock1.recvfrom(buf), Ok((1, addr2)));
-        p2.recv();
+        rx2.recv();
     })
 
     iotest!(fn udp_clone_two_read() {
@@ -303,32 +303,32 @@ mod test {
         let addr2 = next_test_ip4();
         let mut sock1 = UdpSocket::bind(addr1).unwrap();
         let sock2 = UdpSocket::bind(addr2).unwrap();
-        let (p, c) = Chan::new();
-        let c2 = c.clone();
+        let (tx1, rx) = channel();
+        let tx2 = tx1.clone();
 
         spawn(proc() {
             let mut sock2 = sock2;
             sock2.sendto([1], addr1).unwrap();
-            p.recv();
+            rx.recv();
             sock2.sendto([2], addr1).unwrap();
-            p.recv();
+            rx.recv();
         });
 
         let sock3 = sock1.clone();
 
-        let (p, done) = Chan::new();
+        let (done, rx) = channel();
         spawn(proc() {
             let mut sock3 = sock3;
             let mut buf = [0, 0];
             sock3.recvfrom(buf).unwrap();
-            c2.send(());
+            tx2.send(());
             done.send(());
         });
         let mut buf = [0, 0];
         sock1.recvfrom(buf).unwrap();
-        c.send(());
+        tx1.send(());
 
-        p.recv();
+        rx.recv();
     })
 
     iotest!(fn udp_clone_two_write() {
@@ -337,40 +337,40 @@ mod test {
         let mut sock1 = UdpSocket::bind(addr1).unwrap();
         let sock2 = UdpSocket::bind(addr2).unwrap();
 
-        let (p, c) = Chan::new();
-        let (serv_port, serv_chan) = Chan::new();
+        let (tx, rx) = channel();
+        let (serv_tx, serv_rx) = channel();
 
         spawn(proc() {
             let mut sock2 = sock2;
             let mut buf = [0, 1];
 
-            p.recv();
+            rx.recv();
             match sock2.recvfrom(buf) {
                 Ok(..) => {}
                 Err(e) => fail!("failed receive: {}", e),
             }
-            serv_chan.send(());
+            serv_tx.send(());
         });
 
         let sock3 = sock1.clone();
 
-        let (p, done) = Chan::new();
-        let c2 = c.clone();
+        let (done, rx) = channel();
+        let tx2 = tx.clone();
         spawn(proc() {
             let mut sock3 = sock3;
             match sock3.sendto([1], addr2) {
-                Ok(..) => { let _ = c2.try_send(()); }
+                Ok(..) => { let _ = tx2.try_send(()); }
                 Err(..) => {}
             }
             done.send(());
         });
         match sock1.sendto([2], addr2) {
-            Ok(..) => { let _ = c.try_send(()); }
+            Ok(..) => { let _ = tx.try_send(()); }
             Err(..) => {}
         }
-        drop(c);
+        drop(tx);
 
-        p.recv();
-        serv_port.recv();
+        rx.recv();
+        serv_rx.recv();
     })
 }
diff --git a/src/libstd/io/net/unix.rs b/src/libstd/io/net/unix.rs
index 64586113a10..bd715858a01 100644
--- a/src/libstd/io/net/unix.rs
+++ b/src/libstd/io/net/unix.rs
@@ -224,10 +224,13 @@ mod tests {
         let times = 10;
         let path1 = next_test_unix();
         let path2 = path1.clone();
-        let (port, chan) = Chan::new();
+
+        let mut acceptor = match UnixListener::bind(&path1).listen() {
+            Ok(a) => a,
+            Err(e) => fail!("failed listen: {}", e),
+        };
 
         spawn(proc() {
-            port.recv();
             for _ in range(0, times) {
                 let mut stream = UnixStream::connect(&path2);
                 match stream.write([100]) {
@@ -237,11 +240,6 @@ mod tests {
             }
         });
 
-        let mut acceptor = match UnixListener::bind(&path1).listen() {
-            Ok(a) => a,
-            Err(e) => fail!("failed listen: {}", e),
-        };
-        chan.send(());
         for _ in range(0, times) {
             let mut client = acceptor.accept();
             let mut buf = [0];
@@ -278,54 +276,54 @@ mod tests {
         let mut s1 = acceptor.accept().unwrap();
         let s2 = s1.clone();
 
-        let (p1, c1) = Chan::new();
-        let (p2, c2) = Chan::new();
+        let (tx1, rx1) = channel();
+        let (tx2, rx2) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            p1.recv();
+            rx1.recv();
             debug!("writer writing");
             s2.write([1]).unwrap();
             debug!("writer done");
-            c2.send(());
+            tx2.send(());
         });
-        c1.send(());
+        tx1.send(());
         let mut buf = [0, 0];
         debug!("reader reading");
         assert_eq!(s1.read(buf), Ok(1));
         debug!("reader done");
-        p2.recv();
+        rx2.recv();
     })
 
     iotest!(fn unix_clone_two_read() {
         let addr = next_test_unix();
         let mut acceptor = UnixListener::bind(&addr).listen();
-        let (p, c) = Chan::new();
-        let c2 = c.clone();
+        let (tx1, rx) = channel();
+        let tx2 = tx1.clone();
 
         spawn(proc() {
             let mut s = UnixStream::connect(&addr);
             s.write([1]).unwrap();
-            p.recv();
+            rx.recv();
             s.write([2]).unwrap();
-            p.recv();
+            rx.recv();
         });
 
         let mut s1 = acceptor.accept().unwrap();
         let s2 = s1.clone();
 
-        let (p, done) = Chan::new();
+        let (done, rx) = channel();
         spawn(proc() {
             let mut s2 = s2;
             let mut buf = [0, 0];
             s2.read(buf).unwrap();
-            c2.send(());
+            tx2.send(());
             done.send(());
         });
         let mut buf = [0, 0];
         s1.read(buf).unwrap();
-        c.send(());
+        tx1.send(());
 
-        p.recv();
+        rx.recv();
     })
 
     iotest!(fn unix_clone_two_write() {
@@ -342,14 +340,14 @@ mod tests {
         let mut s1 = acceptor.accept().unwrap();
         let s2 = s1.clone();
 
-        let (p, done) = Chan::new();
+        let (tx, rx) = channel();
         spawn(proc() {
             let mut s2 = s2;
             s2.write([1]).unwrap();
-            done.send(());
+            tx.send(());
         });
         s1.write([2]).unwrap();
 
-        p.recv();
+        rx.recv();
     })
 }
diff --git a/src/libstd/io/pipe.rs b/src/libstd/io/pipe.rs
index 763f2d6c6a1..02dfaeb7164 100644
--- a/src/libstd/io/pipe.rs
+++ b/src/libstd/io/pipe.rs
@@ -77,15 +77,15 @@ mod test {
         let os::Pipe { input, out } = os::pipe();
         let out = PipeStream::open(out);
         let mut input = PipeStream::open(input);
-        let (p, c) = Chan::new();
+        let (tx, rx) = channel();
         spawn(proc() {
             let mut out = out;
             out.write([10]).unwrap();
-            p.recv(); // don't close the pipe until the other read has finished
+            rx.recv(); // don't close the pipe until the other read has finished
         });
 
         let mut buf = [0, ..10];
         input.read(buf).unwrap();
-        c.send(());
+        tx.send(());
     })
 }
diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs
index b782cf1d21a..6afd1bbb27d 100644
--- a/src/libstd/io/process.rs
+++ b/src/libstd/io/process.rs
@@ -379,16 +379,16 @@ impl Process {
     /// The stdin handle to the child is closed before waiting.
     pub fn wait_with_output(&mut self) -> ProcessOutput {
         drop(self.stdin.take());
-        fn read(stream: Option<io::PipeStream>) -> Port<IoResult<~[u8]>> {
-            let (p, c) = Chan::new();
+        fn read(stream: Option<io::PipeStream>) -> Receiver<IoResult<~[u8]>> {
+            let (tx, rx) = channel();
             match stream {
                 Some(stream) => spawn(proc() {
                     let mut stream = stream;
-                    c.send(stream.read_to_end())
+                    tx.send(stream.read_to_end())
                 }),
-                None => c.send(Ok(~[]))
+                None => tx.send(Ok(~[]))
             }
-            p
+            rx
         }
         let stdout = read(self.stdout.take());
         let stderr = read(self.stderr.take());
diff --git a/src/libstd/io/signal.rs b/src/libstd/io/signal.rs
index 63df3d2c4f1..c66fcd13917 100644
--- a/src/libstd/io/signal.rs
+++ b/src/libstd/io/signal.rs
@@ -20,7 +20,7 @@ definitions for a number of signals.
 */
 
 use clone::Clone;
-use comm::{Port, Chan};
+use comm::{Sender, Receiver, channel};
 use io;
 use iter::Iterator;
 use mem::drop;
@@ -56,7 +56,7 @@ pub enum Signum {
     WindowSizeChange = 28i,
 }
 
-/// Listener provides a port to listen for registered signals.
+/// Listener provides a receiver to listen for registered signals.
 ///
 /// Listener automatically unregisters its handles once it is out of scope.
 /// However, clients can still unregister signums manually.
@@ -71,7 +71,7 @@ pub enum Signum {
 ///
 /// spawn({
 ///     loop {
-///         match listener.port.recv() {
+///         match listener.rx.recv() {
 ///             Interrupt => println!("Got Interrupt'ed"),
 ///             _ => (),
 ///         }
@@ -82,24 +82,24 @@ pub enum Signum {
 pub struct Listener {
     /// A map from signums to handles to keep the handles in memory
     priv handles: ~[(Signum, ~RtioSignal)],
-    /// chan is where all the handles send signums, which are received by
-    /// the clients from port.
-    priv chan: Chan<Signum>,
+    /// This is where all the handles send signums, which are received by
+    /// the clients from the receiver.
+    priv tx: Sender<Signum>,
 
-    /// Clients of Listener can `recv()` from this port. This is exposed to
-    /// allow selection over this port as well as manipulation of the port
+    /// Clients of Listener can `recv()` on this receiver. This is exposed to
+    /// allow selection over it as well as manipulation of the receiver
     /// directly.
-    port: Port<Signum>,
+    rx: Receiver<Signum>,
 }
 
 impl Listener {
     /// Creates a new listener for signals. Once created, signals are bound via
     /// the `register` method (otherwise nothing will ever be received)
     pub fn new() -> Listener {
-        let (port, chan) = Chan::new();
+        let (tx, rx) = channel();
         Listener {
-            chan: chan,
-            port: port,
+            tx: tx,
+            rx: rx,
             handles: ~[],
         }
     }
@@ -125,7 +125,7 @@ impl Listener {
             return Ok(()); // self is already listening to signum, so succeed
         }
         match LocalIo::maybe_raise(|io| {
-            io.signal(signum, self.chan.clone())
+            io.signal(signum, self.tx.clone())
         }) {
             Ok(handle) => {
                 self.handles.push((signum, handle));
@@ -166,7 +166,7 @@ mod test_unix {
         signal.register(Interrupt).unwrap();
         sigint();
         timer::sleep(10);
-        match signal.port.recv() {
+        match signal.rx.recv() {
             Interrupt => (),
             s => fail!("Expected Interrupt, got {:?}", s),
         }
@@ -180,11 +180,11 @@ mod test_unix {
         s2.register(Interrupt).unwrap();
         sigint();
         timer::sleep(10);
-        match s1.port.recv() {
+        match s1.rx.recv() {
             Interrupt => (),
             s => fail!("Expected Interrupt, got {:?}", s),
         }
-        match s2.port.recv() {
+        match s2.rx.recv() {
             Interrupt => (),
             s => fail!("Expected Interrupt, got {:?}", s),
         }
@@ -199,7 +199,7 @@ mod test_unix {
         s2.unregister(Interrupt);
         sigint();
         timer::sleep(10);
-        assert_eq!(s2.port.try_recv(), Empty);
+        assert_eq!(s2.rx.try_recv(), Empty);
     }
 }
 
diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index 241f3d23c6b..7c65e76ab47 100644
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -388,10 +388,10 @@ mod tests {
     })
 
     iotest!(fn capture_stdout() {
-        use io::comm_adapters::{PortReader, ChanWriter};
+        use io::{ChanReader, ChanWriter};
 
-        let (p, c) = Chan::new();
-        let (mut r, w) = (PortReader::new(p), ChanWriter::new(c));
+        let (tx, rx) = channel();
+        let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx));
         spawn(proc() {
             set_stdout(~w as ~Writer);
             println!("hello!");
@@ -400,10 +400,10 @@ mod tests {
     })
 
     iotest!(fn capture_stderr() {
-        use io::comm_adapters::{PortReader, ChanWriter};
+        use io::{ChanReader, ChanWriter};
 
-        let (p, c) = Chan::new();
-        let (mut r, w) = (PortReader::new(p), ChanWriter::new(c));
+        let (tx, rx) = channel();
+        let (mut r, w) = (ChanReader::new(rx), ChanWriter::new(tx));
         spawn(proc() {
             set_stderr(~w as ~Writer);
             fail!("my special message");
diff --git a/src/libstd/io/test.rs b/src/libstd/io/test.rs
index 73d52654ebf..a3e5bac89d6 100644
--- a/src/libstd/io/test.rs
+++ b/src/libstd/io/test.rs
@@ -46,9 +46,9 @@ macro_rules! iotest (
             $($a)* #[test] fn green() { f() }
             $($a)* #[test] fn native() {
                 use native;
-                let (p, c) = Chan::new();
-                native::task::spawn(proc() { c.send(f()) });
-                p.recv();
+                let (tx, rx) = channel();
+                native::task::spawn(proc() { tx.send(f()) });
+                rx.recv();
             }
         }
     )
diff --git a/src/libstd/io/timer.rs b/src/libstd/io/timer.rs
index 8a13277aee3..f64c36c611c 100644
--- a/src/libstd/io/timer.rs
+++ b/src/libstd/io/timer.rs
@@ -13,11 +13,11 @@
 Synchronous Timers
 
 This module exposes the functionality to create timers, block the current task,
-and create ports which will receive notifications after a period of time.
+and create receivers which will receive notifications after a period of time.
 
 */
 
-use comm::Port;
+use comm::Receiver;
 use rt::rtio::{IoFactory, LocalIo, RtioTimer};
 use io::IoResult;
 
@@ -25,7 +25,7 @@ use io::IoResult;
 ///
 /// Values of this type can be used to put the current task to sleep for a
 /// period of time. Handles to this timer can also be created in the form of
-/// ports which will receive notifications over time.
+/// receivers which will receive notifications over time.
 ///
 /// # Example
 ///
@@ -83,33 +83,33 @@ impl Timer {
 
     /// Blocks the current task for `msecs` milliseconds.
     ///
-    /// Note that this function will cause any other ports for this timer to be
-    /// invalidated (the other end will be closed).
+    /// Note that this function will cause any other receivers for this timer to
+    /// be invalidated (the other end will be closed).
     pub fn sleep(&mut self, msecs: u64) {
         self.obj.sleep(msecs);
     }
 
-    /// Creates a oneshot port which will have a notification sent when `msecs`
-    /// milliseconds has elapsed. This does *not* block the current task, but
-    /// instead returns immediately.
+    /// Creates a oneshot receiver which will have a notification sent when
+    /// `msecs` milliseconds has elapsed. This does *not* block the current
+    /// task, but instead returns immediately.
     ///
-    /// Note that this invalidates any previous port which has been created by
-    /// this timer, and that the returned port will be invalidated once the
-    /// timer is destroyed (when it falls out of scope).
-    pub fn oneshot(&mut self, msecs: u64) -> Port<()> {
+    /// Note that this invalidates any previous receiver which has been created
+    /// by this timer, and that the returned receiver will be invalidated once
+    /// the timer is destroyed (when it falls out of scope).
+    pub fn oneshot(&mut self, msecs: u64) -> Receiver<()> {
         self.obj.oneshot(msecs)
     }
 
-    /// Creates a port which will have a continuous stream of notifications
+    /// Creates a receiver which will have a continuous stream of notifications
     /// being sent every `msecs` milliseconds. This does *not* block the
     /// current task, but instead returns immediately. The first notification
     /// will not be received immediately, but rather after `msec` milliseconds
     /// have passed.
     ///
-    /// Note that this invalidates any previous port which has been created by
-    /// this timer, and that the returned port will be invalidated once the
-    /// timer is destroyed (when it falls out of scope).
-    pub fn periodic(&mut self, msecs: u64) -> Port<()> {
+    /// Note that this invalidates any previous receiver which has been created
+    /// by this timer, and that the returned receiver will be invalidated once
+    /// the timer is destroyed (when it falls out of scope).
+    pub fn periodic(&mut self, msecs: u64) -> Receiver<()> {
         self.obj.period(msecs)
     }
 }
@@ -133,26 +133,26 @@ mod test {
 
     iotest!(fn oneshot_twice() {
         let mut timer = Timer::new().unwrap();
-        let port1 = timer.oneshot(10000);
-        let port = timer.oneshot(1);
-        port.recv();
-        assert_eq!(port1.recv_opt(), None);
+        let rx1 = timer.oneshot(10000);
+        let rx = timer.oneshot(1);
+        rx.recv();
+        assert_eq!(rx1.recv_opt(), None);
     })
 
     iotest!(fn test_io_timer_oneshot_then_sleep() {
         let mut timer = Timer::new().unwrap();
-        let port = timer.oneshot(100000000000);
-        timer.sleep(1); // this should invalidate the port
+        let rx = timer.oneshot(100000000000);
+        timer.sleep(1); // this should inalidate rx
 
-        assert_eq!(port.recv_opt(), None);
+        assert_eq!(rx.recv_opt(), None);
     })
 
     iotest!(fn test_io_timer_sleep_periodic() {
         let mut timer = Timer::new().unwrap();
-        let port = timer.periodic(1);
-        port.recv();
-        port.recv();
-        port.recv();
+        let rx = timer.periodic(1);
+        rx.recv();
+        rx.recv();
+        rx.recv();
     })
 
     iotest!(fn test_io_timer_sleep_periodic_forget() {
@@ -167,33 +167,33 @@ mod test {
     iotest!(fn oneshot() {
         let mut timer = Timer::new().unwrap();
 
-        let port = timer.oneshot(1);
-        port.recv();
-        assert!(port.recv_opt().is_none());
+        let rx = timer.oneshot(1);
+        rx.recv();
+        assert!(rx.recv_opt().is_none());
 
-        let port = timer.oneshot(1);
-        port.recv();
-        assert!(port.recv_opt().is_none());
+        let rx = timer.oneshot(1);
+        rx.recv();
+        assert!(rx.recv_opt().is_none());
     })
 
     iotest!(fn override() {
         let mut timer = Timer::new().unwrap();
-        let oport = timer.oneshot(100);
-        let pport = timer.periodic(100);
+        let orx = timer.oneshot(100);
+        let prx = timer.periodic(100);
         timer.sleep(1);
-        assert_eq!(oport.recv_opt(), None);
-        assert_eq!(pport.recv_opt(), None);
+        assert_eq!(orx.recv_opt(), None);
+        assert_eq!(prx.recv_opt(), None);
         timer.oneshot(1).recv();
     })
 
     iotest!(fn period() {
         let mut timer = Timer::new().unwrap();
-        let port = timer.periodic(1);
-        port.recv();
-        port.recv();
-        let port2 = timer.periodic(1);
-        port2.recv();
-        port2.recv();
+        let rx = timer.periodic(1);
+        rx.recv();
+        rx.recv();
+        let rx2 = timer.periodic(1);
+        rx2.recv();
+        rx2.recv();
     })
 
     iotest!(fn sleep() {
@@ -204,13 +204,13 @@ mod test {
 
     iotest!(fn oneshot_fail() {
         let mut timer = Timer::new().unwrap();
-        let _port = timer.oneshot(1);
+        let _rx = timer.oneshot(1);
         fail!();
     } #[should_fail])
 
     iotest!(fn period_fail() {
         let mut timer = Timer::new().unwrap();
-        let _port = timer.periodic(1);
+        let _rx = timer.periodic(1);
         fail!();
     } #[should_fail])
 
@@ -222,10 +222,10 @@ mod test {
     iotest!(fn closing_channel_during_drop_doesnt_kill_everything() {
         // see issue #10375
         let mut timer = Timer::new().unwrap();
-        let timer_port = timer.periodic(1000);
+        let timer_rx = timer.periodic(1000);
 
         spawn(proc() {
-            timer_port.recv_opt();
+            timer_rx.recv_opt();
         });
 
         // when we drop the TimerWatcher we're going to destroy the channel,
@@ -235,10 +235,10 @@ mod test {
     iotest!(fn reset_doesnt_switch_tasks() {
         // similar test to the one above.
         let mut timer = Timer::new().unwrap();
-        let timer_port = timer.periodic(1000);
+        let timer_rx = timer.periodic(1000);
 
         spawn(proc() {
-            timer_port.recv_opt();
+            timer_rx.recv_opt();
         });
 
         timer.oneshot(1);
@@ -247,29 +247,29 @@ mod test {
     iotest!(fn reset_doesnt_switch_tasks2() {
         // similar test to the one above.
         let mut timer = Timer::new().unwrap();
-        let timer_port = timer.periodic(1000);
+        let timer_rx = timer.periodic(1000);
 
         spawn(proc() {
-            timer_port.recv_opt();
+            timer_rx.recv_opt();
         });
 
         timer.sleep(1);
     })
 
     iotest!(fn sender_goes_away_oneshot() {
-        let port = {
+        let rx = {
             let mut timer = Timer::new().unwrap();
             timer.oneshot(1000)
         };
-        assert_eq!(port.recv_opt(), None);
+        assert_eq!(rx.recv_opt(), None);
     })
 
     iotest!(fn sender_goes_away_period() {
-        let port = {
+        let rx = {
             let mut timer = Timer::new().unwrap();
             timer.periodic(1000)
         };
-        assert_eq!(port.recv_opt(), None);
+        assert_eq!(rx.recv_opt(), None);
     })
 
     iotest!(fn receiver_goes_away_oneshot() {