auto merge of #19027 : nick29581/rust/coercions-4, r=alexcrichton

The forwards compatible parts of #18645, rebased. Converts implicit coercions from `[T, ..n]` to `&[T]` into explicit references.

13 files changed, 294 insertions, 294 deletions

diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index f5c6c15857a..81dc7c8a3ee 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -38,7 +38,7 @@ use vec::Vec;
 /// let mut reader = BufferedReader::new(file);
 ///
 /// let mut buf = [0, ..100];
-/// match reader.read(buf) {
+/// match reader.read(&mut buf) {
 ///     Ok(nread) => println!("Read {} bytes", nread),
 ///     Err(e) => println!("error reading: {}", e)
 /// }
@@ -300,7 +300,7 @@ impl<W: Reader> Reader for InternalBufferedWriter<W> {
 /// stream.flush();
 ///
 /// let mut buf = [0, ..100];
-/// match stream.read(buf) {
+/// match stream.read(&mut buf) {
 ///     Ok(nread) => println!("Read {} bytes", nread),
 ///     Err(e) => println!("error reading: {}", e)
 /// }
@@ -414,35 +414,35 @@ mod test {
         let mut reader = BufferedReader::with_capacity(2, inner);
 
         let mut buf = [0, 0, 0];
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(3), nread);
         let b: &[_] = &[5, 6, 7];
         assert_eq!(buf.as_slice(), b);
 
         let mut buf = [0, 0];
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(2), nread);
         let b: &[_] = &[0, 1];
         assert_eq!(buf.as_slice(), b);
 
         let mut buf = [0];
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(1), nread);
         let b: &[_] = &[2];
         assert_eq!(buf.as_slice(), b);
 
         let mut buf = [0, 0, 0];
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(1), nread);
         let b: &[_] = &[3, 0, 0];
         assert_eq!(buf.as_slice(), b);
 
-        let nread = reader.read(buf);
+        let nread = reader.read(&mut buf);
         assert_eq!(Ok(1), nread);
         let b: &[_] = &[4, 0, 0];
         assert_eq!(buf.as_slice(), b);
 
-        assert!(reader.read(buf).is_err());
+        assert!(reader.read(&mut buf).is_err());
     }
 
     #[test]
@@ -450,36 +450,36 @@ mod test {
         let inner = MemWriter::new();
         let mut writer = BufferedWriter::with_capacity(2, inner);
 
-        writer.write([0, 1]).unwrap();
+        writer.write(&[0, 1]).unwrap();
         let b: &[_] = &[];
         assert_eq!(writer.get_ref().get_ref(), b);
 
-        writer.write([2]).unwrap();
+        writer.write(&[2]).unwrap();
         let b: &[_] = &[0, 1];
         assert_eq!(writer.get_ref().get_ref(), b);
 
-        writer.write([3]).unwrap();
+        writer.write(&[3]).unwrap();
         assert_eq!(writer.get_ref().get_ref(), b);
 
         writer.flush().unwrap();
         let a: &[_] = &[0, 1, 2, 3];
         assert_eq!(a, writer.get_ref().get_ref());
 
-        writer.write([4]).unwrap();
-        writer.write([5]).unwrap();
+        writer.write(&[4]).unwrap();
+        writer.write(&[5]).unwrap();
         assert_eq!(a, writer.get_ref().get_ref());
 
-        writer.write([6]).unwrap();
+        writer.write(&[6]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5];
         assert_eq!(a,
                    writer.get_ref().get_ref());
 
-        writer.write([7, 8]).unwrap();
+        writer.write(&[7, 8]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5, 6];
         assert_eq!(a,
                    writer.get_ref().get_ref());
 
-        writer.write([9, 10, 11]).unwrap();
+        writer.write(&[9, 10, 11]).unwrap();
         let a: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
         assert_eq!(a,
                    writer.get_ref().get_ref());
@@ -492,7 +492,7 @@ mod test {
     #[test]
     fn test_buffered_writer_inner_flushes() {
         let mut w = BufferedWriter::with_capacity(3, MemWriter::new());
-        w.write([0, 1]).unwrap();
+        w.write(&[0, 1]).unwrap();
         let a: &[_] = &[];
         assert_eq!(a, w.get_ref().get_ref());
         let w = w.unwrap();
@@ -518,8 +518,8 @@ mod test {
 
         let mut stream = BufferedStream::new(S);
         let mut buf = [];
-        assert!(stream.read(buf).is_err());
-        stream.write(buf).unwrap();
+        assert!(stream.read(&mut buf).is_err());
+        stream.write(&buf).unwrap();
         stream.flush().unwrap();
     }
 
@@ -537,21 +537,21 @@ mod test {
     #[test]
     fn test_line_buffer() {
         let mut writer = LineBufferedWriter::new(MemWriter::new());
-        writer.write([0]).unwrap();
+        writer.write(&[0]).unwrap();
         let b: &[_] = &[];
         assert_eq!(writer.get_ref().get_ref(), b);
-        writer.write([1]).unwrap();
+        writer.write(&[1]).unwrap();
         assert_eq!(writer.get_ref().get_ref(), b);
         writer.flush().unwrap();
         let b: &[_] = &[0, 1];
         assert_eq!(writer.get_ref().get_ref(), b);
-        writer.write([0, b'\n', 1, b'\n', 2]).unwrap();
+        writer.write(&[0, b'\n', 1, b'\n', 2]).unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n'];
         assert_eq!(writer.get_ref().get_ref(), b);
         writer.flush().unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2];
         assert_eq!(writer.get_ref().get_ref(), b);
-        writer.write([3, b'\n']).unwrap();
+        writer.write(&[3, b'\n']).unwrap();
         let b: &[_] = &[0, 1, 0, b'\n', 1, b'\n', 2, 3, b'\n'];
         assert_eq!(writer.get_ref().get_ref(), b);
     }
@@ -582,26 +582,26 @@ mod test {
         let inner = ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]};
         let mut reader = BufferedReader::new(inner);
         let mut buf = [0, 0];
-        assert_eq!(reader.read(buf), Ok(0));
-        assert_eq!(reader.read(buf), Ok(1));
-        assert_eq!(reader.read(buf), Ok(2));
-        assert_eq!(reader.read(buf), Ok(0));
-        assert_eq!(reader.read(buf), Ok(1));
-        assert_eq!(reader.read(buf), Ok(0));
-        assert!(reader.read(buf).is_err());
+        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf), Ok(1));
+        assert_eq!(reader.read(&mut buf), Ok(2));
+        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert_eq!(reader.read(&mut buf), Ok(1));
+        assert_eq!(reader.read(&mut buf), Ok(0));
+        assert!(reader.read(&mut buf).is_err());
     }
 
     #[test]
     fn read_char_buffered() {
         let buf = [195u8, 159u8];
-        let mut reader = BufferedReader::with_capacity(1, BufReader::new(buf));
+        let mut reader = BufferedReader::with_capacity(1, BufReader::new(&buf));
         assert_eq!(reader.read_char(), Ok('ß'));
     }
 
     #[test]
     fn test_chars() {
         let buf = [195u8, 159u8, b'a'];
-        let mut reader = BufferedReader::with_capacity(1, BufReader::new(buf));
+        let mut reader = BufferedReader::with_capacity(1, BufReader::new(&buf));
         let mut it = reader.chars();
         assert_eq!(it.next(), Some(Ok('ß')));
         assert_eq!(it.next(), Some(Ok('a')));
diff --git a/src/libstd/io/comm_adapters.rs b/src/libstd/io/comm_adapters.rs
index 6b4a952f909..a90b6bbbb8e 100644
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -30,7 +30,7 @@ use vec::Vec;
 /// let mut reader = ChanReader::new(rx);
 ///
 /// let mut buf = [0u8, ..100];
-/// match reader.read(buf) {
+/// match reader.read(&mut buf) {
 ///     Ok(nread) => println!("Read {} bytes", nread),
 ///     Err(e) => println!("read error: {}", e),
 /// }
@@ -172,17 +172,17 @@ mod test {
         let mut reader = ChanReader::new(rx);
         let mut buf = [0u8, ..3];
 
-        assert_eq!(Ok(0), reader.read([]));
+        assert_eq!(Ok(0), reader.read(&mut []));
 
-        assert_eq!(Ok(3), reader.read(buf));
+        assert_eq!(Ok(3), reader.read(&mut buf));
         let a: &[u8] = &[1,2,3];
         assert_eq!(a, buf.as_slice());
 
-        assert_eq!(Ok(3), reader.read(buf));
+        assert_eq!(Ok(3), reader.read(&mut buf));
         let a: &[u8] = &[4,5,6];
         assert_eq!(a, buf.as_slice());
 
-        assert_eq!(Ok(2), reader.read(buf));
+        assert_eq!(Ok(2), reader.read(&mut buf));
         let a: &[u8] = &[7,8,6];
         assert_eq!(a, buf.as_slice());
 
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index 07aa25bc044..70bf90eef93 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -82,9 +82,9 @@ pub fn u64_to_le_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
     assert!(size <= 8u);
     match size {
       1u => f(&[n as u8]),
-      2u => f(unsafe { transmute::<_, [u8, ..2]>((n as u16).to_le()) }),
-      4u => f(unsafe { transmute::<_, [u8, ..4]>((n as u32).to_le()) }),
-      8u => f(unsafe { transmute::<_, [u8, ..8]>(n.to_le()) }),
+      2u => f(unsafe { & transmute::<_, [u8, ..2]>((n as u16).to_le()) }),
+      4u => f(unsafe { & transmute::<_, [u8, ..4]>((n as u32).to_le()) }),
+      8u => f(unsafe { & transmute::<_, [u8, ..8]>(n.to_le()) }),
       _ => {
 
         let mut bytes = vec!();
@@ -121,9 +121,9 @@ pub fn u64_to_be_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
     assert!(size <= 8u);
     match size {
       1u => f(&[n as u8]),
-      2u => f(unsafe { transmute::<_, [u8, ..2]>((n as u16).to_be()) }),
-      4u => f(unsafe { transmute::<_, [u8, ..4]>((n as u32).to_be()) }),
-      8u => f(unsafe { transmute::<_, [u8, ..8]>(n.to_be()) }),
+      2u => f(unsafe { & transmute::<_, [u8, ..2]>((n as u16).to_be()) }),
+      4u => f(unsafe { & transmute::<_, [u8, ..4]>((n as u32).to_be()) }),
+      8u => f(unsafe { & transmute::<_, [u8, ..8]>(n.to_be()) }),
       _ => {
         let mut bytes = vec!();
         let mut i = size;
@@ -474,26 +474,26 @@ mod test {
         let buf = [0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09];
 
         // Aligned access
-        assert_eq!(u64_from_be_bytes(buf, 0, 0), 0);
-        assert_eq!(u64_from_be_bytes(buf, 0, 1), 0x01);
-        assert_eq!(u64_from_be_bytes(buf, 0, 2), 0x0102);
-        assert_eq!(u64_from_be_bytes(buf, 0, 3), 0x010203);
-        assert_eq!(u64_from_be_bytes(buf, 0, 4), 0x01020304);
-        assert_eq!(u64_from_be_bytes(buf, 0, 5), 0x0102030405);
-        assert_eq!(u64_from_be_bytes(buf, 0, 6), 0x010203040506);
-        assert_eq!(u64_from_be_bytes(buf, 0, 7), 0x01020304050607);
-        assert_eq!(u64_from_be_bytes(buf, 0, 8), 0x0102030405060708);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 0), 0);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 1), 0x01);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 2), 0x0102);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 3), 0x010203);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 4), 0x01020304);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 5), 0x0102030405);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 6), 0x010203040506);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 7), 0x01020304050607);
+        assert_eq!(u64_from_be_bytes(&buf, 0, 8), 0x0102030405060708);
 
         // Unaligned access
-        assert_eq!(u64_from_be_bytes(buf, 1, 0), 0);
-        assert_eq!(u64_from_be_bytes(buf, 1, 1), 0x02);
-        assert_eq!(u64_from_be_bytes(buf, 1, 2), 0x0203);
-        assert_eq!(u64_from_be_bytes(buf, 1, 3), 0x020304);
-        assert_eq!(u64_from_be_bytes(buf, 1, 4), 0x02030405);
-        assert_eq!(u64_from_be_bytes(buf, 1, 5), 0x0203040506);
-        assert_eq!(u64_from_be_bytes(buf, 1, 6), 0x020304050607);
-        assert_eq!(u64_from_be_bytes(buf, 1, 7), 0x02030405060708);
-        assert_eq!(u64_from_be_bytes(buf, 1, 8), 0x0203040506070809);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 0), 0);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 1), 0x02);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 2), 0x0203);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 3), 0x020304);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 4), 0x02030405);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 5), 0x0203040506);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 6), 0x020304050607);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 7), 0x02030405060708);
+        assert_eq!(u64_from_be_bytes(&buf, 1, 8), 0x0203040506070809);
     }
 }
 
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index 5c2a5c3512d..3f39dda650a 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -384,7 +384,7 @@ pub fn copy(from: &Path, to: &Path) -> IoResult<()> {
     let mut buf = [0, ..io::DEFAULT_BUF_SIZE];
 
     loop {
-        let amt = match reader.read(buf) {
+        let amt = match reader.read(&mut buf) {
             Ok(n) => n,
             Err(ref e) if e.kind == io::EndOfFile => { break }
             Err(e) => return update_err(Err(e), from, to)
@@ -881,7 +881,7 @@ mod test {
         {
             let mut read_stream = File::open_mode(filename, Open, Read);
             let mut read_buf = [0, .. 1028];
-            let read_str = match check!(read_stream.read(read_buf)) {
+            let read_str = match check!(read_stream.read(&mut read_buf)) {
                 -1|0 => panic!("shouldn't happen"),
                 n => str::from_utf8(read_buf[..n]).unwrap().to_string()
             };
@@ -939,7 +939,7 @@ mod test {
             }
         }
         check!(unlink(filename));
-        let read_str = str::from_utf8(read_mem).unwrap();
+        let read_str = str::from_utf8(&read_mem).unwrap();
         assert_eq!(read_str, message);
     }
 
@@ -960,11 +960,11 @@ mod test {
             let mut read_stream = File::open_mode(filename, Open, Read);
             check!(read_stream.seek(set_cursor as i64, SeekSet));
             tell_pos_pre_read = check!(read_stream.tell());
-            check!(read_stream.read(read_mem));
+            check!(read_stream.read(&mut read_mem));
             tell_pos_post_read = check!(read_stream.tell());
         }
         check!(unlink(filename));
-        let read_str = str::from_utf8(read_mem).unwrap();
+        let read_str = str::from_utf8(&read_mem).unwrap();
         assert_eq!(read_str, message.slice(4, 8));
         assert_eq!(tell_pos_pre_read, set_cursor);
         assert_eq!(tell_pos_post_read, message.len() as u64);
@@ -987,10 +987,10 @@ mod test {
         }
         {
             let mut read_stream = File::open_mode(filename, Open, Read);
-            check!(read_stream.read(read_mem));
+            check!(read_stream.read(&mut read_mem));
         }
         check!(unlink(filename));
-        let read_str = str::from_utf8(read_mem).unwrap();
+        let read_str = str::from_utf8(&read_mem).unwrap();
         assert!(read_str.as_slice() == final_msg.as_slice());
     }
 
@@ -1012,16 +1012,16 @@ mod test {
             let mut read_stream = File::open_mode(filename, Open, Read);
 
             check!(read_stream.seek(-4, SeekEnd));
-            check!(read_stream.read(read_mem));
-            assert_eq!(str::from_utf8(read_mem).unwrap(), chunk_three);
+            check!(read_stream.read(&mut read_mem));
+            assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_three);
 
             check!(read_stream.seek(-9, SeekCur));
-            check!(read_stream.read(read_mem));
-            assert_eq!(str::from_utf8(read_mem).unwrap(), chunk_two);
+            check!(read_stream.read(&mut read_mem));
+            assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_two);
 
             check!(read_stream.seek(0, SeekSet));
-            check!(read_stream.read(read_mem));
-            assert_eq!(str::from_utf8(read_mem).unwrap(), chunk_one);
+            check!(read_stream.read(&mut read_mem));
+            assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_one);
         }
         check!(unlink(filename));
     }
@@ -1107,8 +1107,8 @@ mod test {
         for f in files.iter() {
             {
                 let n = f.filestem_str();
-                check!(File::open(f).read(mem));
-                let read_str = str::from_utf8(mem).unwrap();
+                check!(File::open(f).read(&mut mem));
+                let read_str = str::from_utf8(&mem).unwrap();
                 let expected = match n {
                     None|Some("") => panic!("really shouldn't happen.."),
                     Some(n) => format!("{}{}", prefix, n),
@@ -1532,13 +1532,13 @@ mod test {
         use rand::{StdRng, Rng};
 
         let mut bytes = [0, ..1024];
-        StdRng::new().ok().unwrap().fill_bytes(bytes);
+        StdRng::new().ok().unwrap().fill_bytes(&mut bytes);
 
         let tmpdir = tmpdir();
 
-        check!(File::create(&tmpdir.join("test")).write(bytes));
+        check!(File::create(&tmpdir.join("test")).write(&bytes));
         let actual = check!(File::open(&tmpdir.join("test")).read_to_end());
-        assert!(actual.as_slice() == bytes);
+        assert!(actual.as_slice() == &bytes);
     }
 
     #[test]
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 51935862600..66ae88cfe51 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -50,7 +50,7 @@ fn combine(seek: SeekStyle, cur: uint, end: uint, offset: i64) -> IoResult<u64>
 /// use std::io::MemWriter;
 ///
 /// let mut w = MemWriter::new();
-/// w.write([0, 1, 2]);
+/// w.write(&[0, 1, 2]);
 ///
 /// assert_eq!(w.unwrap(), vec!(0, 1, 2));
 /// ```
@@ -200,8 +200,8 @@ impl Buffer for MemReader {
 ///
 /// let mut buf = [0, ..4];
 /// {
-///     let mut w = BufWriter::new(buf);
-///     w.write([0, 1, 2]);
+///     let mut w = BufWriter::new(&mut buf);
+///     w.write(&[0, 1, 2]);
 /// }
 /// assert!(buf == [0, 1, 2, 0]);
 /// ```
@@ -262,7 +262,7 @@ impl<'a> Seek for BufWriter<'a> {
 /// use std::io::BufReader;
 ///
 /// let mut buf = [0, 1, 2, 3];
-/// let mut r = BufReader::new(buf);
+/// let mut r = BufReader::new(&mut buf);
 ///
 /// assert_eq!(r.read_to_end().unwrap(), vec!(0, 1, 2, 3));
 /// ```
@@ -346,9 +346,9 @@ mod test {
     #[test]
     fn test_mem_writer() {
         let mut writer = MemWriter::new();
-        writer.write([0]).unwrap();
-        writer.write([1, 2, 3]).unwrap();
-        writer.write([4, 5, 6, 7]).unwrap();
+        writer.write(&[0]).unwrap();
+        writer.write(&[1, 2, 3]).unwrap();
+        writer.write(&[4, 5, 6, 7]).unwrap();
         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
         assert_eq!(writer.get_ref(), b);
     }
@@ -357,14 +357,14 @@ mod test {
     fn test_buf_writer() {
         let mut buf = [0 as u8, ..8];
         {
-            let mut writer = BufWriter::new(buf);
+            let mut writer = BufWriter::new(&mut buf);
             assert_eq!(writer.tell(), Ok(0));
-            writer.write([0]).unwrap();
+            writer.write(&[0]).unwrap();
             assert_eq!(writer.tell(), Ok(1));
-            writer.write([1, 2, 3]).unwrap();
-            writer.write([4, 5, 6, 7]).unwrap();
+            writer.write(&[1, 2, 3]).unwrap();
+            writer.write(&[4, 5, 6, 7]).unwrap();
             assert_eq!(writer.tell(), Ok(8));
-            writer.write([]).unwrap();
+            writer.write(&[]).unwrap();
             assert_eq!(writer.tell(), Ok(8));
         }
         let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];
@@ -375,24 +375,24 @@ mod test {
     fn test_buf_writer_seek() {
         let mut buf = [0 as u8, ..8];
         {
-            let mut writer = BufWriter::new(buf);
+            let mut writer = BufWriter::new(&mut buf);
             assert_eq!(writer.tell(), Ok(0));
-            writer.write([1]).unwrap();
+            writer.write(&[1]).unwrap();
             assert_eq!(writer.tell(), Ok(1));
 
             writer.seek(2, SeekSet).unwrap();
             assert_eq!(writer.tell(), Ok(2));
-            writer.write([2]).unwrap();
+            writer.write(&[2]).unwrap();
             assert_eq!(writer.tell(), Ok(3));
 
             writer.seek(-2, SeekCur).unwrap();
             assert_eq!(writer.tell(), Ok(1));
-            writer.write([3]).unwrap();
+            writer.write(&[3]).unwrap();
             assert_eq!(writer.tell(), Ok(2));
 
             writer.seek(-1, SeekEnd).unwrap();
             assert_eq!(writer.tell(), Ok(7));
-            writer.write([4]).unwrap();
+            writer.write(&[4]).unwrap();
             assert_eq!(writer.tell(), Ok(8));
 
         }
@@ -403,10 +403,10 @@ mod test {
     #[test]
     fn test_buf_writer_error() {
         let mut buf = [0 as u8, ..2];
-        let mut writer = BufWriter::new(buf);
-        writer.write([0]).unwrap();
+        let mut writer = BufWriter::new(&mut buf);
+        writer.write(&[0]).unwrap();
 
-        match writer.write([0, 0]) {
+        match writer.write(&[0, 0]) {
             Ok(..) => panic!(),
             Err(e) => assert_eq!(e.kind, io::OtherIoError),
         }
@@ -416,26 +416,26 @@ mod test {
     fn test_mem_reader() {
         let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
         let mut buf = [];
-        assert_eq!(reader.read(buf), Ok(0));
+        assert_eq!(reader.read(&mut buf), Ok(0));
         assert_eq!(reader.tell(), Ok(0));
         let mut buf = [0];
-        assert_eq!(reader.read(buf), Ok(1));
+        assert_eq!(reader.read(&mut buf), Ok(1));
         assert_eq!(reader.tell(), Ok(1));
         let b: &[_] = &[0];
         assert_eq!(buf.as_slice(), b);
         let mut buf = [0, ..4];
-        assert_eq!(reader.read(buf), Ok(4));
+        assert_eq!(reader.read(&mut buf), Ok(4));
         assert_eq!(reader.tell(), Ok(5));
         let b: &[_] = &[1, 2, 3, 4];
         assert_eq!(buf.as_slice(), b);
-        assert_eq!(reader.read(buf), Ok(3));
+        assert_eq!(reader.read(&mut buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
         assert_eq!(buf[0..3], b);
-        assert!(reader.read(buf).is_err());
+        assert!(reader.read(&mut buf).is_err());
         let mut reader = MemReader::new(vec!(0, 1, 2, 3, 4, 5, 6, 7));
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
         assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
-        assert!(reader.read(buf).is_err());
+        assert!(reader.read(&mut buf).is_err());
     }
 
     #[test]
@@ -443,26 +443,26 @@ mod test {
         let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];
         let mut reader = BufReader::new(in_buf.as_slice());
         let mut buf = [];
-        assert_eq!(reader.read(buf), Ok(0));
+        assert_eq!(reader.read(&mut buf), Ok(0));
         assert_eq!(reader.tell(), Ok(0));
         let mut buf = [0];
-        assert_eq!(reader.read(buf), Ok(1));
+        assert_eq!(reader.read(&mut buf), Ok(1));
         assert_eq!(reader.tell(), Ok(1));
         let b: &[_] = &[0];
         assert_eq!(buf.as_slice(), b);
         let mut buf = [0, ..4];
-        assert_eq!(reader.read(buf), Ok(4));
+        assert_eq!(reader.read(&mut buf), Ok(4));
         assert_eq!(reader.tell(), Ok(5));
         let b: &[_] = &[1, 2, 3, 4];
         assert_eq!(buf.as_slice(), b);
-        assert_eq!(reader.read(buf), Ok(3));
+        assert_eq!(reader.read(&mut buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
         assert_eq!(buf[0..3], b);
-        assert!(reader.read(buf).is_err());
+        assert!(reader.read(&mut buf).is_err());
         let mut reader = BufReader::new(in_buf.as_slice());
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
         assert_eq!(reader.read_until(3).unwrap(), vec!(4, 5, 6, 7));
-        assert!(reader.read(buf).is_err());
+        assert!(reader.read(&mut buf).is_err());
     }
 
     #[test]
@@ -506,7 +506,7 @@ mod test {
     #[test]
     fn test_read_whole_string_bad() {
         let buf = [0xff];
-        let mut r = BufReader::new(buf);
+        let mut r = BufReader::new(&buf);
         match r.read_to_string() {
             Ok(..) => panic!(),
             Err(..) => {}
@@ -516,7 +516,7 @@ mod test {
     #[test]
     fn seek_past_end() {
         let buf = [0xff];
-        let mut r = BufReader::new(buf);
+        let mut r = BufReader::new(&buf);
         r.seek(10, SeekSet).unwrap();
         assert!(r.read(&mut []).is_err());
 
@@ -525,22 +525,22 @@ mod test {
         assert!(r.read(&mut []).is_err());
 
         let mut buf = [0];
-        let mut r = BufWriter::new(buf);
+        let mut r = BufWriter::new(&mut buf);
         r.seek(10, SeekSet).unwrap();
-        assert!(r.write([3]).is_err());
+        assert!(r.write(&[3]).is_err());
     }
 
     #[test]
     fn seek_before_0() {
         let buf = [0xff];
-        let mut r = BufReader::new(buf);
+        let mut r = BufReader::new(&buf);
         assert!(r.seek(-1, SeekSet).is_err());
 
         let mut r = MemReader::new(vec!(10));
         assert!(r.seek(-1, SeekSet).is_err());
 
         let mut buf = [0];
-        let mut r = BufWriter::new(buf);
+        let mut r = BufWriter::new(&mut buf);
         assert!(r.seek(-1, SeekSet).is_err());
     }
 
@@ -548,15 +548,15 @@ mod test {
     fn io_read_at_least() {
         let mut r = MemReader::new(vec![1, 2, 3, 4, 5, 6, 7, 8]);
         let mut buf = [0, ..3];
-        assert!(r.read_at_least(buf.len(), buf).is_ok());
+        assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
         let b: &[_] = &[1, 2, 3];
         assert_eq!(buf.as_slice(), b);
         assert!(r.read_at_least(0, buf[mut ..0]).is_ok());
         assert_eq!(buf.as_slice(), b);
-        assert!(r.read_at_least(buf.len(), buf).is_ok());
+        assert!(r.read_at_least(buf.len(), &mut buf).is_ok());
         let b: &[_] = &[4, 5, 6];
         assert_eq!(buf.as_slice(), b);
-        assert!(r.read_at_least(buf.len(), buf).is_err());
+        assert!(r.read_at_least(buf.len(), &mut buf).is_err());
         let b: &[_] = &[7, 8, 6];
         assert_eq!(buf.as_slice(), b);
     }
@@ -625,7 +625,7 @@ mod test {
                 let mut rdr = MemReader::new(buf);
                 for _i in range(0u, 10) {
                     let mut buf = [0 as u8, .. 10];
-                    rdr.read(buf).unwrap();
+                    rdr.read(&mut buf).unwrap();
                     assert_eq!(buf.as_slice(), [5, .. 10].as_slice());
                 }
             }
@@ -637,9 +637,9 @@ mod test {
         b.iter(|| {
             let mut buf = [0 as u8, ..100];
             {
-                let mut wr = BufWriter::new(buf);
+                let mut wr = BufWriter::new(&mut buf);
                 for _i in range(0u, 10) {
-                    wr.write([5, .. 10]).unwrap();
+                    wr.write(&[5, .. 10]).unwrap();
                 }
             }
             assert_eq!(buf.as_slice(), [5, .. 100].as_slice());
@@ -651,10 +651,10 @@ mod test {
         b.iter(|| {
             let buf = [5 as u8, ..100];
             {
-                let mut rdr = BufReader::new(buf);
+                let mut rdr = BufReader::new(&buf);
                 for _i in range(0u, 10) {
                     let mut buf = [0 as u8, .. 10];
-                    rdr.read(buf).unwrap();
+                    rdr.read(&mut buf).unwrap();
                     assert_eq!(buf.as_slice(), [5, .. 10].as_slice());
                 }
             }
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 90345cb0535..66c29db0455 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -521,7 +521,7 @@ pub trait Reader {
     /// Reads a single byte. Returns `Err` on EOF.
     fn read_byte(&mut self) -> IoResult<u8> {
         let mut buf = [0];
-        try!(self.read_at_least(1, buf));
+        try!(self.read_at_least(1, &mut buf));
         Ok(buf[0])
     }
 
@@ -1061,7 +1061,7 @@ pub trait Writer {
     /// that the `write` method is used specifically instead.
     #[inline]
     fn write_line(&mut self, s: &str) -> IoResult<()> {
-        self.write_str(s).and_then(|()| self.write([b'\n']))
+        self.write_str(s).and_then(|()| self.write(&[b'\n']))
     }
 
     /// Write a single char, encoded as UTF-8.
@@ -1217,13 +1217,13 @@ pub trait Writer {
     /// Write a u8 (1 byte).
     #[inline]
     fn write_u8(&mut self, n: u8) -> IoResult<()> {
-        self.write([n])
+        self.write(&[n])
     }
 
     /// Write an i8 (1 byte).
     #[inline]
     fn write_i8(&mut self, n: i8) -> IoResult<()> {
-        self.write([n as u8])
+        self.write(&[n as u8])
     }
 }
 
@@ -1949,7 +1949,7 @@ mod tests {
     fn test_read_at_least() {
         let mut r = BadReader::new(MemReader::new(b"hello, world!".to_vec()),
                                    vec![GoodBehavior(uint::MAX)]);
-        let mut buf = [0u8, ..5];
+        let buf = &mut [0u8, ..5];
         assert!(r.read_at_least(1, buf).unwrap() >= 1);
         assert!(r.read_exact(5).unwrap().len() == 5); // read_exact uses read_at_least
         assert!(r.read_at_least(0, buf).is_ok());
diff --git a/src/libstd/io/net/pipe.rs b/src/libstd/io/net/pipe.rs
index 111b0f2b081..8e934d221d2 100644
--- a/src/libstd/io/net/pipe.rs
+++ b/src/libstd/io/net/pipe.rs
@@ -53,7 +53,7 @@ impl UnixStream {
     ///
     /// let server = Path::new("path/to/my/socket");
     /// let mut stream = UnixStream::connect(&server);
-    /// stream.write([1, 2, 3]);
+    /// stream.write(&[1, 2, 3]);
     /// ```
     pub fn connect<P: ToCStr>(path: &P) -> IoResult<UnixStream> {
         UnixStreamImp::connect(&path.to_c_str(), None)
@@ -169,7 +169,7 @@ impl UnixListener {
     /// let server = Path::new("/path/to/my/socket");
     /// let stream = UnixListener::bind(&server);
     /// for mut client in stream.listen().incoming() {
-    ///     client.write([1, 2, 3, 4]);
+    ///     client.write(&[1, 2, 3, 4]);
     /// }
     /// # }
     /// ```
@@ -307,10 +307,10 @@ mod tests {
     fn smoke() {
         smalltest(proc(mut server) {
             let mut buf = [0];
-            server.read(buf).unwrap();
+            server.read(&mut buf).unwrap();
             assert!(buf[0] == 99);
         }, proc(mut client) {
-            client.write([99]).unwrap();
+            client.write(&[99]).unwrap();
         })
     }
 
@@ -319,8 +319,8 @@ mod tests {
     fn read_eof() {
         smalltest(proc(mut server) {
             let mut buf = [0];
-            assert!(server.read(buf).is_err());
-            assert!(server.read(buf).is_err());
+            assert!(server.read(&mut buf).is_err());
+            assert!(server.read(&mut buf).is_err());
         }, proc(_client) {
             // drop the client
         })
@@ -331,7 +331,7 @@ mod tests {
         smalltest(proc(mut server) {
             let buf = [0];
             loop {
-                match server.write(buf) {
+                match server.write(&buf) {
                     Ok(..) => {}
                     Err(e) => {
                         assert!(e.kind == BrokenPipe ||
@@ -361,7 +361,7 @@ mod tests {
         spawn(proc() {
             for _ in range(0u, times) {
                 let mut stream = UnixStream::connect(&path2);
-                match stream.write([100]) {
+                match stream.write(&[100]) {
                     Ok(..) => {}
                     Err(e) => panic!("failed write: {}", e)
                 }
@@ -371,7 +371,7 @@ mod tests {
         for _ in range(0, times) {
             let mut client = acceptor.accept();
             let mut buf = [0];
-            match client.read(buf) {
+            match client.read(&mut buf) {
                 Ok(..) => {}
                 Err(e) => panic!("failed read/accept: {}", e),
             }
@@ -396,10 +396,10 @@ mod tests {
             let mut s = UnixStream::connect(&addr);
             let mut buf = [0, 0];
             debug!("client reading");
-            assert_eq!(s.read(buf), Ok(1));
+            assert_eq!(s.read(&mut buf), Ok(1));
             assert_eq!(buf[0], 1);
             debug!("client writing");
-            s.write([2]).unwrap();
+            s.write(&[2]).unwrap();
             debug!("client dropping");
         });
 
@@ -412,14 +412,14 @@ mod tests {
             let mut s2 = s2;
             rx1.recv();
             debug!("writer writing");
-            s2.write([1]).unwrap();
+            s2.write(&[1]).unwrap();
             debug!("writer done");
             tx2.send(());
         });
         tx1.send(());
         let mut buf = [0, 0];
         debug!("reader reading");
-        assert_eq!(s1.read(buf), Ok(1));
+        assert_eq!(s1.read(&mut buf), Ok(1));
         debug!("reader done");
         rx2.recv();
     }
@@ -433,9 +433,9 @@ mod tests {
 
         spawn(proc() {
             let mut s = UnixStream::connect(&addr);
-            s.write([1]).unwrap();
+            s.write(&[1]).unwrap();
             rx.recv();
-            s.write([2]).unwrap();
+            s.write(&[2]).unwrap();
             rx.recv();
         });
 
@@ -446,12 +446,12 @@ mod tests {
         spawn(proc() {
             let mut s2 = s2;
             let mut buf = [0, 0];
-            s2.read(buf).unwrap();
+            s2.read(&mut buf).unwrap();
             tx2.send(());
             done.send(());
         });
         let mut buf = [0, 0];
-        s1.read(buf).unwrap();
+        s1.read(&mut buf).unwrap();
         tx1.send(());
 
         rx.recv();
@@ -464,7 +464,7 @@ mod tests {
 
         spawn(proc() {
             let mut s = UnixStream::connect(&addr);
-            let mut buf = [0, 1];
+            let buf = &mut [0, 1];
             s.read(buf).unwrap();
             s.read(buf).unwrap();
         });
@@ -475,10 +475,10 @@ mod tests {
         let (tx, rx) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            s2.write([1]).unwrap();
+            s2.write(&[1]).unwrap();
             tx.send(());
         });
-        s1.write([2]).unwrap();
+        s1.write(&[2]).unwrap();
 
         rx.recv();
     }
@@ -588,18 +588,18 @@ mod tests {
 
         // closing should prevent reads/writes
         s.close_write().unwrap();
-        assert!(s.write([0]).is_err());
+        assert!(s.write(&[0]).is_err());
         s.close_read().unwrap();
-        assert!(s.read(b).is_err());
+        assert!(s.read(&mut b).is_err());
 
         // closing should affect previous handles
-        assert!(s2.write([0]).is_err());
-        assert!(s2.read(b).is_err());
+        assert!(s2.write(&[0]).is_err());
+        assert!(s2.read(&mut b).is_err());
 
         // closing should affect new handles
         let mut s3 = s.clone();
-        assert!(s3.write([0]).is_err());
-        assert!(s3.read(b).is_err());
+        assert!(s3.write(&[0]).is_err());
+        assert!(s3.read(&mut b).is_err());
 
         // make sure these don't die
         let _ = s2.close_read();
@@ -624,7 +624,7 @@ mod tests {
         let (tx, rx) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            assert!(s2.read([0]).is_err());
+            assert!(s2.read(&mut [0]).is_err());
             tx.send(());
         });
         // this should wake up the child task
@@ -642,18 +642,18 @@ mod tests {
         spawn(proc() {
             let mut s = UnixStream::connect(&addr).unwrap();
             rx.recv();
-            assert!(s.write([0]).is_ok());
+            assert!(s.write(&[0]).is_ok());
             let _ = rx.recv_opt();
         });
 
         let mut s = a.accept().unwrap();
         s.set_timeout(Some(20));
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
 
         s.set_timeout(Some(20));
         for i in range(0u, 1001) {
-            match s.write([0, .. 128 * 1024]) {
+            match s.write(&[0, .. 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
                 Err(e) => panic!("{}", e),
@@ -664,12 +664,12 @@ mod tests {
         // I'm not sure as to why, but apparently the write on windows always
         // succeeds after the previous timeout. Who knows?
         if !cfg!(windows) {
-            assert_eq!(s.write([0]).err().unwrap().kind, TimedOut);
+            assert_eq!(s.write(&[0]).err().unwrap().kind, TimedOut);
         }
 
         tx.send(());
         s.set_timeout(None);
-        assert_eq!(s.read([0, 0]), Ok(1));
+        assert_eq!(s.read(&mut [0, 0]), Ok(1));
     }
 
     #[test]
@@ -682,7 +682,7 @@ mod tests {
             rx.recv();
             let mut amt = 0;
             while amt < 100 * 128 * 1024 {
-                match s.read([0, ..128 * 1024]) {
+                match s.read(&mut [0, ..128 * 1024]) {
                     Ok(n) => { amt += n; }
                     Err(e) => panic!("{}", e),
                 }
@@ -692,12 +692,12 @@ mod tests {
 
         let mut s = a.accept().unwrap();
         s.set_read_timeout(Some(20));
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
 
         tx.send(());
         for _ in range(0u, 100) {
-            assert!(s.write([0, ..128 * 1024]).is_ok());
+            assert!(s.write(&[0, ..128 * 1024]).is_ok());
         }
     }
 
@@ -709,14 +709,14 @@ mod tests {
         spawn(proc() {
             let mut s = UnixStream::connect(&addr).unwrap();
             rx.recv();
-            assert!(s.write([0]).is_ok());
+            assert!(s.write(&[0]).is_ok());
             let _ = rx.recv_opt();
         });
 
         let mut s = a.accept().unwrap();
         s.set_write_timeout(Some(20));
         for i in range(0u, 1001) {
-            match s.write([0, .. 128 * 1024]) {
+            match s.write(&[0, .. 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
                 Err(e) => panic!("{}", e),
@@ -725,7 +725,7 @@ mod tests {
         }
 
         tx.send(());
-        assert!(s.read([0]).is_ok());
+        assert!(s.read(&mut [0]).is_ok());
     }
 
     #[test]
@@ -736,7 +736,7 @@ mod tests {
         spawn(proc() {
             let mut s = UnixStream::connect(&addr).unwrap();
             rx.recv();
-            assert!(s.write([0]).is_ok());
+            assert!(s.write(&[0]).is_ok());
             let _ = rx.recv_opt();
         });
 
@@ -745,12 +745,12 @@ mod tests {
         let (tx2, rx2) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            assert!(s2.read([0]).is_ok());
+            assert!(s2.read(&mut [0]).is_ok());
             tx2.send(());
         });
 
         s.set_read_timeout(Some(20));
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
         tx.send(());
 
         rx2.recv();
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index 24fc2998ee6..cab54d82e1c 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -42,9 +42,9 @@ use sys::tcp::TcpAcceptor as TcpAcceptorImp;
 ///
 /// let mut stream = TcpStream::connect("127.0.0.1:34254");
 ///
-/// stream.write([1]);
+/// stream.write(&[1]);
 /// let mut buf = [0];
-/// stream.read(buf);
+/// stream.read(&mut buf);
 /// drop(stream); // close the connection
 /// ```
 pub struct TcpStream {
@@ -143,7 +143,7 @@ impl TcpStream {
     ///
     /// // wait for some data, will get canceled after one second
     /// let mut buf = [0];
-    /// stream.read(buf);
+    /// stream.read(&mut buf);
     /// ```
     ///
     /// Note that this method affects all cloned handles associated with this
@@ -487,12 +487,12 @@ mod test {
 
         spawn(proc() {
             let mut stream = TcpStream::connect(("localhost", socket_addr.port));
-            stream.write([144]).unwrap();
+            stream.write(&[144]).unwrap();
         });
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf).unwrap();
+        stream.read(&mut buf).unwrap();
         assert!(buf[0] == 144);
     }
 
@@ -503,12 +503,12 @@ mod test {
 
         spawn(proc() {
             let mut stream = TcpStream::connect(("localhost", addr.port));
-            stream.write([64]).unwrap();
+            stream.write(&[64]).unwrap();
         });
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf).unwrap();
+        stream.read(&mut buf).unwrap();
         assert!(buf[0] == 64);
     }
 
@@ -519,12 +519,12 @@ mod test {
 
         spawn(proc() {
             let mut stream = TcpStream::connect(("127.0.0.1", addr.port));
-            stream.write([44]).unwrap();
+            stream.write(&[44]).unwrap();
         });
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf).unwrap();
+        stream.read(&mut buf).unwrap();
         assert!(buf[0] == 44);
     }
 
@@ -535,12 +535,12 @@ mod test {
 
         spawn(proc() {
             let mut stream = TcpStream::connect(("::1", addr.port));
-            stream.write([66]).unwrap();
+            stream.write(&[66]).unwrap();
         });
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf).unwrap();
+        stream.read(&mut buf).unwrap();
         assert!(buf[0] == 66);
     }
 
@@ -551,12 +551,12 @@ mod test {
 
         spawn(proc() {
             let mut stream = TcpStream::connect(addr);
-            stream.write([99]).unwrap();
+            stream.write(&[99]).unwrap();
         });
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf).unwrap();
+        stream.read(&mut buf).unwrap();
         assert!(buf[0] == 99);
     }
 
@@ -567,12 +567,12 @@ mod test {
 
         spawn(proc() {
             let mut stream = TcpStream::connect(addr);
-            stream.write([99]).unwrap();
+            stream.write(&[99]).unwrap();
         });
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        stream.read(buf).unwrap();
+        stream.read(&mut buf).unwrap();
         assert!(buf[0] == 99);
     }
 
@@ -588,7 +588,7 @@ mod test {
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        let nread = stream.read(buf);
+        let nread = stream.read(&mut buf);
         assert!(nread.is_err());
     }
 
@@ -604,7 +604,7 @@ mod test {
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        let nread = stream.read(buf);
+        let nread = stream.read(&mut buf);
         assert!(nread.is_err());
     }
 
@@ -620,10 +620,10 @@ mod test {
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        let nread = stream.read(buf);
+        let nread = stream.read(&mut buf);
         assert!(nread.is_err());
 
-        match stream.read(buf) {
+        match stream.read(&mut buf) {
             Ok(..) => panic!(),
             Err(ref e) => {
                 assert!(e.kind == NotConnected || e.kind == EndOfFile,
@@ -644,10 +644,10 @@ mod test {
 
         let mut stream = acceptor.accept();
         let mut buf = [0];
-        let nread = stream.read(buf);
+        let nread = stream.read(&mut buf);
         assert!(nread.is_err());
 
-        match stream.read(buf) {
+        match stream.read(&mut buf) {
             Ok(..) => panic!(),
             Err(ref e) => {
                 assert!(e.kind == NotConnected || e.kind == EndOfFile,
@@ -670,7 +670,7 @@ mod test {
         let mut stream = acceptor.accept();
         rx.recv();
         let buf = [0];
-        match stream.write(buf) {
+        match stream.write(&buf) {
             Ok(..) => {}
             Err(e) => {
                 assert!(e.kind == ConnectionReset ||
@@ -695,7 +695,7 @@ mod test {
         let mut stream = acceptor.accept();
         rx.recv();
         let buf = [0];
-        match stream.write(buf) {
+        match stream.write(&buf) {
             Ok(..) => {}
             Err(e) => {
                 assert!(e.kind == ConnectionReset ||
@@ -715,13 +715,13 @@ mod test {
         spawn(proc() {
             for _ in range(0, max) {
                 let mut stream = TcpStream::connect(addr);
-                stream.write([99]).unwrap();
+                stream.write(&[99]).unwrap();
             }
         });
 
         for ref mut stream in acceptor.incoming().take(max) {
             let mut buf = [0];
-            stream.read(buf).unwrap();
+            stream.read(&mut buf).unwrap();
             assert_eq!(buf[0], 99);
         }
     }
@@ -735,13 +735,13 @@ mod test {
         spawn(proc() {
             for _ in range(0, max) {
                 let mut stream = TcpStream::connect(addr);
-                stream.write([99]).unwrap();
+                stream.write(&[99]).unwrap();
             }
         });
 
         for ref mut stream in acceptor.incoming().take(max) {
             let mut buf = [0];
-            stream.read(buf).unwrap();
+            stream.read(&mut buf).unwrap();
             assert_eq!(buf[0], 99);
         }
     }
@@ -759,7 +759,7 @@ mod test {
                 spawn(proc() {
                     let mut stream = stream;
                     let mut buf = [0];
-                    stream.read(buf).unwrap();
+                    stream.read(&mut buf).unwrap();
                     assert!(buf[0] == i as u8);
                     debug!("read");
                 });
@@ -777,7 +777,7 @@ mod test {
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
-                stream.write([i as u8]).unwrap();
+                stream.write(&[i as u8]).unwrap();
             });
         }
     }
@@ -795,7 +795,7 @@ mod test {
                 spawn(proc() {
                     let mut stream = stream;
                     let mut buf = [0];
-                    stream.read(buf).unwrap();
+                    stream.read(&mut buf).unwrap();
                     assert!(buf[0] == i as u8);
                     debug!("read");
                 });
@@ -813,7 +813,7 @@ mod test {
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
-                stream.write([i as u8]).unwrap();
+                stream.write(&[i as u8]).unwrap();
             });
         }
     }
@@ -831,7 +831,7 @@ mod test {
                 spawn(proc() {
                     let mut stream = stream;
                     let mut buf = [0];
-                    stream.read(buf).unwrap();
+                    stream.read(&mut buf).unwrap();
                     assert!(buf[0] == 99);
                     debug!("read");
                 });
@@ -849,7 +849,7 @@ mod test {
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
-                stream.write([99]).unwrap();
+                stream.write(&[99]).unwrap();
             });
         }
     }
@@ -867,7 +867,7 @@ mod test {
                 spawn(proc() {
                     let mut stream = stream;
                     let mut buf = [0];
-                    stream.read(buf).unwrap();
+                    stream.read(&mut buf).unwrap();
                     assert!(buf[0] == 99);
                     debug!("read");
                 });
@@ -885,7 +885,7 @@ mod test {
                 // Connect again before writing
                 connect(i + 1, addr);
                 debug!("writing");
-                stream.write([99]).unwrap();
+                stream.write(&[99]).unwrap();
             });
         }
     }
@@ -941,17 +941,17 @@ mod test {
             let mut srv = TcpListener::bind(addr).listen().unwrap();
             tx.send(());
             let mut cl = srv.accept().unwrap();
-            cl.write([10]).unwrap();
+            cl.write(&[10]).unwrap();
             let mut b = [0];
-            cl.read(b).unwrap();
+            cl.read(&mut b).unwrap();
             tx.send(());
         });
 
         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();
+        assert_eq!(c.read(&mut b), Ok(1));
+        c.write(&[1]).unwrap();
         rx.recv();
     }
 
@@ -1002,9 +1002,9 @@ mod test {
         spawn(proc() {
             let mut s = TcpStream::connect(addr);
             let mut buf = [0, 0];
-            assert_eq!(s.read(buf), Ok(1));
+            assert_eq!(s.read(&mut buf), Ok(1));
             assert_eq!(buf[0], 1);
-            s.write([2]).unwrap();
+            s.write(&[2]).unwrap();
         });
 
         let mut s1 = acceptor.accept().unwrap();
@@ -1015,12 +1015,12 @@ mod test {
         spawn(proc() {
             let mut s2 = s2;
             rx1.recv();
-            s2.write([1]).unwrap();
+            s2.write(&[1]).unwrap();
             tx2.send(());
         });
         tx1.send(());
         let mut buf = [0, 0];
-        assert_eq!(s1.read(buf), Ok(1));
+        assert_eq!(s1.read(&mut buf), Ok(1));
         rx2.recv();
     }
 
@@ -1033,9 +1033,9 @@ mod test {
 
         spawn(proc() {
             let mut s = TcpStream::connect(addr);
-            s.write([1]).unwrap();
+            s.write(&[1]).unwrap();
             rx.recv();
-            s.write([2]).unwrap();
+            s.write(&[2]).unwrap();
             rx.recv();
         });
 
@@ -1046,12 +1046,12 @@ mod test {
         spawn(proc() {
             let mut s2 = s2;
             let mut buf = [0, 0];
-            s2.read(buf).unwrap();
+            s2.read(&mut buf).unwrap();
             tx2.send(());
             done.send(());
         });
         let mut buf = [0, 0];
-        s1.read(buf).unwrap();
+        s1.read(&mut buf).unwrap();
         tx1.send(());
 
         rx.recv();
@@ -1065,8 +1065,8 @@ mod test {
         spawn(proc() {
             let mut s = TcpStream::connect(addr);
             let mut buf = [0, 1];
-            s.read(buf).unwrap();
-            s.read(buf).unwrap();
+            s.read(&mut buf).unwrap();
+            s.read(&mut buf).unwrap();
         });
 
         let mut s1 = acceptor.accept().unwrap();
@@ -1075,10 +1075,10 @@ mod test {
         let (done, rx) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            s2.write([1]).unwrap();
+            s2.write(&[1]).unwrap();
             done.send(());
         });
-        s1.write([2]).unwrap();
+        s1.write(&[2]).unwrap();
 
         rx.recv();
     }
@@ -1091,12 +1091,12 @@ mod test {
             let mut a = a;
             let mut c = a.accept().unwrap();
             assert_eq!(c.read_to_end(), Ok(vec!()));
-            c.write([1]).unwrap();
+            c.write(&[1]).unwrap();
         });
 
         let mut s = TcpStream::connect(addr).unwrap();
         assert!(s.inner.close_write().is_ok());
-        assert!(s.write([1]).is_err());
+        assert!(s.write(&[1]).is_err());
         assert_eq!(s.read_to_end(), Ok(vec!(1)));
     }
 
@@ -1161,18 +1161,18 @@ mod test {
 
         // closing should prevent reads/writes
         s.close_write().unwrap();
-        assert!(s.write([0]).is_err());
+        assert!(s.write(&[0]).is_err());
         s.close_read().unwrap();
-        assert!(s.read(b).is_err());
+        assert!(s.read(&mut b).is_err());
 
         // closing should affect previous handles
-        assert!(s2.write([0]).is_err());
-        assert!(s2.read(b).is_err());
+        assert!(s2.write(&[0]).is_err());
+        assert!(s2.read(&mut b).is_err());
 
         // closing should affect new handles
         let mut s3 = s.clone();
-        assert!(s3.write([0]).is_err());
-        assert!(s3.read(b).is_err());
+        assert!(s3.write(&[0]).is_err());
+        assert!(s3.read(&mut b).is_err());
 
         // make sure these don't die
         let _ = s2.close_read();
@@ -1197,7 +1197,7 @@ mod test {
         let (tx, rx) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            assert!(s2.read([0]).is_err());
+            assert!(s2.read(&mut [0]).is_err());
             tx.send(());
         });
         // this should wake up the child task
@@ -1215,29 +1215,29 @@ mod test {
         spawn(proc() {
             let mut s = TcpStream::connect(addr).unwrap();
             rx.recv();
-            assert!(s.write([0]).is_ok());
+            assert!(s.write(&[0]).is_ok());
             let _ = rx.recv_opt();
         });
 
         let mut s = a.accept().unwrap();
         s.set_timeout(Some(20));
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
 
         s.set_timeout(Some(20));
         for i in range(0i, 1001) {
-            match s.write([0, .. 128 * 1024]) {
+            match s.write(&[0, .. 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
                 Err(e) => panic!("{}", e),
            }
            if i == 1000 { panic!("should have filled up?!"); }
         }
-        assert_eq!(s.write([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.write(&[0]).err().unwrap().kind, TimedOut);
 
         tx.send(());
         s.set_timeout(None);
-        assert_eq!(s.read([0, 0]), Ok(1));
+        assert_eq!(s.read(&mut [0, 0]), Ok(1));
     }
 
     #[test]
@@ -1250,7 +1250,7 @@ mod test {
             rx.recv();
             let mut amt = 0;
             while amt < 100 * 128 * 1024 {
-                match s.read([0, ..128 * 1024]) {
+                match s.read(&mut [0, ..128 * 1024]) {
                     Ok(n) => { amt += n; }
                     Err(e) => panic!("{}", e),
                 }
@@ -1260,12 +1260,12 @@ mod test {
 
         let mut s = a.accept().unwrap();
         s.set_read_timeout(Some(20));
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
 
         tx.send(());
         for _ in range(0i, 100) {
-            assert!(s.write([0, ..128 * 1024]).is_ok());
+            assert!(s.write(&[0, ..128 * 1024]).is_ok());
         }
     }
 
@@ -1277,24 +1277,24 @@ mod test {
         spawn(proc() {
             let mut s = TcpStream::connect(addr).unwrap();
             rx.recv();
-            assert!(s.write([0]).is_ok());
+            assert!(s.write(&[0]).is_ok());
             let _ = rx.recv_opt();
         });
 
         let mut s = a.accept().unwrap();
         s.set_write_timeout(Some(20));
         for i in range(0i, 1001) {
-            match s.write([0, .. 128 * 1024]) {
+            match s.write(&[0, .. 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
                 Err(e) => panic!("{}", e),
            }
            if i == 1000 { panic!("should have filled up?!"); }
         }
-        assert_eq!(s.write([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.write(&[0]).err().unwrap().kind, TimedOut);
 
         tx.send(());
-        assert!(s.read([0]).is_ok());
+        assert!(s.read(&mut [0]).is_ok());
     }
 
     #[test]
@@ -1305,7 +1305,7 @@ mod test {
         spawn(proc() {
             let mut s = TcpStream::connect(addr).unwrap();
             rx.recv();
-            assert_eq!(s.write([0]), Ok(()));
+            assert_eq!(s.write(&[0]), Ok(()));
             let _ = rx.recv_opt();
         });
 
@@ -1314,12 +1314,12 @@ mod test {
         let (tx2, rx2) = channel();
         spawn(proc() {
             let mut s2 = s2;
-            assert_eq!(s2.read([0]), Ok(1));
+            assert_eq!(s2.read(&mut [0]), Ok(1));
             tx2.send(());
         });
 
         s.set_read_timeout(Some(20));
-        assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
+        assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
         tx.send(());
 
         rx2.recv();
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index 31b61989647..567e7da0c00 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -44,7 +44,7 @@ use sys::udp::UdpSocket as UdpSocketImp;
 ///     };
 ///
 ///     let mut buf = [0, ..10];
-///     match socket.recv_from(buf) {
+///     match socket.recv_from(&mut buf) {
 ///         Ok((amt, src)) => {
 ///             // Send a reply to the socket we received data from
 ///             let buf = buf[mut ..amt];
@@ -266,7 +266,7 @@ mod test {
             match UdpSocket::bind(client_ip) {
                 Ok(ref mut client) => {
                     rx1.recv();
-                    client.send_to([99], server_ip).unwrap()
+                    client.send_to(&[99], server_ip).unwrap()
                 }
                 Err(..) => panic!()
             }
@@ -277,7 +277,7 @@ mod test {
             Ok(ref mut server) => {
                 tx1.send(());
                 let mut buf = [0];
-                match server.recv_from(buf) {
+                match server.recv_from(&mut buf) {
                     Ok((nread, src)) => {
                         assert_eq!(nread, 1);
                         assert_eq!(buf[0], 99);
@@ -301,7 +301,7 @@ mod test {
             match UdpSocket::bind(client_ip) {
                 Ok(ref mut client) => {
                     rx.recv();
-                    client.send_to([99], server_ip).unwrap()
+                    client.send_to(&[99], server_ip).unwrap()
                 }
                 Err(..) => panic!()
             }
@@ -311,7 +311,7 @@ mod test {
             Ok(ref mut server) => {
                 tx.send(());
                 let mut buf = [0];
-                match server.recv_from(buf) {
+                match server.recv_from(&mut buf) {
                     Ok((nread, src)) => {
                         assert_eq!(nread, 1);
                         assert_eq!(buf[0], 99);
@@ -345,8 +345,8 @@ mod test {
                 }
             };
             rx1.recv();
-            send_as(dummy_ip, [98]);
-            send_as(client_ip, [99]);
+            send_as(dummy_ip, &[98]);
+            send_as(client_ip, &[99]);
             tx2.send(());
         });
 
@@ -356,7 +356,7 @@ mod test {
                 let mut stream = server.connect(client_ip);
                 tx1.send(());
                 let mut buf = [0];
-                match stream.read(buf) {
+                match stream.read(&mut buf) {
                     Ok(nread) => {
                         assert_eq!(nread, 1);
                         assert_eq!(buf[0], 99);
@@ -383,7 +383,7 @@ mod test {
                     let client = box client;
                     let mut stream = client.connect(server_ip);
                     rx1.recv();
-                    stream.write([99]).unwrap();
+                    stream.write(&[99]).unwrap();
                 }
                 Err(..) => panic!()
             }
@@ -396,7 +396,7 @@ mod test {
                 let mut stream = server.connect(client_ip);
                 tx1.send(());
                 let mut buf = [0];
-                match stream.read(buf) {
+                match stream.read(&mut buf) {
                     Ok(nread) => {
                         assert_eq!(nread, 1);
                         assert_eq!(buf[0], 99);
@@ -442,9 +442,9 @@ mod test {
         spawn(proc() {
             let mut sock2 = sock2;
             let mut buf = [0, 0];
-            assert_eq!(sock2.recv_from(buf), Ok((1, addr1)));
+            assert_eq!(sock2.recv_from(&mut buf), Ok((1, addr1)));
             assert_eq!(buf[0], 1);
-            sock2.send_to([2], addr1).unwrap();
+            sock2.send_to(&[2], addr1).unwrap();
         });
 
         let sock3 = sock1.clone();
@@ -454,12 +454,12 @@ mod test {
         spawn(proc() {
             let mut sock3 = sock3;
             rx1.recv();
-            sock3.send_to([1], addr2).unwrap();
+            sock3.send_to(&[1], addr2).unwrap();
             tx2.send(());
         });
         tx1.send(());
         let mut buf = [0, 0];
-        assert_eq!(sock1.recv_from(buf), Ok((1, addr2)));
+        assert_eq!(sock1.recv_from(&mut buf), Ok((1, addr2)));
         rx2.recv();
     }
 
@@ -474,9 +474,9 @@ mod test {
 
         spawn(proc() {
             let mut sock2 = sock2;
-            sock2.send_to([1], addr1).unwrap();
+            sock2.send_to(&[1], addr1).unwrap();
             rx.recv();
-            sock2.send_to([2], addr1).unwrap();
+            sock2.send_to(&[2], addr1).unwrap();
             rx.recv();
         });
 
@@ -486,12 +486,12 @@ mod test {
         spawn(proc() {
             let mut sock3 = sock3;
             let mut buf = [0, 0];
-            sock3.recv_from(buf).unwrap();
+            sock3.recv_from(&mut buf).unwrap();
             tx2.send(());
             done.send(());
         });
         let mut buf = [0, 0];
-        sock1.recv_from(buf).unwrap();
+        sock1.recv_from(&mut buf).unwrap();
         tx1.send(());
 
         rx.recv();
@@ -512,7 +512,7 @@ mod test {
             let mut buf = [0, 1];
 
             rx.recv();
-            match sock2.recv_from(buf) {
+            match sock2.recv_from(&mut buf) {
                 Ok(..) => {}
                 Err(e) => panic!("failed receive: {}", e),
             }
@@ -525,13 +525,13 @@ mod test {
         let tx2 = tx.clone();
         spawn(proc() {
             let mut sock3 = sock3;
-            match sock3.send_to([1], addr2) {
+            match sock3.send_to(&[1], addr2) {
                 Ok(..) => { let _ = tx2.send_opt(()); }
                 Err(..) => {}
             }
             done.send(());
         });
-        match sock1.send_to([2], addr2) {
+        match sock1.send_to(&[2], addr2) {
             Ok(..) => { let _ = tx.send_opt(()); }
             Err(..) => {}
         }
@@ -552,28 +552,28 @@ mod test {
         let (tx2, rx2) = channel();
         spawn(proc() {
             let mut a = UdpSocket::bind(addr2).unwrap();
-            assert_eq!(a.recv_from([0]), Ok((1, addr1)));
-            assert_eq!(a.send_to([0], addr1), Ok(()));
+            assert_eq!(a.recv_from(&mut [0]), Ok((1, addr1)));
+            assert_eq!(a.send_to(&[0], addr1), Ok(()));
             rx.recv();
-            assert_eq!(a.send_to([0], addr1), Ok(()));
+            assert_eq!(a.send_to(&[0], addr1), Ok(()));
 
             tx2.send(());
         });
 
         // Make sure that reads time out, but writes can continue
         a.set_read_timeout(Some(20));
-        assert_eq!(a.recv_from([0]).err().unwrap().kind, TimedOut);
-        assert_eq!(a.recv_from([0]).err().unwrap().kind, TimedOut);
-        assert_eq!(a.send_to([0], addr2), Ok(()));
+        assert_eq!(a.recv_from(&mut [0]).err().unwrap().kind, TimedOut);
+        assert_eq!(a.recv_from(&mut [0]).err().unwrap().kind, TimedOut);
+        assert_eq!(a.send_to(&[0], addr2), Ok(()));
 
         // Cloned handles should be able to block
         let mut a2 = a.clone();
-        assert_eq!(a2.recv_from([0]), Ok((1, addr2)));
+        assert_eq!(a2.recv_from(&mut [0]), Ok((1, addr2)));
 
         // Clearing the timeout should allow for receiving
         a.set_timeout(None);
         tx.send(());
-        assert_eq!(a2.recv_from([0]), Ok((1, addr2)));
+        assert_eq!(a2.recv_from(&mut [0]), Ok((1, addr2)));
 
         // Make sure the child didn't die
         rx2.recv();
@@ -588,7 +588,7 @@ mod test {
 
         a.set_write_timeout(Some(1000));
         for _ in range(0u, 100) {
-            match a.send_to([0, ..4*1024], addr2) {
+            match a.send_to(&[0, ..4*1024], addr2) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
                 Err(e) => panic!("other error: {}", e),
diff --git a/src/libstd/io/pipe.rs b/src/libstd/io/pipe.rs
index 64b2518fab1..5137db305f0 100644
--- a/src/libstd/io/pipe.rs
+++ b/src/libstd/io/pipe.rs
@@ -125,12 +125,12 @@ mod test {
         let (tx, rx) = channel();
         spawn(proc() {
             let mut out = out;
-            out.write([10]).unwrap();
+            out.write(&[10]).unwrap();
             rx.recv(); // don't close the pipe until the other read has finished
         });
 
         let mut buf = [0, ..10];
-        input.read(buf).unwrap();
+        input.read(&mut buf).unwrap();
         tx.send(());
     }
 }
diff --git a/src/libstd/io/result.rs b/src/libstd/io/result.rs
index 40793d98ee3..ec856e662e3 100644
--- a/src/libstd/io/result.rs
+++ b/src/libstd/io/result.rs
@@ -85,7 +85,7 @@ mod test {
     #[test]
     fn test_option_writer() {
         let mut writer: io::IoResult<MemWriter> = Ok(MemWriter::new());
-        writer.write([0, 1, 2]).unwrap();
+        writer.write(&[0, 1, 2]).unwrap();
         writer.flush().unwrap();
         assert_eq!(writer.unwrap().unwrap(), vec!(0, 1, 2));
     }
@@ -95,7 +95,7 @@ mod test {
         let mut writer: io::IoResult<MemWriter> =
             Err(io::standard_error(io::EndOfFile));
 
-        match writer.write([0, 0, 0]) {
+        match writer.write(&[0, 0, 0]) {
             Ok(..) => panic!(),
             Err(e) => assert_eq!(e.kind, io::EndOfFile),
         }
@@ -110,7 +110,7 @@ mod test {
         let mut reader: io::IoResult<MemReader> =
             Ok(MemReader::new(vec!(0, 1, 2, 3)));
         let mut buf = [0, 0];
-        reader.read(buf).unwrap();
+        reader.read(&mut buf).unwrap();
         let b: &[_] = &[0, 1];
         assert_eq!(buf.as_slice(), b);
     }
@@ -121,7 +121,7 @@ mod test {
             Err(io::standard_error(io::EndOfFile));
         let mut buf = [];
 
-        match reader.read(buf) {
+        match reader.read(&mut buf) {
             Ok(..) => panic!(),
             Err(e) => assert_eq!(e.kind, io::EndOfFile),
         }
diff --git a/src/libstd/io/stdio.rs b/src/libstd/io/stdio.rs
index 158d596ea13..00d62f389ca 100644
--- a/src/libstd/io/stdio.rs
+++ b/src/libstd/io/stdio.rs
@@ -237,7 +237,7 @@ pub fn print(s: &str) {
 /// `\n` character is printed to the console after the string.
 pub fn println(s: &str) {
     with_task_stdout(|io| {
-        io.write(s.as_bytes()).and_then(|()| io.write([b'\n']))
+        io.write(s.as_bytes()).and_then(|()| io.write(&[b'\n']))
     })
 }
 
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index 765af0dfbc0..e7598611ec8 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -225,7 +225,7 @@ impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
 pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
     let mut buf = [0, ..super::DEFAULT_BUF_SIZE];
     loop {
-        let len = match r.read(buf) {
+        let len = match r.read(&mut buf) {
             Ok(len) => len,
             Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
             Err(e) => return Err(e),
@@ -352,7 +352,7 @@ mod test {
 
         let mut multi = MultiWriter::new(vec!(box TestWriter as Box<Writer>,
                                               box TestWriter as Box<Writer>));
-        multi.write([1, 2, 3]).unwrap();
+        multi.write(&[1, 2, 3]).unwrap();
         assert_eq!(2, unsafe { writes });
         assert_eq!(0, unsafe { flushes });
         multi.flush().unwrap();
@@ -413,25 +413,25 @@ mod test {
     fn test_iter_reader() {
         let mut r = IterReader::new(range(0u8, 8));
         let mut buf = [0, 0, 0];
-        let len = r.read(buf).unwrap();
+        let len = r.read(&mut buf).unwrap();
         assert_eq!(len, 3);
         assert!(buf == [0, 1, 2]);
 
-        let len = r.read(buf).unwrap();
+        let len = r.read(&mut buf).unwrap();
         assert_eq!(len, 3);
         assert!(buf == [3, 4, 5]);
 
-        let len = r.read(buf).unwrap();
+        let len = r.read(&mut buf).unwrap();
         assert_eq!(len, 2);
         assert!(buf == [6, 7, 5]);
 
-        assert_eq!(r.read(buf).unwrap_err().kind, io::EndOfFile);
+        assert_eq!(r.read(&mut buf).unwrap_err().kind, io::EndOfFile);
     }
 
     #[test]
     fn iter_reader_zero_length() {
         let mut r = IterReader::new(range(0u8, 8));
         let mut buf = [];
-        assert_eq!(Ok(0), r.read(buf));
+        assert_eq!(Ok(0), r.read(&mut buf));
     }
 }