/// Return a lower bound and upper bound on the remaining length of the iterator.
///
/// The common use case for the estimate is pre-allocating space to store the results.
- fn size_hint(&self) -> (Option<uint>, Option<uint>) { (None, None) }
+ fn size_hint(&self) -> (uint, Option<uint>) { (0, None) }
}
/// Iterator adaptors provided for every `Iterator` implementation. The adaptor objects are also
}
#[inline]
- fn size_hint(&self) -> (Option<uint>, Option<uint>) {
+ fn size_hint(&self) -> (uint, Option<uint>) {
let (a_lower, a_upper) = self.a.size_hint();
let (b_lower, b_upper) = self.b.size_hint();
- let lower = match (a_lower, b_lower) {
- (Some(x), Some(y)) => Some(x + y),
- (Some(x), None) => Some(x),
- (None, Some(y)) => Some(y),
- (None, None) => None
- };
+ let lower = a_lower + b_lower;
let upper = match (a_upper, b_upper) {
(Some(x), Some(y)) => Some(x + y),
}
#[inline]
- fn size_hint(&self) -> (Option<uint>, Option<uint>) {
+ fn size_hint(&self) -> (uint, Option<uint>) {
self.iter.size_hint()
}
}
}
#[inline]
- fn size_hint(&self) -> (Option<uint>, Option<uint>) {
+ fn size_hint(&self) -> (uint, Option<uint>) {
let (_, upper) = self.iter.size_hint();
- (None, upper) // can't know a lower bound, due to the predicate
+ (0, upper) // can't know a lower bound, due to the predicate
}
}
}
#[inline]
- fn size_hint(&self) -> (Option<uint>, Option<uint>) {
+ fn size_hint(&self) -> (uint, Option<uint>) {
let (_, upper) = self.iter.size_hint();
- (None, upper) // can't know a lower bound, due to the predicate
+ (0, upper) // can't know a lower bound, due to the predicate
}
}
}
#[inline]
- fn size_hint(&self) -> (Option<uint>, Option<uint>) {
+ fn size_hint(&self) -> (uint, Option<uint>) {
let diff = if $step > 0 {
(self.end as uint) - (self.ptr as uint)
} else {
(self.ptr as uint) - (self.end as uint)
};
- let exact = Some(diff / size_of::<$elem>());
- (exact, exact)
+ let exact = diff / size_of::<$elem>();
+ (exact, Some(exact))
}
}
}
impl<A, T: Iterator<A>> FromIterator<A, T> for ~[A] {
pub fn from_iterator(iterator: &mut T) -> ~[A] {
let (lower, _) = iterator.size_hint();
- let mut xs = with_capacity(lower.get_or_zero());
+ let mut xs = with_capacity(lower);
for iterator.advance |x| {
xs.push(x);
}
use iterator::*;
let xs = [1, 2, 5, 10, 11];
let mut it = xs.iter();
- assert_eq!(it.size_hint(), (Some(5), Some(5)));
+ assert_eq!(it.size_hint(), (5, Some(5)));
assert_eq!(it.next().unwrap(), &1);
- assert_eq!(it.size_hint(), (Some(4), Some(4)));
+ assert_eq!(it.size_hint(), (4, Some(4)));
assert_eq!(it.next().unwrap(), &2);
- assert_eq!(it.size_hint(), (Some(3), Some(3)));
+ assert_eq!(it.size_hint(), (3, Some(3)));
assert_eq!(it.next().unwrap(), &5);
- assert_eq!(it.size_hint(), (Some(2), Some(2)));
+ assert_eq!(it.size_hint(), (2, Some(2)));
assert_eq!(it.next().unwrap(), &10);
- assert_eq!(it.size_hint(), (Some(1), Some(1)));
+ assert_eq!(it.size_hint(), (1, Some(1)));
assert_eq!(it.next().unwrap(), &11);
- assert_eq!(it.size_hint(), (Some(0), Some(0)));
+ assert_eq!(it.size_hint(), (0, Some(0)));
assert!(it.next().is_none());
}
fn test_iter_size_hints() {
use iterator::*;
let mut xs = [1, 2, 5, 10, 11];
- assert_eq!(xs.iter().size_hint(), (Some(5), Some(5)));
- assert_eq!(xs.rev_iter().size_hint(), (Some(5), Some(5)));
- assert_eq!(xs.mut_iter().size_hint(), (Some(5), Some(5)));
- assert_eq!(xs.mut_rev_iter().size_hint(), (Some(5), Some(5)));
+ assert_eq!(xs.iter().size_hint(), (5, Some(5)));
+ assert_eq!(xs.rev_iter().size_hint(), (5, Some(5)));
+ assert_eq!(xs.mut_iter().size_hint(), (5, Some(5)));
+ assert_eq!(xs.mut_rev_iter().size_hint(), (5, Some(5)));
}
#[test]