use slicing sugar

18 files changed, 120 insertions, 124 deletions

diff --git a/src/libstd/failure.rs b/src/libstd/failure.rs
index 50538d3e43d..dbc88ddf0a0 100644
--- a/src/libstd/failure.rs
+++ b/src/libstd/failure.rs
@@ -37,7 +37,7 @@ pub fn on_fail(obj: &(Any+Send), file: &'static str, line: uint) {
     let msg = match obj.downcast_ref::<&'static str>() {
         Some(s) => *s,
         None => match obj.downcast_ref::<String>() {
-            Some(s) => s.index(&FullRange),
+            Some(s) => &s[],
             None => "Box<Any>",
         }
     };
diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs
index 74c503e6f2b..ba13bd05dc5 100644
--- a/src/libstd/io/buffered.rs
+++ b/src/libstd/io/buffered.rs
@@ -15,7 +15,7 @@
 use cmp;
 use io::{Reader, Writer, Stream, Buffer, DEFAULT_BUF_SIZE, IoResult};
 use iter::{IteratorExt, ExactSizeIterator};
-use ops::{Drop, Index};
+use ops::Drop;
 use option::Option;
 use option::Option::{Some, None};
 use result::Result::Ok;
@@ -97,7 +97,7 @@ impl<R: Reader> Buffer for BufferedReader<R> {
             self.cap = try!(self.inner.read(self.buf.as_mut_slice()));
             self.pos = 0;
         }
-        Ok(self.buf.index(&(self.pos..self.cap)))
+        Ok(&self.buf[self.pos..self.cap])
     }
 
     fn consume(&mut self, amt: uint) {
@@ -114,7 +114,7 @@ impl<R: Reader> Reader for BufferedReader<R> {
         let nread = {
             let available = try!(self.fill_buf());
             let nread = cmp::min(available.len(), buf.len());
-            slice::bytes::copy_memory(buf, available.index(&(0..nread)));
+            slice::bytes::copy_memory(buf, &available[0..nread]);
             nread
         };
         self.pos += nread;
@@ -168,7 +168,7 @@ impl<W: Writer> BufferedWriter<W> {
 
     fn flush_buf(&mut self) -> IoResult<()> {
         if self.pos != 0 {
-            let ret = self.inner.as_mut().unwrap().write(self.buf.index(&(0..self.pos)));
+            let ret = self.inner.as_mut().unwrap().write(&self.buf[0..self.pos]);
             self.pos = 0;
             ret
         } else {
@@ -260,9 +260,9 @@ impl<W: Writer> Writer for LineBufferedWriter<W> {
     fn write(&mut self, buf: &[u8]) -> IoResult<()> {
         match buf.iter().rposition(|&b| b == b'\n') {
             Some(i) => {
-                try!(self.inner.write(buf.index(&(0..(i + 1)))));
+                try!(self.inner.write(&buf[0..(i + 1)]));
                 try!(self.inner.flush());
-                try!(self.inner.write(buf.index(&((i + 1)..))));
+                try!(self.inner.write(&buf[(i + 1)..]));
                 Ok(())
             }
             None => self.inner.write(buf),
@@ -510,7 +510,7 @@ mod test {
         assert_eq!(a, &w.get_ref()[]);
         let w = w.into_inner();
         let a: &[_] = &[0, 1];
-        assert_eq!(a, w.index(&FullRange));
+        assert_eq!(a, &w[]);
     }
 
     // This is just here to make sure that we don't infinite loop in the
@@ -607,14 +607,14 @@ mod test {
     #[test]
     fn read_char_buffered() {
         let buf = [195u8, 159u8];
-        let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange));
+        let mut reader = BufferedReader::with_capacity(1, &buf[]);
         assert_eq!(reader.read_char(), Ok('ß'));
     }
 
     #[test]
     fn test_chars() {
         let buf = [195u8, 159u8, b'a'];
-        let mut reader = BufferedReader::with_capacity(1, buf.index(&FullRange));
+        let mut reader = BufferedReader::with_capacity(1, &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 bce097e17ef..b578f4d5adc 100644
--- a/src/libstd/io/comm_adapters.rs
+++ b/src/libstd/io/comm_adapters.rs
@@ -13,7 +13,6 @@ use cmp;
 use sync::mpsc::{Sender, Receiver};
 use io;
 use option::Option::{None, Some};
-use ops::Index;
 use result::Result::{Ok, Err};
 use slice::{bytes, SliceExt};
 use super::{Buffer, Reader, Writer, IoResult};
@@ -91,7 +90,7 @@ impl Reader for ChanReader {
                 Some(src) => {
                     let dst = buf.slice_from_mut(num_read);
                     let count = cmp::min(src.len(), dst.len());
-                    bytes::copy_memory(dst, src.index(&(0..count)));
+                    bytes::copy_memory(dst, &src[0..count]);
                     count
                 },
                 None => 0,
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index eadca8e42e5..dbccc81c4cc 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -889,7 +889,7 @@ mod test {
             let mut read_buf = [0; 1028];
             let read_str = match check!(read_stream.read(&mut read_buf)) {
                 -1|0 => panic!("shouldn't happen"),
-                n => str::from_utf8(read_buf.index(&(0..n))).unwrap().to_string()
+                n => str::from_utf8(&read_buf[0..n]).unwrap().to_string()
             };
             assert_eq!(read_str.as_slice(), message);
         }
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index 9a6ad04fdbc..c5e289398e0 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -13,7 +13,6 @@
 //! Readers and Writers for in-memory buffers
 
 use cmp::min;
-use ops::Index;
 use option::Option::None;
 use result::Result::{Err, Ok};
 use io;
@@ -160,7 +159,7 @@ impl Reader for MemReader {
 
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
-            let input = self.buf.index(&(self.pos.. (self.pos + write_len)));
+            let input = &self.buf[self.pos.. (self.pos + write_len)];
             let output = buf.slice_to_mut(write_len);
             assert_eq!(input.len(), output.len());
             slice::bytes::copy_memory(output, input);
@@ -188,7 +187,7 @@ impl Buffer for MemReader {
     #[inline]
     fn fill_buf<'a>(&'a mut self) -> IoResult<&'a [u8]> {
         if self.pos < self.buf.len() {
-            Ok(self.buf.index(&(self.pos..)))
+            Ok(&self.buf[self.pos..])
         } else {
             Err(io::standard_error(io::EndOfFile))
         }
@@ -205,7 +204,7 @@ impl<'a> Reader for &'a [u8] {
 
         let write_len = min(buf.len(), self.len());
         {
-            let input = self.index(&(0..write_len));
+            let input = &self[0..write_len];
             let output = buf.slice_to_mut(write_len);
             slice::bytes::copy_memory(output, input);
         }
@@ -228,7 +227,7 @@ impl<'a> Buffer for &'a [u8] {
 
     #[inline]
     fn consume(&mut self, amt: uint) {
-        *self = self.index(&(amt..));
+        *self = &self[amt..];
     }
 }
 
@@ -287,7 +286,7 @@ impl<'a> Writer for BufWriter<'a> {
 
             Ok(())
         } else {
-            slice::bytes::copy_memory(dst, src.index(&(0..dst_len)));
+            slice::bytes::copy_memory(dst, &src[0..dst_len]);
 
             self.pos += dst_len;
 
@@ -350,7 +349,7 @@ impl<'a> Reader for BufReader<'a> {
 
         let write_len = min(buf.len(), self.buf.len() - self.pos);
         {
-            let input = self.buf.index(&(self.pos.. (self.pos + write_len)));
+            let input = &self.buf[self.pos.. (self.pos + write_len)];
             let output = buf.slice_to_mut(write_len);
             assert_eq!(input.len(), output.len());
             slice::bytes::copy_memory(output, input);
@@ -378,7 +377,7 @@ impl<'a> Buffer for BufReader<'a> {
     #[inline]
     fn fill_buf(&mut self) -> IoResult<&[u8]> {
         if self.pos < self.buf.len() {
-            Ok(self.buf.index(&(self.pos..)))
+            Ok(&self.buf[self.pos..])
         } else {
             Err(io::standard_error(io::EndOfFile))
         }
@@ -393,7 +392,7 @@ mod test {
     extern crate "test" as test_crate;
     use io::{SeekSet, SeekCur, SeekEnd, Reader, Writer, Seek};
     use prelude::v1::{Ok, Err, range,  Vec, Buffer,  AsSlice, SliceExt};
-    use prelude::v1::{IteratorExt, Index};
+    use prelude::v1::IteratorExt;
     use io;
     use iter::repeat;
     use self::test_crate::Bencher;
@@ -499,7 +498,7 @@ mod test {
         assert_eq!(buf, b);
         assert_eq!(reader.read(&mut buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf.index(&(0..3)), b);
+        assert_eq!(&buf[0..3], b);
         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));
@@ -525,7 +524,7 @@ mod test {
         assert_eq!(buf.as_slice(), b);
         assert_eq!(reader.read(&mut buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf.index(&(0..3)), b);
+        assert_eq!(&buf[0..3], b);
         assert!(reader.read(&mut buf).is_err());
         let mut reader = &mut in_buf.as_slice();
         assert_eq!(reader.read_until(3).unwrap(), vec!(0, 1, 2, 3));
@@ -552,7 +551,7 @@ mod test {
         assert_eq!(buf, b);
         assert_eq!(reader.read(&mut buf), Ok(3));
         let b: &[_] = &[5, 6, 7];
-        assert_eq!(buf.index(&(0..3)), b);
+        assert_eq!(&buf[0..3], b);
         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));
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index 2595a3c44a8..c71ab514695 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -236,7 +236,7 @@ use int;
 use iter::{Iterator, IteratorExt};
 use marker::Sized;
 use mem::transmute;
-use ops::{FnOnce, Index};
+use ops::FnOnce;
 use option::Option;
 use option::Option::{Some, None};
 use os;
@@ -1069,7 +1069,7 @@ pub trait Writer {
     fn write_char(&mut self, c: char) -> IoResult<()> {
         let mut buf = [0u8; 4];
         let n = c.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
-        self.write(buf.index(&(0..n)))
+        self.write(&buf[0..n])
     }
 
     /// Write the result of passing n through `int::to_str_bytes`.
@@ -1454,7 +1454,7 @@ pub trait Buffer: Reader {
                 };
                 match available.iter().position(|&b| b == byte) {
                     Some(i) => {
-                        res.push_all(available.index(&(0..(i + 1))));
+                        res.push_all(&available[0..(i + 1)]);
                         used = i + 1;
                         break
                     }
@@ -1493,7 +1493,7 @@ pub trait Buffer: Reader {
                 }
             }
         }
-        match str::from_utf8(buf.index(&(0..width))).ok() {
+        match str::from_utf8(&buf[0..width]).ok() {
             Some(s) => Ok(s.char_at(0)),
             None => Err(standard_error(InvalidInput))
         }
diff --git a/src/libstd/io/net/ip.rs b/src/libstd/io/net/ip.rs
index b9f653f86c2..d09afea94dc 100644
--- a/src/libstd/io/net/ip.rs
+++ b/src/libstd/io/net/ip.rs
@@ -22,7 +22,7 @@ use fmt;
 use io::{self, IoResult, IoError};
 use io::net;
 use iter::{Iterator, IteratorExt};
-use ops::{FnOnce, FnMut, Index};
+use ops::{FnOnce, FnMut};
 use option::Option;
 use option::Option::{None, Some};
 use result::Result::{Ok, Err};
@@ -313,7 +313,7 @@ impl<'a> Parser<'a> {
 
         let mut tail = [0u16; 8];
         let (tail_size, _) = read_groups(self, &mut tail, 8 - head_size);
-        Some(ipv6_addr_from_head_tail(head.index(&(0..head_size)), tail.index(&(0..tail_size))))
+        Some(ipv6_addr_from_head_tail(&head[0..head_size], &tail[0..tail_size]))
     }
 
     fn read_ipv6_addr(&mut self) -> Option<IpAddr> {
diff --git a/src/libstd/io/util.rs b/src/libstd/io/util.rs
index c0254a3e7a2..5a7219495f5 100644
--- a/src/libstd/io/util.rs
+++ b/src/libstd/io/util.rs
@@ -59,7 +59,7 @@ impl<R: Reader> Reader for LimitReader<R> {
 impl<R: Buffer> Buffer for LimitReader<R> {
     fn fill_buf<'a>(&'a mut self) -> io::IoResult<&'a [u8]> {
         let amt = try!(self.inner.fill_buf());
-        let buf = amt.index(&(0..cmp::min(amt.len(), self.limit)));
+        let buf = &amt[0..cmp::min(amt.len(), self.limit)];
         if buf.len() == 0 {
             Err(io::standard_error(io::EndOfFile))
         } else {
@@ -220,7 +220,7 @@ impl<R: Reader, W: Writer> TeeReader<R, W> {
 impl<R: Reader, W: Writer> Reader for TeeReader<R, W> {
     fn read(&mut self, buf: &mut [u8]) -> io::IoResult<uint> {
         self.reader.read(buf).and_then(|len| {
-            self.writer.write(buf.index_mut(&(0..len))).map(|()| len)
+            self.writer.write(&mut buf[0..len]).map(|()| len)
         })
     }
 }
@@ -234,7 +234,7 @@ pub fn copy<R: Reader, W: Writer>(r: &mut R, w: &mut W) -> io::IoResult<()> {
             Err(ref e) if e.kind == io::EndOfFile => return Ok(()),
             Err(e) => return Err(e),
         };
-        try!(w.write(buf.index(&(0..len))));
+        try!(w.write(&buf[0..len]));
     }
 }
 
diff --git a/src/libstd/path/mod.rs b/src/libstd/path/mod.rs
index 581969e98fb..0d7c213cd96 100644
--- a/src/libstd/path/mod.rs
+++ b/src/libstd/path/mod.rs
@@ -68,7 +68,7 @@ use fmt;
 use iter::IteratorExt;
 use option::Option;
 use option::Option::{None, Some};
-use ops::{FullRange, Index};
+use ops::FullRange;
 use str;
 use str::StrExt;
 use string::{String, CowString};
@@ -352,7 +352,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
                 match name.rposition_elem(&dot) {
                     None | Some(0) => name,
                     Some(1) if name == b".." => name,
-                    Some(pos) => name.index(&(0..pos))
+                    Some(pos) => &name[0..pos]
                 }
             })
         }
@@ -399,7 +399,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
                 match name.rposition_elem(&dot) {
                     None | Some(0) => None,
                     Some(1) if name == b".." => None,
-                    Some(pos) => Some(name.index(&((pos+1)..)))
+                    Some(pos) => Some(&name[(pos+1)..])
                 }
             }
         }
@@ -475,7 +475,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
             let extlen = extension.container_as_bytes().len();
             match (name.rposition_elem(&dot), extlen) {
                 (None, 0) | (Some(0), 0) => None,
-                (Some(idx), 0) => Some(name.index(&(0..idx)).to_vec()),
+                (Some(idx), 0) => Some(name[0..idx].to_vec()),
                 (idx, extlen) => {
                     let idx = match idx {
                         None | Some(0) => name.len(),
@@ -484,7 +484,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
 
                     let mut v;
                     v = Vec::with_capacity(idx + extlen + 1);
-                    v.push_all(name.index(&(0..idx)));
+                    v.push_all(&name[0..idx]);
                     v.push(dot);
                     v.push_all(extension.container_as_bytes());
                     Some(v)
@@ -877,7 +877,7 @@ impl BytesContainer for String {
     }
     #[inline]
     fn container_as_str(&self) -> Option<&str> {
-        Some(self.index(&FullRange))
+        Some(&self[])
     }
     #[inline]
     fn is_str(_: Option<&String>) -> bool { true }
@@ -893,7 +893,7 @@ impl BytesContainer for [u8] {
 impl BytesContainer for Vec<u8> {
     #[inline]
     fn container_as_bytes(&self) -> &[u8] {
-        self.index(&FullRange)
+        &self[]
     }
 }
 
diff --git a/src/libstd/path/posix.rs b/src/libstd/path/posix.rs
index 0b7dc19fcab..708fe724cb1 100644
--- a/src/libstd/path/posix.rs
+++ b/src/libstd/path/posix.rs
@@ -17,7 +17,6 @@ use hash;
 use io::Writer;
 use iter::{AdditiveIterator, Extend};
 use iter::{Iterator, IteratorExt, Map};
-use ops::Index;
 use marker::Sized;
 use option::Option::{self, Some, None};
 use slice::{AsSlice, Split, SliceExt, SliceConcatExt};
@@ -127,7 +126,7 @@ impl GenericPathUnsafe for Path {
             None => {
                 self.repr = Path::normalize(filename);
             }
-            Some(idx) if self.repr.index(&((idx+1)..)) == b".." => {
+            Some(idx) if &self.repr[(idx+1)..] == b".." => {
                 let mut v = Vec::with_capacity(self.repr.len() + 1 + filename.len());
                 v.push_all(self.repr.as_slice());
                 v.push(SEP_BYTE);
@@ -137,7 +136,7 @@ impl GenericPathUnsafe for Path {
             }
             Some(idx) => {
                 let mut v = Vec::with_capacity(idx + 1 + filename.len());
-                v.push_all(self.repr.index(&(0..(idx+1))));
+                v.push_all(&self.repr[0..(idx+1)]);
                 v.push_all(filename);
                 // FIXME: this is slow
                 self.repr = Path::normalize(v.as_slice());
@@ -178,9 +177,9 @@ impl GenericPath for Path {
         match self.sepidx {
             None if b".." == self.repr => self.repr.as_slice(),
             None => dot_static,
-            Some(0) => self.repr.index(&(0..1)),
-            Some(idx) if self.repr.index(&((idx+1)..)) == b".." => self.repr.as_slice(),
-            Some(idx) => self.repr.index(&(0..idx))
+            Some(0) => &self.repr[0..1],
+            Some(idx) if &self.repr[(idx+1)..] == b".." => self.repr.as_slice(),
+            Some(idx) => &self.repr[0..idx]
         }
     }
 
@@ -189,9 +188,9 @@ impl GenericPath for Path {
             None if b"." == self.repr ||
                 b".." == self.repr => None,
             None => Some(self.repr.as_slice()),
-            Some(idx) if self.repr.index(&((idx+1)..)) == b".." => None,
-            Some(0) if self.repr.index(&(1..)).is_empty() => None,
-            Some(idx) => Some(self.repr.index(&((idx+1)..)))
+            Some(idx) if &self.repr[(idx+1)..] == b".." => None,
+            Some(0) if self.repr[1..].is_empty() => None,
+            Some(idx) => Some(&self.repr[(idx+1)..])
         }
     }
 
@@ -333,7 +332,7 @@ impl Path {
         // borrowck is being very picky
         let val = {
             let is_abs = !v.as_slice().is_empty() && v.as_slice()[0] == SEP_BYTE;
-            let v_ = if is_abs { v.as_slice().index(&(1..)) } else { v.as_slice() };
+            let v_ = if is_abs { &v.as_slice()[1..] } else { v.as_slice() };
             let comps = normalize_helper(v_, is_abs);
             match comps {
                 None => None,
@@ -372,7 +371,7 @@ impl Path {
     /// A path of "/" yields no components. A path of "." yields one component.
     pub fn components<'a>(&'a self) -> Components<'a> {
         let v = if self.repr[0] == SEP_BYTE {
-            self.repr.index(&(1..))
+            &self.repr[1..]
         } else { self.repr.as_slice() };
         let is_sep_byte: fn(&u8) -> bool = is_sep_byte; // coerce to fn ptr
         let mut ret = v.split(is_sep_byte);
diff --git a/src/libstd/path/windows.rs b/src/libstd/path/windows.rs
index 5c4e7aa9ac2..dee511bc097 100644
--- a/src/libstd/path/windows.rs
+++ b/src/libstd/path/windows.rs
@@ -25,7 +25,7 @@ use iter::{AdditiveIterator, Extend};
 use iter::{Iterator, IteratorExt, Map, repeat};
 use mem;
 use option::Option::{self, Some, None};
-use ops::{FullRange, Index};
+use ops::FullRange;
 use slice::{SliceExt, SliceConcatExt};
 use str::{SplitTerminator, FromStr, StrExt};
 use string::{String, ToString};
@@ -173,30 +173,30 @@ impl GenericPathUnsafe for Path {
                 s.push_str("..");
                 s.push(SEP);
                 s.push_str(filename);
-                self.update_normalized(s.index(&FullRange));
+                self.update_normalized(&s[]);
             }
             None => {
                 self.update_normalized(filename);
             }
-            Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => {
+            Some((_,idxa,end)) if &self.repr[idxa..end] == ".." => {
                 let mut s = String::with_capacity(end + 1 + filename.len());
-                s.push_str(self.repr.index(&(0..end)));
+                s.push_str(&self.repr[0..end]);
                 s.push(SEP);
                 s.push_str(filename);
-                self.update_normalized(s.index(&FullRange));
+                self.update_normalized(&s[]);
             }
             Some((idxb,idxa,_)) if self.prefix == Some(DiskPrefix) && idxa == self.prefix_len() => {
                 let mut s = String::with_capacity(idxb + filename.len());
-                s.push_str(self.repr.index(&(0..idxb)));
+                s.push_str(&self.repr[0..idxb]);
                 s.push_str(filename);
-                self.update_normalized(s.index(&FullRange));
+                self.update_normalized(&s[]);
             }
             Some((idxb,_,_)) => {
                 let mut s = String::with_capacity(idxb + 1 + filename.len());
-                s.push_str(self.repr.index(&(0..idxb)));
+                s.push_str(&self.repr[0..idxb]);
                 s.push(SEP);
                 s.push_str(filename);
-                self.update_normalized(s.index(&FullRange));
+                self.update_normalized(&s[]);
             }
         }
     }
@@ -215,12 +215,12 @@ impl GenericPathUnsafe for Path {
         let path = path.container_as_str().unwrap();
         fn is_vol_abs(path: &str, prefix: Option<PathPrefix>) -> bool {
             // assume prefix is Some(DiskPrefix)
-            let rest = path.index(&(prefix_len(prefix)..));
+            let rest = &path[prefix_len(prefix)..];
             !rest.is_empty() && rest.as_bytes()[0].is_ascii() && is_sep(rest.as_bytes()[0] as char)
         }
         fn shares_volume(me: &Path, path: &str) -> bool {
             // path is assumed to have a prefix of Some(DiskPrefix)
-            let repr = me.repr.index(&FullRange);
+            let repr = &me.repr[];
             match me.prefix {
                 Some(DiskPrefix) => {
                     repr.as_bytes()[0] == path.as_bytes()[0].to_ascii_uppercase()
@@ -252,7 +252,7 @@ impl GenericPathUnsafe for Path {
                         else { None };
             let pathlen = path_.as_ref().map_or(path.len(), |p| p.len());
             let mut s = String::with_capacity(me.repr.len() + 1 + pathlen);
-            s.push_str(me.repr.index(&FullRange));
+            s.push_str(&me.repr[]);
             let plen = me.prefix_len();
             // if me is "C:" we don't want to add a path separator
             match me.prefix {
@@ -264,9 +264,9 @@ impl GenericPathUnsafe for Path {
             }
             match path_ {
                 None => s.push_str(path),
-                Some(p) => s.push_str(p.index(&FullRange)),
+                Some(p) => s.push_str(&p[]),
             };
-            me.update_normalized(s.index(&FullRange))
+            me.update_normalized(&s[])
         }
 
         if !path.is_empty() {
@@ -274,7 +274,7 @@ impl GenericPathUnsafe for Path {
             match prefix {
                 Some(DiskPrefix) if !is_vol_abs(path, prefix) && shares_volume(self, path) => {
                     // cwd-relative path, self is on the same volume
-                    append_path(self, path.index(&(prefix_len(prefix)..)));
+                    append_path(self, &path[prefix_len(prefix)..]);
                 }
                 Some(_) => {
                     // absolute path, or cwd-relative and self is not same volume
@@ -320,7 +320,7 @@ impl GenericPath for Path {
     /// Always returns a `Some` value.
     #[inline]
     fn as_str<'a>(&'a self) -> Option<&'a str> {
-        Some(self.repr.index(&FullRange))
+        Some(&self.repr[])
     }
 
     #[inline]
@@ -342,21 +342,21 @@ impl GenericPath for Path {
     /// Always returns a `Some` value.
     fn dirname_str<'a>(&'a self) -> Option<&'a str> {
         Some(match self.sepidx_or_prefix_len() {
-            None if ".." == self.repr => self.repr.index(&FullRange),
+            None if ".." == self.repr => &self.repr[],
             None => ".",
-            Some((_,idxa,end)) if self.repr.index(&(idxa..end)) == ".." => {
-                self.repr.index(&FullRange)
+            Some((_,idxa,end)) if &self.repr[idxa..end] == ".." => {
+                &self.repr[]
             }
-            Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => {
-                self.repr.index(&FullRange)
+            Some((idxb,_,end)) if &self.repr[idxb..end] == "\\" => {
+                &self.repr[]
             }
-            Some((0,idxa,_)) => self.repr.index(&(0..idxa)),
+            Some((0,idxa,_)) => &self.repr[0..idxa],
             Some((idxb,idxa,_)) => {
                 match self.prefix {
                     Some(DiskPrefix) | Some(VerbatimDiskPrefix) if idxb == self.prefix_len() => {
-                        self.repr.index(&(0..idxa))
+                        &self.repr[0..idxa]
                     }
-                    _ => self.repr.index(&(0..idxb))
+                    _ => &self.repr[0..idxb]
                 }
             }
         })
@@ -370,13 +370,13 @@ impl GenericPath for Path {
     /// See `GenericPath::filename_str` for info.
     /// Always returns a `Some` value if `filename` returns a `Some` value.
     fn filename_str<'a>(&'a self) -> Option<&'a str> {
-        let repr = self.repr.index(&FullRange);
+        let repr = &self.repr[];
         match self.sepidx_or_prefix_len() {
             None if "." == repr || ".." == repr => None,
             None => Some(repr),
-            Some((_,idxa,end)) if repr.index(&(idxa..end)) == ".." => None,
+            Some((_,idxa,end)) if &repr[idxa..end] == ".." => None,
             Some((_,idxa,end)) if idxa == end => None,
-            Some((_,idxa,end)) => Some(repr.index(&(idxa..end)))
+            Some((_,idxa,end)) => Some(&repr[idxa..end])
         }
     }
 
@@ -408,7 +408,7 @@ impl GenericPath for Path {
                 true
             }
             Some((idxb,idxa,end)) if idxb == idxa && idxb == end => false,
-            Some((idxb,_,end)) if self.repr.index(&(idxb..end)) == "\\" => false,
+            Some((idxb,_,end)) if &self.repr[idxb..end] == "\\" => false,
             Some((idxb,idxa,_)) => {
                 let trunc = match self.prefix {
                     Some(DiskPrefix) | Some(VerbatimDiskPrefix) | None => {
@@ -428,15 +428,15 @@ impl GenericPath for Path {
         if self.prefix.is_some() {
             Some(Path::new(match self.prefix {
                 Some(DiskPrefix) if self.is_absolute() => {
-                    self.repr.index(&(0..(self.prefix_len()+1)))
+                    &self.repr[0..(self.prefix_len()+1)]
                 }
                 Some(VerbatimDiskPrefix) => {
-                    self.repr.index(&(0..(self.prefix_len()+1)))
+                    &self.repr[0..(self.prefix_len()+1)]
                 }
-                _ => self.repr.index(&(0..self.prefix_len()))
+                _ => &self.repr[0..self.prefix_len()]
             }))
         } else if is_vol_relative(self) {
-            Some(Path::new(self.repr.index(&(0..1))))
+            Some(Path::new(&self.repr[0..1]))
         } else {
             None
         }
@@ -455,7 +455,7 @@ impl GenericPath for Path {
     fn is_absolute(&self) -> bool {
         match self.prefix {
             Some(DiskPrefix) => {
-                let rest = self.repr.index(&(self.prefix_len()..));
+                let rest = &self.repr[self.prefix_len()..];
                 rest.len() > 0 && rest.as_bytes()[0] == SEP_BYTE
             }
             Some(_) => true,
@@ -630,15 +630,15 @@ impl Path {
     /// Does not distinguish between absolute and cwd-relative paths, e.g.
     /// C:\foo and C:foo.
     pub fn str_components<'a>(&'a self) -> StrComponents<'a> {
-        let repr = self.repr.index(&FullRange);
+        let repr = &self.repr[];
         let s = match self.prefix {
             Some(_) => {
                 let plen = self.prefix_len();
                 if repr.len() > plen && repr.as_bytes()[plen] == SEP_BYTE {
-                    repr.index(&((plen+1)..))
-                } else { repr.index(&(plen..)) }
+                    &repr[(plen+1)..]
+                } else { &repr[plen..] }
             }
-            None if repr.as_bytes()[0] == SEP_BYTE => repr.index(&(1..)),
+            None if repr.as_bytes()[0] == SEP_BYTE => &repr[1..],
             None => repr
         };
         let some: fn(&'a str) -> Option<&'a str> = Some; // coerce to fn ptr
@@ -658,8 +658,8 @@ impl Path {
     }
 
     fn equiv_prefix(&self, other: &Path) -> bool {
-        let s_repr = self.repr.index(&FullRange);
-        let o_repr = other.repr.index(&FullRange);
+        let s_repr = &self.repr[];
+        let o_repr = &other.repr[];
         match (self.prefix, other.prefix) {
             (Some(DiskPrefix), Some(VerbatimDiskPrefix)) => {
                 self.is_absolute() &&
@@ -676,14 +676,14 @@ impl Path {
                     o_repr.as_bytes()[4].to_ascii_lowercase()
             }
             (Some(UNCPrefix(_,_)), Some(VerbatimUNCPrefix(_,_))) => {
-                s_repr.index(&(2..self.prefix_len())) == o_repr.index(&(8..other.prefix_len()))
+                &s_repr[2..self.prefix_len()] == &o_repr[8..other.prefix_len()]
             }
             (Some(VerbatimUNCPrefix(_,_)), Some(UNCPrefix(_,_))) => {
-                s_repr.index(&(8..self.prefix_len())) == o_repr.index(&(2..other.prefix_len()))
+                &s_repr[8..self.prefix_len()] == &o_repr[2..other.prefix_len()]
             }
             (None, None) => true,
             (a, b) if a == b => {
-                s_repr.index(&(0..self.prefix_len())) == o_repr.index(&(0..other.prefix_len()))
+                &s_repr[0..self.prefix_len()] == &o_repr[0..other.prefix_len()]
             }
             _ => false
         }
@@ -737,7 +737,7 @@ impl Path {
                         match prefix.unwrap() {
                             DiskPrefix => {
                                 let len = prefix_len(prefix) + is_abs as uint;
-                                let mut s = String::from_str(s.index(&(0..len)));
+                                let mut s = String::from_str(&s[0..len]);
                                 unsafe {
                                     let v = s.as_mut_vec();
                                     v[0] = (*v)[0].to_ascii_uppercase();
@@ -752,7 +752,7 @@ impl Path {
                             }
                             VerbatimDiskPrefix => {
                                 let len = prefix_len(prefix) + is_abs as uint;
-                                let mut s = String::from_str(s.index(&(0..len)));
+                                let mut s = String::from_str(&s[0..len]);
                                 unsafe {
                                     let v = s.as_mut_vec();
                                     v[4] = (*v)[4].to_ascii_uppercase();
@@ -762,14 +762,14 @@ impl Path {
                             _ => {
                                 let plen = prefix_len(prefix);
                                 if s.len() > plen {
-                                    Some(String::from_str(s.index(&(0..plen))))
+                                    Some(String::from_str(&s[0..plen]))
                                 } else { None }
                             }
                         }
                     } else if is_abs && comps.is_empty() {
                         Some(repeat(SEP).take(1).collect())
                     } else {
-                        let prefix_ = s.index(&(0..prefix_len(prefix)));
+                        let prefix_ = &s[0..prefix_len(prefix)];
                         let n = prefix_.len() +
                                 if is_abs { comps.len() } else { comps.len() - 1} +
                                 comps.iter().map(|v| v.len()).sum();
@@ -780,15 +780,15 @@ impl Path {
                                 s.push(':');
                             }
                             Some(VerbatimDiskPrefix) => {
-                                s.push_str(prefix_.index(&(0..4)));
+                                s.push_str(&prefix_[0..4]);
                                 s.push(prefix_.as_bytes()[4].to_ascii_uppercase() as char);
-                                s.push_str(prefix_.index(&(5..)));
+                                s.push_str(&prefix_[5..]);
                             }
                             Some(UNCPrefix(a,b)) => {
                                 s.push_str("\\\\");
-                                s.push_str(prefix_.index(&(2..(a+2))));
+                                s.push_str(&prefix_[2..(a+2)]);
                                 s.push(SEP);
-                                s.push_str(prefix_.index(&((3+a)..(3+a+b))));
+                                s.push_str(&prefix_[(3+a)..(3+a+b)]);
                             }
                             Some(_) => s.push_str(prefix_),
                             None => ()
@@ -813,8 +813,8 @@ impl Path {
 
     fn update_sepidx(&mut self) {
         let s = if self.has_nonsemantic_trailing_slash() {
-                    self.repr.index(&(0..(self.repr.len()-1)))
-                } else { self.repr.index(&FullRange) };
+                    &self.repr[0..(self.repr.len()-1)]
+                } else { &self.repr[] };
         let sep_test: fn(char) -> bool = if !prefix_is_verbatim(self.prefix) {
             is_sep
         } else {
@@ -893,17 +893,17 @@ pub fn is_verbatim(path: &Path) -> bool {
 /// non-verbatim, the non-verbatim version is returned.
 /// Otherwise, None is returned.
 pub fn make_non_verbatim(path: &Path) -> Option<Path> {
-    let repr = path.repr.index(&FullRange);
+    let repr = &path.repr[];
     let new_path = match path.prefix {
         Some(VerbatimPrefix(_)) | Some(DeviceNSPrefix(_)) => return None,
         Some(UNCPrefix(_,_)) | Some(DiskPrefix) | None => return Some(path.clone()),
         Some(VerbatimDiskPrefix) => {
             // \\?\D:\
-            Path::new(repr.index(&(4..)))
+            Path::new(&repr[4..])
         }
         Some(VerbatimUNCPrefix(_,_)) => {
             // \\?\UNC\server\share
-            Path::new(format!(r"\{}", repr.index(&(7..))))
+            Path::new(format!(r"\{}", &repr[7..]))
         }
     };
     if new_path.prefix.is_none() {
@@ -912,8 +912,7 @@ pub fn make_non_verbatim(path: &Path) -> Option<Path> {
         return None;
     }
     // now ensure normalization didn't change anything
-    if repr.index(&(path.prefix_len()..)) ==
-        new_path.repr.index(&(new_path.prefix_len()..)) {
+    if &repr[path.prefix_len()..] == &new_path.repr[new_path.prefix_len()..] {
         Some(new_path)
     } else {
         None
@@ -978,13 +977,13 @@ pub enum PathPrefix {
 fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
     if path.starts_with("\\\\") {
         // \\
-        path = path.index(&(2..));
+        path = &path[2..];
         if path.starts_with("?\\") {
             // \\?\
-            path = path.index(&(2..));
+            path = &path[2..];
             if path.starts_with("UNC\\") {
                 // \\?\UNC\server\share
-                path = path.index(&(4..));
+                path = &path[4..];
                 let (idx_a, idx_b) = match parse_two_comps(path, is_sep_verbatim) {
                     Some(x) => x,
                     None => (path.len(), 0)
@@ -1005,7 +1004,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
             }
         } else if path.starts_with(".\\") {
             // \\.\path
-            path = path.index(&(2..));
+            path = &path[2..];
             let idx = path.find('\\').unwrap_or(path.len());
             return Some(DeviceNSPrefix(idx));
         }
@@ -1030,7 +1029,7 @@ fn parse_prefix<'a>(mut path: &'a str) -> Option<PathPrefix> {
             None => return None,
             Some(x) => x
         };
-        path = path.index(&((idx_a+1)..));
+        path = &path[(idx_a+1)..];
         let idx_b = path.find(f).unwrap_or(path.len());
         Some((idx_a, idx_b))
     }
@@ -1044,8 +1043,8 @@ fn normalize_helper<'a>(s: &'a str, prefix: Option<PathPrefix>) -> (bool, Option
         is_sep_verbatim
     };
     let is_abs = s.len() > prefix_len(prefix) && f(s.char_at(prefix_len(prefix)));
-    let s_ = s.index(&(prefix_len(prefix)..));
-    let s_ = if is_abs { s_.index(&(1..)) } else { s_ };
+    let s_ = &s[prefix_len(prefix)..];
+    let s_ = if is_abs { &s_[1..] } else { s_ };
 
     if is_abs && s_.is_empty() {
         return (is_abs, match prefix {
diff --git a/src/libstd/prelude/v1.rs b/src/libstd/prelude/v1.rs
index dcb342b9ca2..d9c942c0185 100644
--- a/src/libstd/prelude/v1.rs
+++ b/src/libstd/prelude/v1.rs
@@ -17,7 +17,7 @@
 #[stable] #[doc(no_inline)] pub use ops::{Drop, Fn, FnMut, FnOnce};
 
 // TEMPORARY
-#[unstable] #[doc(no_inline)] pub use ops::{Index, IndexMut, FullRange};
+#[unstable] #[doc(no_inline)] pub use ops::FullRange;
 
 // Reexported functions
 #[stable] #[doc(no_inline)] pub use mem::drop;
diff --git a/src/libstd/rt/unwind.rs b/src/libstd/rt/unwind.rs
index fd84f220942..03876189da9 100644
--- a/src/libstd/rt/unwind.rs
+++ b/src/libstd/rt/unwind.rs
@@ -544,7 +544,7 @@ fn begin_unwind_inner(msg: Box<Any + Send>, file_line: &(&'static str, uint)) ->
     // MAX_CALLBACKS, so we're sure to clamp it as necessary.
     let callbacks = {
         let amt = CALLBACK_CNT.load(Ordering::SeqCst);
-        CALLBACKS.index(&(0..cmp::min(amt, MAX_CALLBACKS)))
+        &CALLBACKS[0..cmp::min(amt, MAX_CALLBACKS)]
     };
     for cb in callbacks.iter() {
         match cb.load(Ordering::SeqCst) {
diff --git a/src/libstd/rt/util.rs b/src/libstd/rt/util.rs
index 59f654a95ca..c076f0a7c6c 100644
--- a/src/libstd/rt/util.rs
+++ b/src/libstd/rt/util.rs
@@ -131,7 +131,7 @@ pub fn abort(args: fmt::Arguments) -> ! {
     impl<'a> fmt::Writer for BufWriter<'a> {
         fn write_str(&mut self, bytes: &str) -> fmt::Result {
             let left = self.buf.slice_from_mut(self.pos);
-            let to_write = bytes.as_bytes().index(&(0..cmp::min(bytes.len(), left.len())));
+            let to_write = &bytes.as_bytes()[0..cmp::min(bytes.len(), left.len())];
             slice::bytes::copy_memory(left, to_write);
             self.pos += to_write.len();
             Ok(())
@@ -142,7 +142,7 @@ pub fn abort(args: fmt::Arguments) -> ! {
     let mut msg = [0u8; 512];
     let mut w = BufWriter { buf: &mut msg, pos: 0 };
     let _ = write!(&mut w, "{}", args);
-    let msg = str::from_utf8(w.buf.index_mut(&(0..w.pos))).unwrap_or("aborted");
+    let msg = str::from_utf8(&w.buf[0..w.pos]).unwrap_or("aborted");
     let msg = if msg.is_empty() {"aborted"} else {msg};
 
     // Give some context to the message
diff --git a/src/libstd/sys/common/net.rs b/src/libstd/sys/common/net.rs
index 902942d7244..4cf891ac498 100644
--- a/src/libstd/sys/common/net.rs
+++ b/src/libstd/sys/common/net.rs
@@ -469,7 +469,7 @@ pub fn write<T, L, W>(fd: sock_t,
             // Also as with read(), we use MSG_DONTWAIT to guard ourselves
             // against unforeseen circumstances.
             let _guard = lock();
-            let ptr = buf.index(&(written..)).as_ptr();
+            let ptr = buf[written..].as_ptr();
             let len = buf.len() - written;
             match retry(|| write(deadline.is_some(), ptr, len)) {
                 -1 if wouldblock() => {}
diff --git a/src/libstd/sys/windows/backtrace.rs b/src/libstd/sys/windows/backtrace.rs
index eb76f13afe7..ee2dd14955b 100644
--- a/src/libstd/sys/windows/backtrace.rs
+++ b/src/libstd/sys/windows/backtrace.rs
@@ -362,7 +362,7 @@ pub fn write(w: &mut Writer) -> IoResult<()> {
             let bytes = unsafe { ffi::c_str_to_bytes(&ptr) };
             match str::from_utf8(bytes) {
                 Ok(s) => try!(demangle(w, s)),
-                Err(..) => try!(w.write(bytes.index(&(..(bytes.len()-1))))),
+                Err(..) => try!(w.write(&bytes[..(bytes.len()-1)])),
             }
         }
         try!(w.write(&['\n' as u8]));
diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs
index fcde5c01080..064633f321c 100644
--- a/src/libstd/sys/windows/os.rs
+++ b/src/libstd/sys/windows/os.rs
@@ -36,7 +36,7 @@ const BUF_BYTES : uint = 2048u;
 pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] {
     match v.iter().position(|c| *c == 0) {
         // don't include the 0
-        Some(i) => v.index(&(0..i)),
+        Some(i) => &v[0..i],
         None => v
     }
 }
diff --git a/src/libstd/sys/windows/pipe.rs b/src/libstd/sys/windows/pipe.rs
index 016757ef63e..9996909f2f5 100644
--- a/src/libstd/sys/windows/pipe.rs
+++ b/src/libstd/sys/windows/pipe.rs
@@ -453,7 +453,7 @@ impl UnixStream {
             }
             let ret = unsafe {
                 libc::WriteFile(self.handle(),
-                                buf.index(&(offset..)).as_ptr() as libc::LPVOID,
+                                buf[offset..].as_ptr() as libc::LPVOID,
                                 (buf.len() - offset) as libc::DWORD,
                                 &mut bytes_written,
                                 &mut overlapped)