rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup and modernize some things in libcore::iter

Browse Source
This commit is contained in:
Corey Farwell
2015-04-03 20:45:43 -07:00
parent f207ecbe02
commit 263fdfeea8
1 changed files with 62 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files

152
src/libcore/iter.rs
View File

@@ -608,7 +608,11 @@ pub trait Iterator {
fn all<F>(&mut self, mut f: F) -> bool where fn all<F>(&mut self, mut f: F) -> bool where
Self: Sized, F: FnMut(Self::Item) -> bool Self: Sized, F: FnMut(Self::Item) -> bool
{ {
for x in self.by_ref() { if !f(x) { return false; } } for x in self.by_ref() {
if !f(x) {
return false;
}
}
true true
} }
@@ -633,7 +637,11 @@ pub trait Iterator {
Self: Sized, Self: Sized,
F: FnMut(Self::Item) -> bool F: FnMut(Self::Item) -> bool
{ {
for x in self.by_ref() { if f(x) { return true; } } for x in self.by_ref() {
if f(x) {
return true;
}
}
false false
} }
@@ -1562,13 +1570,11 @@ impl<A, B> Iterator for Zip<A, B> where A: Iterator, B: Iterator
#[inline] #[inline]
fn next(&mut self) -> Option<(A::Item, B::Item)> { fn next(&mut self) -> Option<(A::Item, B::Item)> {
match self.a.next() { self.a.next().and_then(|x| {
None => None, self.b.next().and_then(|y| {
Some(x) => match self.b.next() { Some((x, y))
None => None, })
Some(y) => Some((x, y)) })
}
}
} }
#[inline] #[inline]
@@ -1626,13 +1632,11 @@ impl<A, B> RandomAccessIterator for Zip<A, B> where
#[inline] #[inline]
fn idx(&mut self, index: usize) -> Option<(A::Item, B::Item)> { fn idx(&mut self, index: usize) -> Option<(A::Item, B::Item)> {
match self.a.idx(index) { self.a.idx(index).and_then(|x| {
None => None, self.b.idx(index).and_then(|y| {
Some(x) => match self.b.idx(index) { Some((x, y))
None => None, })
Some(y) => Some((x, y)) })
}
}
} }
} }
@@ -1748,9 +1752,8 @@ impl<B, I: Iterator, F> Iterator for FilterMap<I, F>
#[inline] #[inline]
fn next(&mut self) -> Option<B> { fn next(&mut self) -> Option<B> {
for x in self.iter.by_ref() { for x in self.iter.by_ref() {
match (self.f)(x) { if let Some(y) = (self.f)(x) {
Some(y) => return Some(y), return Some(y);
None => ()
} }
} }
None None
@@ -1770,9 +1773,8 @@ impl<B, I: DoubleEndedIterator, F> DoubleEndedIterator for FilterMap<I, F>
#[inline] #[inline]
fn next_back(&mut self) -> Option<B> { fn next_back(&mut self) -> Option<B> {
for x in self.iter.by_ref().rev() { for x in self.iter.by_ref().rev() {
match (self.f)(x) { if let Some(y) = (self.f)(x) {
Some(y) => return Some(y), return Some(y);
None => ()
} }
} }
None None
@@ -1794,14 +1796,11 @@ impl<I> Iterator for Enumerate<I> where I: Iterator {
#[inline] #[inline]
fn next(&mut self) -> Option<(usize, <I as Iterator>::Item)> { fn next(&mut self) -> Option<(usize, <I as Iterator>::Item)> {
match self.iter.next() { self.iter.next().map(|a| {
Some(a) => { let ret = (self.count, a);
let ret = Some((self.count, a)); self.count += 1;
self.count += 1; ret
ret })
}
_ => None
}
} }
#[inline] #[inline]
@@ -1816,13 +1815,10 @@ impl<I> DoubleEndedIterator for Enumerate<I> where
{ {
#[inline] #[inline]
fn next_back(&mut self) -> Option<(usize, <I as Iterator>::Item)> { fn next_back(&mut self) -> Option<(usize, <I as Iterator>::Item)> {
match self.iter.next_back() { self.iter.next_back().map(|a| {
Some(a) => { let len = self.iter.len();
let len = self.iter.len(); (self.count + len, a)
Some((self.count + len, a)) })
}
_ => None
}
} }
} }
@@ -1835,10 +1831,7 @@ impl<I> RandomAccessIterator for Enumerate<I> where I: RandomAccessIterator {
#[inline] #[inline]
fn idx(&mut self, index: usize) -> Option<(usize, <I as Iterator>::Item)> { fn idx(&mut self, index: usize) -> Option<(usize, <I as Iterator>::Item)> {
match self.iter.idx(index) { self.iter.idx(index).map(|a| (self.count + index, a))
Some(a) => Some((self.count + index, a)),
_ => None,
}
} }
} }
@@ -1865,8 +1858,10 @@ impl<I: Iterator> Iterator for Peekable<I> {
#[inline] #[inline]
fn next(&mut self) -> Option<I::Item> { fn next(&mut self) -> Option<I::Item> {
if self.peeked.is_some() { self.peeked.take() } match self.peeked {
else { self.iter.next() } Some(_) => self.peeked.take(),
None => self.iter.next(),
}
} }
#[inline] #[inline]
@@ -1874,10 +1869,7 @@ impl<I: Iterator> Iterator for Peekable<I> {
let (lo, hi) = self.iter.size_hint(); let (lo, hi) = self.iter.size_hint();
if self.peeked.is_some() { if self.peeked.is_some() {
let lo = lo.saturating_add(1); let lo = lo.saturating_add(1);
let hi = match hi { let hi = hi.and_then(|x| x.checked_add(1));
Some(x) => x.checked_add(1),
None => None
};
(lo, hi) (lo, hi)
} else { } else {
(lo, hi) (lo, hi)
@@ -1966,17 +1958,14 @@ impl<I: Iterator, P> Iterator for TakeWhile<I, P>
if self.flag { if self.flag {
None None
} else { } else {
match self.iter.next() { self.iter.next().and_then(|x| {
Some(x) => { if (self.predicate)(&x) {
if (self.predicate)(&x) { Some(x)
Some(x) } else {
} else { self.flag = true;
self.flag = true; None
None
}
} }
None => None })
}
} }
} }
@@ -2030,11 +2019,7 @@ impl<I> Iterator for Skip<I> where I: Iterator {
let (lower, upper) = self.iter.size_hint(); let (lower, upper) = self.iter.size_hint();
let lower = lower.saturating_sub(self.n); let lower = lower.saturating_sub(self.n);
let upper = upper.map(|x| x.saturating_sub(self.n));
let upper = match upper {
Some(x) => Some(x.saturating_sub(self.n)),
None => None
};
(lower, upper) (lower, upper)
} }
@@ -2316,9 +2301,8 @@ pub struct Inspect<I, F> {
impl<I: Iterator, F> Inspect<I, F> where F: FnMut(&I::Item) { impl<I: Iterator, F> Inspect<I, F> where F: FnMut(&I::Item) {
#[inline] #[inline]
fn do_inspect(&mut self, elt: Option<I::Item>) -> Option<I::Item> { fn do_inspect(&mut self, elt: Option<I::Item>) -> Option<I::Item> {
match elt { if let Some(ref a) = elt {
Some(ref a) => (self.f)(a), (self.f)(a);
None => ()
} }
elt elt
@@ -2619,17 +2603,14 @@ impl<A: Step + One + Clone> Iterator for RangeInclusive<A> {
#[inline] #[inline]
fn next(&mut self) -> Option<A> { fn next(&mut self) -> Option<A> {
match self.range.next() { self.range.next().or_else(|| {
Some(x) => Some(x), if !self.done && self.range.start == self.range.end {
None => { self.done = true;
if !self.done && self.range.start == self.range.end { Some(self.range.end.clone())
self.done = true; } else {
Some(self.range.end.clone()) None
} else {
None
}
} }
} })
} }
#[inline] #[inline]
@@ -2639,10 +2620,7 @@ impl<A: Step + One + Clone> Iterator for RangeInclusive<A> {
(lo, hi) (lo, hi)
} else { } else {
let lo = lo.saturating_add(1); let lo = lo.saturating_add(1);
let hi = match hi { let hi = hi.and_then(|x| x.checked_add(1));
Some(x) => x.checked_add(1),
None => None
};
(lo, hi) (lo, hi)
} }
} }
@@ -2805,10 +2783,9 @@ impl<A: Step + One + Clone> Iterator for ops::Range<A> {
#[inline] #[inline]
fn size_hint(&self) -> (usize, Option<usize>) { fn size_hint(&self) -> (usize, Option<usize>) {
if let Some(hint) = Step::steps_between(&self.start, &self.end, &A::one()) { match Step::steps_between(&self.start, &self.end, &A::one()) {
(hint, Some(hint)) Some(hint) => (hint, Some(hint)),
} else { None => (0, None)
(0, None)
} }
} }
} }
@@ -2899,13 +2876,8 @@ pub fn iterate<T, F>(seed: T, f: F) -> Iterate<T, F> where
let &mut (ref mut f, ref mut val, ref mut first) = st; let &mut (ref mut f, ref mut val, ref mut first) = st;
if *first { if *first {
*first = false; *first = false;
} else { } else if let Some(x) = val.take() {
match val.take() { *val = Some((*f)(x))
Some(x) => {
*val = Some((*f)(x))
}
None => {}
}
} }
val.clone() val.clone()
} }