Fallout from stabilization

3 files changed, 14 insertions, 14 deletions

diff --git a/src/libregex/compile.rs b/src/libregex/compile.rs
index c361a25bf52..1476e6ab8a7 100644
--- a/src/libregex/compile.rs
+++ b/src/libregex/compile.rs
@@ -14,6 +14,7 @@
 pub use self::Inst::*;
 
 use std::cmp;
+use std::iter::repeat;
 use parse;
 use parse::{
     Flags, FLAG_EMPTY,
@@ -157,7 +158,7 @@ impl<'r> Compiler<'r> {
             Capture(cap, name, x) => {
                 let len = self.names.len();
                 if cap >= len {
-                    self.names.grow(10 + cap - len, None)
+                    self.names.extend(repeat(None).take(10 + cap - len))
                 }
                 self.names[cap] = name;
 
diff --git a/src/libregex/parse.rs b/src/libregex/parse.rs
index 86c02de76dc..692a065299c 100644
--- a/src/libregex/parse.rs
+++ b/src/libregex/parse.rs
@@ -18,7 +18,6 @@ use std::cmp;
 use std::fmt;
 use std::iter;
 use std::num;
-use std::slice::BinarySearchResult;
 
 /// Static data containing Unicode ranges for general categories and scripts.
 use unicode::regex::{UNICODE_CLASSES, PERLD, PERLS, PERLW};
@@ -1028,9 +1027,9 @@ fn is_valid_cap(c: char) -> bool {
 }
 
 fn find_class(classes: NamedClasses, name: &str) -> Option<Vec<(char, char)>> {
-    match classes.binary_search(|&(s, _)| s.cmp(name)) {
-        BinarySearchResult::Found(i) => Some(classes[i].1.to_vec()),
-        BinarySearchResult::NotFound(_) => None,
+    match classes.binary_search_by(|&(s, _)| s.cmp(name)) {
+        Ok(i) => Some(classes[i].1.to_vec()),
+        Err(_) => None,
     }
 }
 
diff --git a/src/libregex/vm.rs b/src/libregex/vm.rs
index 990d5a159f6..72e0e559c80 100644
--- a/src/libregex/vm.rs
+++ b/src/libregex/vm.rs
@@ -38,6 +38,7 @@ pub use self::StepState::*;
 
 use std::cmp;
 use std::mem;
+use std::iter::repeat;
 use std::slice::SliceExt;
 use compile::{
     Program,
@@ -121,7 +122,7 @@ impl<'r, 't> Nfa<'r, 't> {
         let mut clist = &mut Threads::new(self.which, ninsts, ncaps);
         let mut nlist = &mut Threads::new(self.which, ninsts, ncaps);
 
-        let mut groups = Vec::from_elem(ncaps * 2, None);
+        let mut groups: Vec<_> = repeat(None).take(ncaps * 2).collect();
 
         // Determine if the expression starts with a '^' so we can avoid
         // simulating .*?
@@ -227,8 +228,7 @@ impl<'r, 't> Nfa<'r, 't> {
                     let negate = flags & FLAG_NEGATED > 0;
                     let casei = flags & FLAG_NOCASE > 0;
                     let found = ranges.as_slice();
-                    let found = found.binary_search(|&rc| class_cmp(casei, c, rc))
-                        .found().is_some();
+                    let found = found.binary_search_by(|&rc| class_cmp(casei, c, rc)).is_ok();
                     if found ^ negate {
                         self.add(nlist, pc+1, caps);
                     }
@@ -457,10 +457,10 @@ impl Threads {
     fn new(which: MatchKind, num_insts: uint, ncaps: uint) -> Threads {
         Threads {
             which: which,
-            queue: Vec::from_fn(num_insts, |_| {
-                Thread { pc: 0, groups: Vec::from_elem(ncaps * 2, None) }
-            }),
-            sparse: Vec::from_elem(num_insts, 0u),
+            queue: range(0, num_insts).map(|_| {
+                Thread { pc: 0, groups: repeat(None).take(ncaps * 2).collect() }
+            }).collect(),
+            sparse: repeat(0u).take(num_insts).collect(),
             size: 0,
         }
     }
@@ -518,7 +518,7 @@ pub fn is_word(c: Option<char>) -> bool {
     // Try the common ASCII case before invoking binary search.
     match c {
         '_' | '0' ... '9' | 'a' ... 'z' | 'A' ... 'Z' => true,
-        _ => PERLW.binary_search(|&(start, end)| {
+        _ => PERLW.binary_search_by(|&(start, end)| {
             if c >= start && c <= end {
                 Equal
             } else if start > c {
@@ -526,7 +526,7 @@ pub fn is_word(c: Option<char>) -> bool {
             } else {
                 Less
             }
-        }).found().is_some()
+        }).is_ok()
     }
 }