use cmp::max;
use fmt::{self, Debug};
use hash::{Hash, SipHasher, BuildHasher};
-use iter::{self, Map, FromIterator};
+use iter::FromIterator;
use mem::{self, replace};
use ops::{Deref, Index};
use rand::{self, Rng};
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
- fn first<A, B>((a, _): (A, B)) -> A { a }
- Keys { inner: self.iter().map(first) }
+ Keys { inner: self.iter() }
}
/// An iterator visiting all values in arbitrary order.
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn values<'a>(&'a self) -> Values<'a, K, V> {
- fn second<A, B>((_, b): (A, B)) -> B { b }
- Values { inner: self.iter().map(second) }
+ Values { inner: self.iter() }
}
/// An iterator visiting all key-value pairs in arbitrary order.
#[inline]
#[stable(feature = "drain", since = "1.6.0")]
pub fn drain(&mut self) -> Drain<K, V> {
- fn last_two<A, B, C>((_, b, c): (A, B, C)) -> (B, C) { (b, c) }
Drain {
- inner: self.table.drain().map(last_two),
+ inner: self.table.drain(),
}
}
/// HashMap move iterator.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct IntoIter<K, V> {
- inner: iter::Map<table::IntoIter<K, V>, fn((SafeHash, K, V)) -> (K, V)>
+ inner: table::IntoIter<K, V>
}
/// HashMap keys iterator.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Keys<'a, K: 'a, V: 'a> {
- inner: Map<Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a K>
+ inner: Iter<'a, K, V>
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
/// HashMap values iterator.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Values<'a, K: 'a, V: 'a> {
- inner: Map<Iter<'a, K, V>, fn((&'a K, &'a V)) -> &'a V>
+ inner: Iter<'a, K, V>
}
// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
/// HashMap drain iterator.
#[stable(feature = "drain", since = "1.6.0")]
pub struct Drain<'a, K: 'a, V: 'a> {
- inner: iter::Map<table::Drain<'a, K, V>, fn((SafeHash, K, V)) -> (K, V)>
+ inner: table::Drain<'a, K, V>
}
enum InternalEntry<K, V, M> {
/// let vec: Vec<(&str, isize)> = map.into_iter().collect();
/// ```
fn into_iter(self) -> IntoIter<K, V> {
- fn last_two<A, B, C>((_, b, c): (A, B, C)) -> (B, C) { (b, c) }
IntoIter {
- inner: self.table.into_iter().map(last_two)
+ inner: self.table.into_iter()
}
}
}
impl<K, V> Iterator for IntoIter<K, V> {
type Item = (K, V);
- #[inline] fn next(&mut self) -> Option<(K, V)> { self.inner.next() }
+ #[inline] fn next(&mut self) -> Option<(K, V)> { self.inner.next().map(|(_, k, v)| (k, v)) }
#[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> Iterator for Keys<'a, K, V> {
type Item = &'a K;
- #[inline] fn next(&mut self) -> Option<(&'a K)> { self.inner.next() }
+ #[inline] fn next(&mut self) -> Option<(&'a K)> { self.inner.next().map(|(k, _)| k) }
#[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> Iterator for Values<'a, K, V> {
type Item = &'a V;
- #[inline] fn next(&mut self) -> Option<(&'a V)> { self.inner.next() }
+ #[inline] fn next(&mut self) -> Option<(&'a V)> { self.inner.next().map(|(_, v)| v) }
#[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> Iterator for Drain<'a, K, V> {
type Item = (K, V);
- #[inline] fn next(&mut self) -> Option<(K, V)> { self.inner.next() }
+ #[inline] fn next(&mut self) -> Option<(K, V)> { self.inner.next().map(|(_, k, v)| (k, v)) }
#[inline] fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
use borrow::Borrow;
use fmt;
use hash::{Hash, BuildHasher};
-use iter::{Map, Chain, FromIterator};
+use iter::{Chain, FromIterator};
use ops::{BitOr, BitAnd, BitXor, Sub};
use super::Recover;
#[inline]
#[stable(feature = "drain", since = "1.6.0")]
pub fn drain(&mut self) -> Drain<T> {
- fn first<A, B>((a, _): (A, B)) -> A { a }
- Drain { iter: self.map.drain().map(first) }
+ Drain { iter: self.map.drain() }
}
/// Clears the set, removing all values.
/// HashSet move iterator
#[stable(feature = "rust1", since = "1.0.0")]
pub struct IntoIter<K> {
- iter: Map<map::IntoIter<K, ()>, fn((K, ())) -> K>
+ iter: map::IntoIter<K, ()>
}
/// HashSet drain iterator
#[stable(feature = "rust1", since = "1.0.0")]
pub struct Drain<'a, K: 'a> {
- iter: Map<map::Drain<'a, K, ()>, fn((K, ())) -> K>,
+ iter: map::Drain<'a, K, ()>,
}
/// Intersection iterator
/// }
/// ```
fn into_iter(self) -> IntoIter<T> {
- fn first<A, B>((a, _): (A, B)) -> A { a }
- IntoIter { iter: self.map.into_iter().map(first) }
+ IntoIter { iter: self.map.into_iter() }
}
}
impl<K> Iterator for IntoIter<K> {
type Item = K;
- fn next(&mut self) -> Option<K> { self.iter.next() }
+ fn next(&mut self) -> Option<K> { self.iter.next().map(|(k, _)| k) }
fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K> Iterator for Drain<'a, K> {
type Item = K;
- fn next(&mut self) -> Option<K> { self.iter.next() }
+ fn next(&mut self) -> Option<K> { self.iter.next().map(|(k, _)| k) }
fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }
}
#[stable(feature = "rust1", since = "1.0.0")]