Skip to content

Commit

Permalink
Cleanup and modernize some things in libcore::iter
Browse files Browse the repository at this point in the history
  • Loading branch information
@frewsxcv
frewsxcv committed Apr 4, 2015
1 parent f207ecb commit 263fdfe
Showing 1 changed file with 62 additions and 90 deletions.
152 changes: 62 additions & 90 deletions src/libcore/iter.rs
View file
Expand Up @@ -608,7 +608,11 @@ pub trait Iterator {
fn all<F>(&mut self, mut f: F) -> bool where
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
}

Expand All @@ -633,7 +637,11 @@ pub trait Iterator {
Self: Sized,
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
}

Expand Down Expand Up @@ -1562,13 +1570,11 @@ impl<A, B> Iterator for Zip<A, B> where A: Iterator, B: Iterator

#[inline]
fn next(&mut self) -> Option<(A::Item, B::Item)> {
match self.a.next() {
None => None,
Some(x) => match self.b.next() {
None => None,
Some(y) => Some((x, y))
}
}
self.a.next().and_then(|x| {
self.b.next().and_then(|y| {
Some((x, y))
})
})
}

#[inline]
Expand Down Expand Up @@ -1626,13 +1632,11 @@ impl<A, B> RandomAccessIterator for Zip<A, B> where

#[inline]
fn idx(&mut self, index: usize) -> Option<(A::Item, B::Item)> {
match self.a.idx(index) {
None => None,
Some(x) => match self.b.idx(index) {
None => None,
Some(y) => Some((x, y))
}
}
self.a.idx(index).and_then(|x| {
self.b.idx(index).and_then(|y| {
Some((x, y))
})
})
}
}

Expand Down Expand Up @@ -1748,9 +1752,8 @@ impl<B, I: Iterator, F> Iterator for FilterMap<I, F>
#[inline]
fn next(&mut self) -> Option<B> {
for x in self.iter.by_ref() {
match (self.f)(x) {
Some(y) => return Some(y),
None => ()
if let Some(y) = (self.f)(x) {
return Some(y);
}
}
None
Expand All @@ -1770,9 +1773,8 @@ impl<B, I: DoubleEndedIterator, F> DoubleEndedIterator for FilterMap<I, F>
#[inline]
fn next_back(&mut self) -> Option<B> {
for x in self.iter.by_ref().rev() {
match (self.f)(x) {
Some(y) => return Some(y),
None => ()
if let Some(y) = (self.f)(x) {
return Some(y);
}
}
None
Expand All @@ -1794,14 +1796,11 @@ impl<I> Iterator for Enumerate<I> where I: Iterator {

#[inline]
fn next(&mut self) -> Option<(usize, <I as Iterator>::Item)> {
match self.iter.next() {
Some(a) => {
let ret = Some((self.count, a));
self.count += 1;
ret
}
_ => None
}
self.iter.next().map(|a| {
let ret = (self.count, a);
self.count += 1;
ret
})
}

#[inline]
Expand All @@ -1816,13 +1815,10 @@ impl<I> DoubleEndedIterator for Enumerate<I> where
{
#[inline]
fn next_back(&mut self) -> Option<(usize, <I as Iterator>::Item)> {
match self.iter.next_back() {
Some(a) => {
let len = self.iter.len();
Some((self.count + len, a))
}
_ => None
}
self.iter.next_back().map(|a| {
let len = self.iter.len();
(self.count + len, a)
})
}
}

Expand All @@ -1835,10 +1831,7 @@ impl<I> RandomAccessIterator for Enumerate<I> where I: RandomAccessIterator {

#[inline]
fn idx(&mut self, index: usize) -> Option<(usize, <I as Iterator>::Item)> {
match self.iter.idx(index) {
Some(a) => Some((self.count + index, a)),
_ => None,
}
self.iter.idx(index).map(|a| (self.count + index, a))
}
}

Expand All @@ -1865,19 +1858,18 @@ impl<I: Iterator> Iterator for Peekable<I> {

#[inline]
fn next(&mut self) -> Option<I::Item> {
if self.peeked.is_some() { self.peeked.take() }
else { self.iter.next() }
match self.peeked {
Some(_) => self.peeked.take(),
None => self.iter.next(),
}
}

#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
let (lo, hi) = self.iter.size_hint();
if self.peeked.is_some() {
let lo = lo.saturating_add(1);
let hi = match hi {
Some(x) => x.checked_add(1),
None => None
};
let hi = hi.and_then(|x| x.checked_add(1));
(lo, hi)
} else {
(lo, hi)
Expand Down Expand Up @@ -1966,17 +1958,14 @@ impl<I: Iterator, P> Iterator for TakeWhile<I, P>
if self.flag {
None
} else {
match self.iter.next() {
Some(x) => {
if (self.predicate)(&x) {
Some(x)
} else {
self.flag = true;
None
}
self.iter.next().and_then(|x| {
if (self.predicate)(&x) {
Some(x)
} else {
self.flag = true;
None
}
None => None
}
})
}
}

Expand Down Expand Up @@ -2030,11 +2019,7 @@ impl<I> Iterator for Skip<I> where I: Iterator {
let (lower, upper) = self.iter.size_hint();

let lower = lower.saturating_sub(self.n);

let upper = match upper {
Some(x) => Some(x.saturating_sub(self.n)),
None => None
};
let upper = upper.map(|x| x.saturating_sub(self.n));

(lower, upper)
}
Expand Down Expand Up @@ -2316,9 +2301,8 @@ pub struct Inspect<I, F> {
impl<I: Iterator, F> Inspect<I, F> where F: FnMut(&I::Item) {
#[inline]
fn do_inspect(&mut self, elt: Option<I::Item>) -> Option<I::Item> {
match elt {
Some(ref a) => (self.f)(a),
None => ()
if let Some(ref a) = elt {
(self.f)(a);
}

elt
Expand Down Expand Up @@ -2619,17 +2603,14 @@ impl<A: Step + One + Clone> Iterator for RangeInclusive<A> {

#[inline]
fn next(&mut self) -> Option<A> {
match self.range.next() {
Some(x) => Some(x),
None => {
if !self.done && self.range.start == self.range.end {
self.done = true;
Some(self.range.end.clone())
} else {
None
}
self.range.next().or_else(|| {
if !self.done && self.range.start == self.range.end {
self.done = true;
Some(self.range.end.clone())
} else {
None
}
}
})
}

#[inline]
Expand All @@ -2639,10 +2620,7 @@ impl<A: Step + One + Clone> Iterator for RangeInclusive<A> {
(lo, hi)
} else {
let lo = lo.saturating_add(1);
let hi = match hi {
Some(x) => x.checked_add(1),
None => None
};
let hi = hi.and_then(|x| x.checked_add(1));
(lo, hi)
}
}
Expand Down Expand Up @@ -2805,10 +2783,9 @@ impl<A: Step + One + Clone> Iterator for ops::Range<A> {

#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
if let Some(hint) = Step::steps_between(&self.start, &self.end, &A::one()) {
(hint, Some(hint))
} else {
(0, None)
match Step::steps_between(&self.start, &self.end, &A::one()) {
Some(hint) => (hint, Some(hint)),
None => (0, None)
}
}
}
Expand Down Expand Up @@ -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;
if *first {
*first = false;
} else {
match val.take() {
Some(x) => {
*val = Some((*f)(x))
}
None => {}
}
} else if let Some(x) = val.take() {
*val = Some((*f)(x))
}
val.clone()
}
Expand Down

0 comments on commit 263fdfe

Please sign in to comment.