From f53c212d46dcb2d38c151707bed8fd6ba7f61b92 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Fri, 25 Aug 2017 15:44:25 -0700 Subject: [PATCH] almost --- src/hash/map.rs | 206 ++++++++++-------------------------------------- src/hash/set.rs | 131 +++++++----------------------- src/lib.rs | 8 +- 3 files changed, 73 insertions(+), 272 deletions(-) diff --git a/src/hash/map.rs b/src/hash/map.rs index 16b0c709986..c785dc6af5d 100644 --- a/src/hash/map.rs +++ b/src/hash/map.rs @@ -387,7 +387,6 @@ const DISPLACEMENT_THRESHOLD: usize = 128; /// ``` #[derive(Clone)] -#[stable(feature = "rust1", since = "1.0.0")] pub struct HashMap { // All hashes are keyed on these values, to prevent hash collision attacks. hash_builder: S, @@ -595,8 +594,7 @@ impl HashMap { /// let mut map: HashMap<&str, isize> = HashMap::new(); /// ``` #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - pub fn new() -> HashMap { + pub fn new() -> HashMap { Default::default() } @@ -612,8 +610,7 @@ impl HashMap { /// let mut map: HashMap<&str, isize> = HashMap::with_capacity(10); /// ``` #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - pub fn with_capacity(capacity: usize) -> HashMap { + pub fn with_capacity(capacity: usize) -> HashMap { HashMap::with_capacity_and_hasher(capacity, Default::default()) } } @@ -643,8 +640,7 @@ impl HashMap /// map.insert(1, 2); /// ``` #[inline] - #[stable(feature = "hashmap_build_hasher", since = "1.7.0")] - pub fn with_hasher(hash_builder: S) -> HashMap { + pub fn with_hasher(hash_builder: S) -> HashMap { HashMap { hash_builder, resize_policy: DefaultResizePolicy::new(), @@ -674,8 +670,7 @@ impl HashMap /// map.insert(1, 2); /// ``` #[inline] - #[stable(feature = "hashmap_build_hasher", since = "1.7.0")] - pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> HashMap { + pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> HashMap { let resize_policy = DefaultResizePolicy::new(); let raw_cap = resize_policy.raw_capacity(capacity); HashMap { @@ -688,8 +683,7 @@ impl HashMap /// Returns a reference to the map's [`BuildHasher`]. /// /// [`BuildHasher`]: ../../std/hash/trait.BuildHasher.html - #[stable(feature = "hashmap_public_hasher", since = "1.9.0")] - pub fn hasher(&self) -> &S { + pub fn hasher(&self) -> &S { &self.hash_builder } @@ -706,8 +700,7 @@ impl HashMap /// assert!(map.capacity() >= 100); /// ``` #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - pub fn capacity(&self) -> usize { + pub fn capacity(&self) -> usize { self.resize_policy.capacity(self.raw_capacity()) } @@ -734,8 +727,7 @@ impl HashMap /// let mut map: HashMap<&str, isize> = HashMap::new(); /// map.reserve(10); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve(&mut self, additional: usize) { + pub fn reserve(&mut self, additional: usize) { let remaining = self.capacity() - self.len(); // this can't overflow if remaining < additional { let min_cap = self.len().checked_add(additional).expect("reserve overflow"); @@ -817,8 +809,7 @@ impl HashMap /// map.shrink_to_fit(); /// assert!(map.capacity() >= 2); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn shrink_to_fit(&mut self) { + pub fn shrink_to_fit(&mut self) { let new_raw_cap = self.resize_policy.raw_capacity(self.len()); if self.raw_capacity() != new_raw_cap { let old_table = replace(&mut self.table, RawTable::new(new_raw_cap)); @@ -868,8 +859,7 @@ impl HashMap /// println!("{}", key); /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn keys(&self) -> Keys { + pub fn keys(&self) -> Keys { Keys { inner: self.iter() } } @@ -890,8 +880,7 @@ impl HashMap /// println!("{}", val); /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn values(&self) -> Values { + pub fn values(&self) -> Values { Values { inner: self.iter() } } @@ -917,8 +906,7 @@ impl HashMap /// println!("{}", val); /// } /// ``` - #[stable(feature = "map_values_mut", since = "1.10.0")] - pub fn values_mut(&mut self) -> ValuesMut { + pub fn values_mut(&mut self) -> ValuesMut { ValuesMut { inner: self.iter_mut() } } @@ -939,8 +927,7 @@ impl HashMap /// println!("key: {} val: {}", key, val); /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn iter(&self) -> Iter { + pub fn iter(&self) -> Iter { Iter { inner: self.table.iter() } } @@ -967,8 +954,7 @@ impl HashMap /// println!("key: {} val: {}", key, val); /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn iter_mut(&mut self) -> IterMut { + pub fn iter_mut(&mut self) -> IterMut { IterMut { inner: self.table.iter_mut() } } @@ -991,8 +977,7 @@ impl HashMap /// assert_eq!(letters[&'u'], 1); /// assert_eq!(letters.get(&'y'), None); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn entry(&mut self, key: K) -> Entry { + pub fn entry(&mut self, key: K) -> Entry { // Gotta resize now. self.reserve(1); let hash = self.make_hash(&key); @@ -1012,8 +997,7 @@ impl HashMap /// a.insert(1, "a"); /// assert_eq!(a.len(), 1); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> usize { + pub fn len(&self) -> usize { self.table.size() } @@ -1030,8 +1014,7 @@ impl HashMap /// assert!(!a.is_empty()); /// ``` #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - pub fn is_empty(&self) -> bool { + pub fn is_empty(&self) -> bool { self.len() == 0 } @@ -1055,8 +1038,7 @@ impl HashMap /// assert!(a.is_empty()); /// ``` #[inline] - #[stable(feature = "drain", since = "1.6.0")] - pub fn drain(&mut self) -> Drain { + pub fn drain(&mut self) -> Drain { Drain { inner: self.table.drain() } } @@ -1073,8 +1055,7 @@ impl HashMap /// a.clear(); /// assert!(a.is_empty()); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - #[inline] + #[inline] pub fn clear(&mut self) { self.drain(); } @@ -1098,8 +1079,7 @@ impl HashMap /// assert_eq!(map.get(&1), Some(&"a")); /// assert_eq!(map.get(&2), None); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn get(&self, k: &Q) -> Option<&V> + pub fn get(&self, k: &Q) -> Option<&V> where K: Borrow, Q: Hash + Eq { @@ -1125,8 +1105,7 @@ impl HashMap /// assert_eq!(map.contains_key(&1), true); /// assert_eq!(map.contains_key(&2), false); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn contains_key(&self, k: &Q) -> bool + pub fn contains_key(&self, k: &Q) -> bool where K: Borrow, Q: Hash + Eq { @@ -1154,8 +1133,7 @@ impl HashMap /// } /// assert_eq!(map[&1], "b"); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn get_mut(&mut self, k: &Q) -> Option<&mut V> + pub fn get_mut(&mut self, k: &Q) -> Option<&mut V> where K: Borrow, Q: Hash + Eq { @@ -1187,8 +1165,7 @@ impl HashMap /// assert_eq!(map.insert(37, "c"), Some("b")); /// assert_eq!(map[&37], "c"); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn insert(&mut self, k: K, v: V) -> Option { + pub fn insert(&mut self, k: K, v: V) -> Option { let hash = self.make_hash(&k); self.reserve(1); self.insert_hashed_nocheck(hash, k, v) @@ -1214,8 +1191,7 @@ impl HashMap /// assert_eq!(map.remove(&1), Some("a")); /// assert_eq!(map.remove(&1), None); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn remove(&mut self, k: &Q) -> Option + pub fn remove(&mut self, k: &Q) -> Option where K: Borrow, Q: Hash + Eq { @@ -1239,8 +1215,7 @@ impl HashMap /// map.retain(|&k, _| k % 2 == 0); /// assert_eq!(map.len(), 4); /// ``` - #[stable(feature = "retain_hash_collection", since = "1.18.0")] - pub fn retain(&mut self, mut f: F) + pub fn retain(&mut self, mut f: F) where F: FnMut(&K, &mut V) -> bool { if self.table.size() == 0 { @@ -1276,7 +1251,6 @@ impl HashMap } } -#[stable(feature = "rust1", since = "1.0.0")] impl PartialEq for HashMap where K: Eq + Hash, V: PartialEq, @@ -1291,7 +1265,6 @@ impl PartialEq for HashMap } } -#[stable(feature = "rust1", since = "1.0.0")] impl Eq for HashMap where K: Eq + Hash, V: Eq, @@ -1299,7 +1272,6 @@ impl Eq for HashMap { } -#[stable(feature = "rust1", since = "1.0.0")] impl Debug for HashMap where K: Eq + Hash + Debug, V: Debug, @@ -1310,7 +1282,6 @@ impl Debug for HashMap } } -#[stable(feature = "rust1", since = "1.0.0")] impl Default for HashMap where K: Eq + Hash, S: BuildHasher + Default @@ -1321,7 +1292,6 @@ impl Default for HashMap } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, Q: ?Sized, V, S> Index<&'a Q> for HashMap where K: Eq + Hash + Borrow, Q: Eq + Hash, @@ -1342,20 +1312,17 @@ impl<'a, K, Q: ?Sized, V, S> Index<&'a Q> for HashMap /// /// [`iter`]: struct.HashMap.html#method.iter /// [`HashMap`]: struct.HashMap.html -#[stable(feature = "rust1", since = "1.0.0")] pub struct Iter<'a, K: 'a, V: 'a> { inner: table::Iter<'a, K, V>, } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> Clone for Iter<'a, K, V> { fn clone(&self) -> Iter<'a, K, V> { Iter { inner: self.inner.clone() } } } -#[stable(feature = "std_debug", since = "1.16.0")] impl<'a, K: Debug, V: Debug> fmt::Debug for Iter<'a, K, V> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_list() @@ -1371,7 +1338,6 @@ impl<'a, K: Debug, V: Debug> fmt::Debug for Iter<'a, K, V> { /// /// [`iter_mut`]: struct.HashMap.html#method.iter_mut /// [`HashMap`]: struct.HashMap.html -#[stable(feature = "rust1", since = "1.0.0")] pub struct IterMut<'a, K: 'a, V: 'a> { inner: table::IterMut<'a, K, V>, } @@ -1383,7 +1349,6 @@ pub struct IterMut<'a, K: 'a, V: 'a> { /// /// [`into_iter`]: struct.HashMap.html#method.into_iter /// [`HashMap`]: struct.HashMap.html -#[stable(feature = "rust1", since = "1.0.0")] pub struct IntoIter { pub(super) inner: table::IntoIter, } @@ -1395,20 +1360,17 @@ pub struct IntoIter { /// /// [`keys`]: struct.HashMap.html#method.keys /// [`HashMap`]: struct.HashMap.html -#[stable(feature = "rust1", since = "1.0.0")] pub struct Keys<'a, K: 'a, V: 'a> { inner: Iter<'a, K, V>, } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> Clone for Keys<'a, K, V> { fn clone(&self) -> Keys<'a, K, V> { Keys { inner: self.inner.clone() } } } -#[stable(feature = "std_debug", since = "1.16.0")] impl<'a, K: Debug, V> fmt::Debug for Keys<'a, K, V> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_list() @@ -1424,20 +1386,17 @@ impl<'a, K: Debug, V> fmt::Debug for Keys<'a, K, V> { /// /// [`values`]: struct.HashMap.html#method.values /// [`HashMap`]: struct.HashMap.html -#[stable(feature = "rust1", since = "1.0.0")] pub struct Values<'a, K: 'a, V: 'a> { inner: Iter<'a, K, V>, } // FIXME(#19839) Remove in favor of `#[derive(Clone)]` -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> Clone for Values<'a, K, V> { fn clone(&self) -> Values<'a, K, V> { Values { inner: self.inner.clone() } } } -#[stable(feature = "std_debug", since = "1.16.0")] impl<'a, K, V: Debug> fmt::Debug for Values<'a, K, V> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_list() @@ -1453,7 +1412,6 @@ impl<'a, K, V: Debug> fmt::Debug for Values<'a, K, V> { /// /// [`drain`]: struct.HashMap.html#method.drain /// [`HashMap`]: struct.HashMap.html -#[stable(feature = "drain", since = "1.6.0")] pub struct Drain<'a, K: 'a, V: 'a> { pub(super) inner: table::Drain<'a, K, V>, } @@ -1465,7 +1423,6 @@ pub struct Drain<'a, K: 'a, V: 'a> { /// /// [`values_mut`]: struct.HashMap.html#method.values_mut /// [`HashMap`]: struct.HashMap.html -#[stable(feature = "map_values_mut", since = "1.10.0")] pub struct ValuesMut<'a, K: 'a, V: 'a> { inner: IterMut<'a, K, V>, } @@ -1517,20 +1474,14 @@ impl<'a, K, V> InternalEntry> { /// /// [`HashMap`]: struct.HashMap.html /// [`entry`]: struct.HashMap.html#method.entry -#[stable(feature = "rust1", since = "1.0.0")] pub enum Entry<'a, K: 'a, V: 'a> { /// An occupied entry. - #[stable(feature = "rust1", since = "1.0.0")] - Occupied(#[stable(feature = "rust1", since = "1.0.0")] - OccupiedEntry<'a, K, V>), + Occupied( OccupiedEntry<'a, K, V>), /// A vacant entry. - #[stable(feature = "rust1", since = "1.0.0")] - Vacant(#[stable(feature = "rust1", since = "1.0.0")] - VacantEntry<'a, K, V>), + Vacant( VacantEntry<'a, K, V>), } -#[stable(feature= "debug_hash_map", since = "1.12.0")] impl<'a, K: 'a + Debug, V: 'a + Debug> Debug for Entry<'a, K, V> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { @@ -1552,13 +1503,11 @@ impl<'a, K: 'a + Debug, V: 'a + Debug> Debug for Entry<'a, K, V> { /// It is part of the [`Entry`] enum. /// /// [`Entry`]: enum.Entry.html -#[stable(feature = "rust1", since = "1.0.0")] pub struct OccupiedEntry<'a, K: 'a, V: 'a> { key: Option, elem: FullBucket>, } -#[stable(feature= "debug_hash_map", since = "1.12.0")] impl<'a, K: 'a + Debug, V: 'a + Debug> Debug for OccupiedEntry<'a, K, V> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_struct("OccupiedEntry") @@ -1572,14 +1521,12 @@ impl<'a, K: 'a + Debug, V: 'a + Debug> Debug for OccupiedEntry<'a, K, V> { /// It is part of the [`Entry`] enum. /// /// [`Entry`]: enum.Entry.html -#[stable(feature = "rust1", since = "1.0.0")] pub struct VacantEntry<'a, K: 'a, V: 'a> { hash: SafeHash, key: K, elem: VacantEntryState>, } -#[stable(feature= "debug_hash_map", since = "1.12.0")] impl<'a, K: 'a + Debug, V: 'a> Debug for VacantEntry<'a, K, V> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_tuple("VacantEntry") @@ -1597,7 +1544,6 @@ enum VacantEntryState { NoElem(EmptyBucket, usize), } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V, S> IntoIterator for &'a HashMap where K: Eq + Hash, S: BuildHasher @@ -1610,7 +1556,6 @@ impl<'a, K, V, S> IntoIterator for &'a HashMap } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V, S> IntoIterator for &'a mut HashMap where K: Eq + Hash, S: BuildHasher @@ -1623,7 +1568,6 @@ impl<'a, K, V, S> IntoIterator for &'a mut HashMap } } -#[stable(feature = "rust1", since = "1.0.0")] impl IntoIterator for HashMap where K: Eq + Hash, S: BuildHasher @@ -1653,7 +1597,6 @@ impl IntoIterator for HashMap } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> Iterator for Iter<'a, K, V> { type Item = (&'a K, &'a V); @@ -1666,7 +1609,6 @@ impl<'a, K, V> Iterator for Iter<'a, K, V> { self.inner.size_hint() } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> { #[inline] fn len(&self) -> usize { @@ -1674,10 +1616,8 @@ impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> { } } -#[unstable(feature = "fused", issue = "35602")] impl<'a, K, V> FusedIterator for Iter<'a, K, V> {} -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> Iterator for IterMut<'a, K, V> { type Item = (&'a K, &'a mut V); @@ -1690,17 +1630,14 @@ impl<'a, K, V> Iterator for IterMut<'a, K, V> { self.inner.size_hint() } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> ExactSizeIterator for IterMut<'a, K, V> { #[inline] fn len(&self) -> usize { self.inner.len() } } -#[unstable(feature = "fused", issue = "35602")] impl<'a, K, V> FusedIterator for IterMut<'a, K, V> {} -#[stable(feature = "std_debug", since = "1.16.0")] impl<'a, K, V> fmt::Debug for IterMut<'a, K, V> where K: fmt::Debug, V: fmt::Debug, @@ -1712,7 +1649,6 @@ impl<'a, K, V> fmt::Debug for IterMut<'a, K, V> } } -#[stable(feature = "rust1", since = "1.0.0")] impl Iterator for IntoIter { type Item = (K, V); @@ -1725,17 +1661,14 @@ impl Iterator for IntoIter { self.inner.size_hint() } } -#[stable(feature = "rust1", since = "1.0.0")] impl ExactSizeIterator for IntoIter { #[inline] fn len(&self) -> usize { self.inner.len() } } -#[unstable(feature = "fused", issue = "35602")] impl FusedIterator for IntoIter {} -#[stable(feature = "std_debug", since = "1.16.0")] impl fmt::Debug for IntoIter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_list() @@ -1744,7 +1677,6 @@ impl fmt::Debug for IntoIter { } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> Iterator for Keys<'a, K, V> { type Item = &'a K; @@ -1757,17 +1689,14 @@ impl<'a, K, V> Iterator for Keys<'a, K, V> { self.inner.size_hint() } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> { #[inline] fn len(&self) -> usize { self.inner.len() } } -#[unstable(feature = "fused", issue = "35602")] impl<'a, K, V> FusedIterator for Keys<'a, K, V> {} -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> Iterator for Values<'a, K, V> { type Item = &'a V; @@ -1780,17 +1709,14 @@ impl<'a, K, V> Iterator for Values<'a, K, V> { self.inner.size_hint() } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> { #[inline] fn len(&self) -> usize { self.inner.len() } } -#[unstable(feature = "fused", issue = "35602")] impl<'a, K, V> FusedIterator for Values<'a, K, V> {} -#[stable(feature = "map_values_mut", since = "1.10.0")] impl<'a, K, V> Iterator for ValuesMut<'a, K, V> { type Item = &'a mut V; @@ -1803,17 +1729,14 @@ impl<'a, K, V> Iterator for ValuesMut<'a, K, V> { self.inner.size_hint() } } -#[stable(feature = "map_values_mut", since = "1.10.0")] impl<'a, K, V> ExactSizeIterator for ValuesMut<'a, K, V> { #[inline] fn len(&self) -> usize { self.inner.len() } } -#[unstable(feature = "fused", issue = "35602")] impl<'a, K, V> FusedIterator for ValuesMut<'a, K, V> {} -#[stable(feature = "std_debug", since = "1.16.0")] impl<'a, K, V> fmt::Debug for ValuesMut<'a, K, V> where K: fmt::Debug, V: fmt::Debug, @@ -1825,7 +1748,6 @@ impl<'a, K, V> fmt::Debug for ValuesMut<'a, K, V> } } -#[stable(feature = "drain", since = "1.6.0")] impl<'a, K, V> Iterator for Drain<'a, K, V> { type Item = (K, V); @@ -1838,17 +1760,14 @@ impl<'a, K, V> Iterator for Drain<'a, K, V> { self.inner.size_hint() } } -#[stable(feature = "drain", since = "1.6.0")] impl<'a, K, V> ExactSizeIterator for Drain<'a, K, V> { #[inline] fn len(&self) -> usize { self.inner.len() } } -#[unstable(feature = "fused", issue = "35602")] impl<'a, K, V> FusedIterator for Drain<'a, K, V> {} -#[stable(feature = "std_debug", since = "1.16.0")] impl<'a, K, V> fmt::Debug for Drain<'a, K, V> where K: fmt::Debug, V: fmt::Debug, @@ -1864,16 +1783,10 @@ impl<'a, K, V> fmt::Debug for Drain<'a, K, V> /// /// See [`HashMap::entry`](struct.HashMap.html#method.entry) for details. #[must_use = "places do nothing unless written to with `<-` syntax"] -#[unstable(feature = "collection_placement", - reason = "struct name and placement protocol is subject to change", - issue = "30172")] pub struct EntryPlace<'a, K: 'a, V: 'a> { bucket: FullBucketMut<'a, K, V>, } -#[unstable(feature = "collection_placement", - reason = "struct name and placement protocol is subject to change", - issue = "30172")] impl<'a, K: 'a + Debug, V: 'a + Debug> Debug for EntryPlace<'a, K, V> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_struct("EntryPlace") @@ -1883,9 +1796,6 @@ impl<'a, K: 'a + Debug, V: 'a + Debug> Debug for EntryPlace<'a, K, V> { } } -#[unstable(feature = "collection_placement", - reason = "struct name and placement protocol is subject to change", - issue = "30172")] impl<'a, K, V> Drop for EntryPlace<'a, K, V> { fn drop(&mut self) { // Inplacement insertion failed. Only key need to drop. @@ -1894,9 +1804,6 @@ impl<'a, K, V> Drop for EntryPlace<'a, K, V> { } } -#[unstable(feature = "collection_placement", - reason = "placement protocol is subject to change", - issue = "30172")] impl<'a, K, V> Placer for Entry<'a, K, V> { type Place = EntryPlace<'a, K, V>; @@ -1914,18 +1821,12 @@ impl<'a, K, V> Placer for Entry<'a, K, V> { } } -#[unstable(feature = "collection_placement", - reason = "placement protocol is subject to change", - issue = "30172")] impl<'a, K, V> Place for EntryPlace<'a, K, V> { fn pointer(&mut self) -> *mut V { self.bucket.read_mut().1 } } -#[unstable(feature = "collection_placement", - reason = "placement protocol is subject to change", - issue = "30172")] impl<'a, K, V> InPlace for EntryPlace<'a, K, V> { type Owner = (); @@ -1935,8 +1836,7 @@ impl<'a, K, V> InPlace for EntryPlace<'a, K, V> { } impl<'a, K, V> Entry<'a, K, V> { - #[stable(feature = "rust1", since = "1.0.0")] - /// Ensures a value is in the entry by inserting the default if empty, and returns + /// Ensures a value is in the entry by inserting the default if empty, and returns /// a mutable reference to the value in the entry. /// /// # Examples @@ -1959,8 +1859,7 @@ impl<'a, K, V> Entry<'a, K, V> { } } - #[stable(feature = "rust1", since = "1.0.0")] - /// Ensures a value is in the entry by inserting the result of the default function if empty, + /// Ensures a value is in the entry by inserting the result of the default function if empty, /// and returns a mutable reference to the value in the entry. /// /// # Examples @@ -1992,8 +1891,7 @@ impl<'a, K, V> Entry<'a, K, V> { /// let mut map: HashMap<&str, u32> = HashMap::new(); /// assert_eq!(map.entry("poneyland").key(), &"poneyland"); /// ``` - #[stable(feature = "map_entry_keys", since = "1.10.0")] - pub fn key(&self) -> &K { + pub fn key(&self) -> &K { match *self { Occupied(ref entry) => entry.key(), Vacant(ref entry) => entry.key(), @@ -2013,8 +1911,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> { /// map.entry("poneyland").or_insert(12); /// assert_eq!(map.entry("poneyland").key(), &"poneyland"); /// ``` - #[stable(feature = "map_entry_keys", since = "1.10.0")] - pub fn key(&self) -> &K { + pub fn key(&self) -> &K { self.elem.read().0 } @@ -2036,8 +1933,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> { /// /// assert_eq!(map.contains_key("poneyland"), false); /// ``` - #[stable(feature = "map_entry_recover_keys2", since = "1.12.0")] - pub fn remove_entry(self) -> (K, V) { + pub fn remove_entry(self) -> (K, V) { let (k, v, _) = pop_internal(self.elem); (k, v) } @@ -2057,8 +1953,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> { /// assert_eq!(o.get(), &12); /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn get(&self) -> &V { + pub fn get(&self) -> &V { self.elem.read().1 } @@ -2080,8 +1975,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> { /// /// assert_eq!(map["poneyland"], 22); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn get_mut(&mut self) -> &mut V { + pub fn get_mut(&mut self) -> &mut V { self.elem.read_mut().1 } @@ -2104,8 +1998,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> { /// /// assert_eq!(map["poneyland"], 22); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn into_mut(self) -> &'a mut V { + pub fn into_mut(self) -> &'a mut V { self.elem.into_mut_refs().1 } @@ -2126,8 +2019,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> { /// /// assert_eq!(map["poneyland"], 15); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn insert(&mut self, mut value: V) -> V { + pub fn insert(&mut self, mut value: V) -> V { let old_value = self.get_mut(); mem::swap(&mut value, old_value); value @@ -2150,8 +2042,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> { /// /// assert_eq!(map.contains_key("poneyland"), false); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn remove(self) -> V { + pub fn remove(self) -> V { pop_internal(self.elem).1 } @@ -2175,8 +2066,7 @@ impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> { /// let mut map: HashMap<&str, u32> = HashMap::new(); /// assert_eq!(map.entry("poneyland").key(), &"poneyland"); /// ``` - #[stable(feature = "map_entry_keys", since = "1.10.0")] - pub fn key(&self) -> &K { + pub fn key(&self) -> &K { &self.key } @@ -2194,8 +2084,7 @@ impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> { /// v.into_key(); /// } /// ``` - #[stable(feature = "map_entry_recover_keys2", since = "1.12.0")] - pub fn into_key(self) -> K { + pub fn into_key(self) -> K { self.key } @@ -2215,8 +2104,7 @@ impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> { /// } /// assert_eq!(map["poneyland"], 37); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn insert(self, value: V) -> &'a mut V { + pub fn insert(self, value: V) -> &'a mut V { let b = match self.elem { NeqElem(mut bucket, disp) => { if disp >= DISPLACEMENT_THRESHOLD { @@ -2255,7 +2143,6 @@ impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> { } } -#[stable(feature = "rust1", since = "1.0.0")] impl FromIterator<(K, V)> for HashMap where K: Eq + Hash, S: BuildHasher + Default @@ -2267,7 +2154,6 @@ impl FromIterator<(K, V)> for HashMap } } -#[stable(feature = "rust1", since = "1.0.0")] impl Extend<(K, V)> for HashMap where K: Eq + Hash, S: BuildHasher @@ -2290,7 +2176,6 @@ impl Extend<(K, V)> for HashMap } } -#[stable(feature = "hash_extend_copy", since = "1.4.0")] impl<'a, K, V, S> Extend<(&'a K, &'a V)> for HashMap where K: Eq + Hash + Copy, V: Copy, @@ -2321,7 +2206,6 @@ impl<'a, K, V, S> Extend<(&'a K, &'a V)> for HashMap /// map.insert(1, 2); /// ``` #[derive(Clone)] -#[stable(feature = "hashmap_build_hasher", since = "1.7.0")] pub struct RandomState { k0: u64, k1: u64, @@ -2340,8 +2224,7 @@ impl RandomState { #[inline] #[allow(deprecated)] // rand - #[stable(feature = "hashmap_build_hasher", since = "1.7.0")] - pub fn new() -> RandomState { + pub fn new() -> RandomState { // Historically this function did not cache keys from the OS and instead // simply always called `rand::thread_rng().gen()` twice. In #31356 it // was discovered, however, that because we re-seed the thread-local RNG @@ -2367,7 +2250,6 @@ impl RandomState { } } -#[stable(feature = "hashmap_build_hasher", since = "1.7.0")] impl BuildHasher for RandomState { type Hasher = DefaultHasher; #[inline] @@ -2384,7 +2266,6 @@ impl BuildHasher for RandomState { /// /// [`RandomState`]: struct.RandomState.html /// [`Hasher`]: ../../hash/trait.Hasher.html -#[stable(feature = "hashmap_default_hasher", since = "1.13.0")] #[allow(deprecated)] #[derive(Clone, Debug)] pub struct DefaultHasher(SipHasher13); @@ -2395,14 +2276,12 @@ impl DefaultHasher { /// This hasher is not guaranteed to be the same as all other /// `DefaultHasher` instances, but is the same as all other `DefaultHasher` /// instances created through `new` or `default`. - #[stable(feature = "hashmap_default_hasher", since = "1.13.0")] - #[allow(deprecated)] + #[allow(deprecated)] pub fn new() -> DefaultHasher { DefaultHasher(SipHasher13::new_with_keys(0, 0)) } } -#[stable(feature = "hashmap_default_hasher", since = "1.13.0")] impl Default for DefaultHasher { /// Creates a new `DefaultHasher` using [`new`]. See its documentation for more. /// @@ -2412,7 +2291,6 @@ impl Default for DefaultHasher { } } -#[stable(feature = "hashmap_default_hasher", since = "1.13.0")] impl Hasher for DefaultHasher { #[inline] fn write(&mut self, msg: &[u8]) { @@ -2425,7 +2303,6 @@ impl Hasher for DefaultHasher { } } -#[stable(feature = "hashmap_build_hasher", since = "1.7.0")] impl Default for RandomState { /// Constructs a new `RandomState`. #[inline] @@ -2434,7 +2311,6 @@ impl Default for RandomState { } } -#[stable(feature = "std_debug", since = "1.16.0")] impl fmt::Debug for RandomState { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.pad("RandomState { .. }") diff --git a/src/hash/set.rs b/src/hash/set.rs index 9771363d545..87894d0b711 100644 --- a/src/hash/set.rs +++ b/src/hash/set.rs @@ -117,7 +117,6 @@ use super::map::{self, HashMap, Keys, RandomState}; /// [`PartialEq`]: ../../std/cmp/trait.PartialEq.html /// [`RefCell`]: ../../std/cell/struct.RefCell.html #[derive(Clone)] -#[stable(feature = "rust1", since = "1.0.0")] pub struct HashSet { map: HashMap, } @@ -132,8 +131,7 @@ impl HashSet { /// let set: HashSet = HashSet::new(); /// ``` #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - pub fn new() -> HashSet { + pub fn new() -> HashSet { HashSet { map: HashMap::new() } } @@ -150,8 +148,7 @@ impl HashSet { /// assert!(set.capacity() >= 10); /// ``` #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - pub fn with_capacity(capacity: usize) -> HashSet { + pub fn with_capacity(capacity: usize) -> HashSet { HashSet { map: HashMap::with_capacity(capacity) } } } @@ -181,8 +178,7 @@ impl HashSet /// set.insert(2); /// ``` #[inline] - #[stable(feature = "hashmap_build_hasher", since = "1.7.0")] - pub fn with_hasher(hasher: S) -> HashSet { + pub fn with_hasher(hasher: S) -> HashSet { HashSet { map: HashMap::with_hasher(hasher) } } @@ -208,8 +204,7 @@ impl HashSet /// set.insert(1); /// ``` #[inline] - #[stable(feature = "hashmap_build_hasher", since = "1.7.0")] - pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> HashSet { + pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> HashSet { HashSet { map: HashMap::with_capacity_and_hasher(capacity, hasher) } } @@ -227,8 +222,7 @@ impl HashSet /// let set: HashSet = HashSet::with_hasher(hasher); /// let hasher: &RandomState = set.hasher(); /// ``` - #[stable(feature = "hashmap_public_hasher", since = "1.9.0")] - pub fn hasher(&self) -> &S { + pub fn hasher(&self) -> &S { self.map.hasher() } @@ -242,8 +236,7 @@ impl HashSet /// assert!(set.capacity() >= 100); /// ``` #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - pub fn capacity(&self) -> usize { + pub fn capacity(&self) -> usize { self.map.capacity() } @@ -263,8 +256,7 @@ impl HashSet /// set.reserve(10); /// assert!(set.capacity() >= 10); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn reserve(&mut self, additional: usize) { + pub fn reserve(&mut self, additional: usize) { self.map.reserve(additional) } @@ -284,8 +276,7 @@ impl HashSet /// set.shrink_to_fit(); /// assert!(set.capacity() >= 2); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn shrink_to_fit(&mut self) { + pub fn shrink_to_fit(&mut self) { self.map.shrink_to_fit() } @@ -305,8 +296,7 @@ impl HashSet /// println!("{}", x); /// } /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn iter(&self) -> Iter { + pub fn iter(&self) -> Iter { Iter { iter: self.map.keys() } } @@ -333,8 +323,7 @@ impl HashSet /// let diff: HashSet<_> = b.difference(&a).collect(); /// assert_eq!(diff, [4].iter().collect()); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn difference<'a>(&'a self, other: &'a HashSet) -> Difference<'a, T, S> { + pub fn difference<'a>(&'a self, other: &'a HashSet) -> Difference<'a, T, S> { Difference { iter: self.iter(), other, @@ -362,8 +351,7 @@ impl HashSet /// assert_eq!(diff1, diff2); /// assert_eq!(diff1, [1, 4].iter().collect()); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn symmetric_difference<'a>(&'a self, + pub fn symmetric_difference<'a>(&'a self, other: &'a HashSet) -> SymmetricDifference<'a, T, S> { SymmetricDifference { iter: self.difference(other).chain(other.difference(self)) } @@ -387,8 +375,7 @@ impl HashSet /// let intersection: HashSet<_> = a.intersection(&b).collect(); /// assert_eq!(intersection, [2, 3].iter().collect()); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn intersection<'a>(&'a self, other: &'a HashSet) -> Intersection<'a, T, S> { + pub fn intersection<'a>(&'a self, other: &'a HashSet) -> Intersection<'a, T, S> { Intersection { iter: self.iter(), other, @@ -413,8 +400,7 @@ impl HashSet /// let union: HashSet<_> = a.union(&b).collect(); /// assert_eq!(union, [1, 2, 3, 4].iter().collect()); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn union<'a>(&'a self, other: &'a HashSet) -> Union<'a, T, S> { + pub fn union<'a>(&'a self, other: &'a HashSet) -> Union<'a, T, S> { Union { iter: self.iter().chain(other.difference(self)) } } @@ -430,8 +416,7 @@ impl HashSet /// v.insert(1); /// assert_eq!(v.len(), 1); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn len(&self) -> usize { + pub fn len(&self) -> usize { self.map.len() } @@ -447,8 +432,7 @@ impl HashSet /// v.insert(1); /// assert!(!v.is_empty()); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn is_empty(&self) -> bool { + pub fn is_empty(&self) -> bool { self.map.is_empty() } @@ -470,8 +454,7 @@ impl HashSet /// assert!(set.is_empty()); /// ``` #[inline] - #[stable(feature = "drain", since = "1.6.0")] - pub fn drain(&mut self) -> Drain { + pub fn drain(&mut self) -> Drain { Drain { iter: self.map.drain() } } @@ -487,8 +470,7 @@ impl HashSet /// v.clear(); /// assert!(v.is_empty()); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn clear(&mut self) { + pub fn clear(&mut self) { self.map.clear() } @@ -510,8 +492,7 @@ impl HashSet /// /// [`Eq`]: ../../std/cmp/trait.Eq.html /// [`Hash`]: ../../std/hash/trait.Hash.html - #[stable(feature = "rust1", since = "1.0.0")] - pub fn contains(&self, value: &Q) -> bool + pub fn contains(&self, value: &Q) -> bool where T: Borrow, Q: Hash + Eq { @@ -526,8 +507,7 @@ impl HashSet /// /// [`Eq`]: ../../std/cmp/trait.Eq.html /// [`Hash`]: ../../std/hash/trait.Hash.html - #[stable(feature = "set_recovery", since = "1.9.0")] - pub fn get(&self, value: &Q) -> Option<&T> + pub fn get(&self, value: &Q) -> Option<&T> where T: Borrow, Q: Hash + Eq { @@ -551,8 +531,7 @@ impl HashSet /// b.insert(1); /// assert_eq!(a.is_disjoint(&b), false); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn is_disjoint(&self, other: &HashSet) -> bool { + pub fn is_disjoint(&self, other: &HashSet) -> bool { self.iter().all(|v| !other.contains(v)) } @@ -573,8 +552,7 @@ impl HashSet /// set.insert(4); /// assert_eq!(set.is_subset(&sup), false); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn is_subset(&self, other: &HashSet) -> bool { + pub fn is_subset(&self, other: &HashSet) -> bool { self.iter().all(|v| other.contains(v)) } @@ -599,8 +577,7 @@ impl HashSet /// assert_eq!(set.is_superset(&sub), true); /// ``` #[inline] - #[stable(feature = "rust1", since = "1.0.0")] - pub fn is_superset(&self, other: &HashSet) -> bool { + pub fn is_superset(&self, other: &HashSet) -> bool { other.is_subset(self) } @@ -621,15 +598,13 @@ impl HashSet /// assert_eq!(set.insert(2), false); /// assert_eq!(set.len(), 1); /// ``` - #[stable(feature = "rust1", since = "1.0.0")] - pub fn insert(&mut self, value: T) -> bool { + pub fn insert(&mut self, value: T) -> bool { self.map.insert(value, ()).is_none() } /// Adds a value to the set, replacing the existing value, if any, that is equal to the given /// one. Returns the replaced value. - #[stable(feature = "set_recovery", since = "1.9.0")] - pub fn replace(&mut self, value: T) -> Option { + pub fn replace(&mut self, value: T) -> Option { Recover::replace(&mut self.map, value) } @@ -654,8 +629,7 @@ impl HashSet /// /// [`Eq`]: ../../std/cmp/trait.Eq.html /// [`Hash`]: ../../std/hash/trait.Hash.html - #[stable(feature = "rust1", since = "1.0.0")] - pub fn remove(&mut self, value: &Q) -> bool + pub fn remove(&mut self, value: &Q) -> bool where T: Borrow, Q: Hash + Eq { @@ -670,8 +644,7 @@ impl HashSet /// /// [`Eq`]: ../../std/cmp/trait.Eq.html /// [`Hash`]: ../../std/hash/trait.Hash.html - #[stable(feature = "set_recovery", since = "1.9.0")] - pub fn take(&mut self, value: &Q) -> Option + pub fn take(&mut self, value: &Q) -> Option where T: Borrow, Q: Hash + Eq { @@ -692,15 +665,13 @@ impl HashSet /// set.retain(|&k| k % 2 == 0); /// assert_eq!(set.len(), 3); /// ``` - #[stable(feature = "retain_hash_collection", since = "1.18.0")] - pub fn retain(&mut self, mut f: F) + pub fn retain(&mut self, mut f: F) where F: FnMut(&T) -> bool { self.map.retain(|k, _| f(k)); } } -#[stable(feature = "rust1", since = "1.0.0")] impl PartialEq for HashSet where T: Eq + Hash, S: BuildHasher @@ -714,14 +685,12 @@ impl PartialEq for HashSet } } -#[stable(feature = "rust1", since = "1.0.0")] impl Eq for HashSet where T: Eq + Hash, S: BuildHasher { } -#[stable(feature = "rust1", since = "1.0.0")] impl fmt::Debug for HashSet where T: Eq + Hash + fmt::Debug, S: BuildHasher @@ -731,7 +700,6 @@ impl fmt::Debug for HashSet } } -#[stable(feature = "rust1", since = "1.0.0")] impl FromIterator for HashSet where T: Eq + Hash, S: BuildHasher + Default @@ -743,7 +711,6 @@ impl FromIterator for HashSet } } -#[stable(feature = "rust1", since = "1.0.0")] impl Extend for HashSet where T: Eq + Hash, S: BuildHasher @@ -753,7 +720,6 @@ impl Extend for HashSet } } -#[stable(feature = "hash_extend_copy", since = "1.4.0")] impl<'a, T, S> Extend<&'a T> for HashSet where T: 'a + Eq + Hash + Copy, S: BuildHasher @@ -763,7 +729,6 @@ impl<'a, T, S> Extend<&'a T> for HashSet } } -#[stable(feature = "rust1", since = "1.0.0")] impl Default for HashSet where T: Eq + Hash, S: BuildHasher + Default @@ -774,7 +739,6 @@ impl Default for HashSet } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, 'b, T, S> BitOr<&'b HashSet> for &'a HashSet where T: Eq + Hash + Clone, S: BuildHasher + Default @@ -806,7 +770,6 @@ impl<'a, 'b, T, S> BitOr<&'b HashSet> for &'a HashSet } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, 'b, T, S> BitAnd<&'b HashSet> for &'a HashSet where T: Eq + Hash + Clone, S: BuildHasher + Default @@ -838,7 +801,6 @@ impl<'a, 'b, T, S> BitAnd<&'b HashSet> for &'a HashSet } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, 'b, T, S> BitXor<&'b HashSet> for &'a HashSet where T: Eq + Hash + Clone, S: BuildHasher + Default @@ -870,7 +832,6 @@ impl<'a, 'b, T, S> BitXor<&'b HashSet> for &'a HashSet } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, 'b, T, S> Sub<&'b HashSet> for &'a HashSet where T: Eq + Hash + Clone, S: BuildHasher + Default @@ -909,7 +870,6 @@ impl<'a, 'b, T, S> Sub<&'b HashSet> for &'a HashSet /// /// [`HashSet`]: struct.HashSet.html /// [`iter`]: struct.HashSet.html#method.iter -#[stable(feature = "rust1", since = "1.0.0")] pub struct Iter<'a, K: 'a> { iter: Keys<'a, K, ()>, } @@ -921,7 +881,6 @@ pub struct Iter<'a, K: 'a> { /// /// [`HashSet`]: struct.HashSet.html /// [`into_iter`]: struct.HashSet.html#method.into_iter -#[stable(feature = "rust1", since = "1.0.0")] pub struct IntoIter { iter: map::IntoIter, } @@ -933,7 +892,6 @@ pub struct IntoIter { /// /// [`HashSet`]: struct.HashSet.html /// [`drain`]: struct.HashSet.html#method.drain -#[stable(feature = "rust1", since = "1.0.0")] pub struct Drain<'a, K: 'a> { iter: map::Drain<'a, K, ()>, } @@ -945,7 +903,6 @@ pub struct Drain<'a, K: 'a> { /// /// [`HashSet`]: struct.HashSet.html /// [`intersection`]: struct.HashSet.html#method.intersection -#[stable(feature = "rust1", since = "1.0.0")] pub struct Intersection<'a, T: 'a, S: 'a> { // iterator of the first set iter: Iter<'a, T>, @@ -960,7 +917,6 @@ pub struct Intersection<'a, T: 'a, S: 'a> { /// /// [`HashSet`]: struct.HashSet.html /// [`difference`]: struct.HashSet.html#method.difference -#[stable(feature = "rust1", since = "1.0.0")] pub struct Difference<'a, T: 'a, S: 'a> { // iterator of the first set iter: Iter<'a, T>, @@ -975,7 +931,6 @@ pub struct Difference<'a, T: 'a, S: 'a> { /// /// [`HashSet`]: struct.HashSet.html /// [`symmetric_difference`]: struct.HashSet.html#method.symmetric_difference -#[stable(feature = "rust1", since = "1.0.0")] pub struct SymmetricDifference<'a, T: 'a, S: 'a> { iter: Chain, Difference<'a, T, S>>, } @@ -987,12 +942,10 @@ pub struct SymmetricDifference<'a, T: 'a, S: 'a> { /// /// [`HashSet`]: struct.HashSet.html /// [`union`]: struct.HashSet.html#method.union -#[stable(feature = "rust1", since = "1.0.0")] pub struct Union<'a, T: 'a, S: 'a> { iter: Chain, Difference<'a, T, S>>, } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, S> IntoIterator for &'a HashSet where T: Eq + Hash, S: BuildHasher @@ -1005,7 +958,6 @@ impl<'a, T, S> IntoIterator for &'a HashSet } } -#[stable(feature = "rust1", since = "1.0.0")] impl IntoIterator for HashSet where T: Eq + Hash, S: BuildHasher @@ -1038,13 +990,11 @@ impl IntoIterator for HashSet } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K> Clone for Iter<'a, K> { fn clone(&self) -> Iter<'a, K> { Iter { iter: self.iter.clone() } } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K> Iterator for Iter<'a, K> { type Item = &'a K; @@ -1055,23 +1005,19 @@ impl<'a, K> Iterator for Iter<'a, K> { self.iter.size_hint() } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K> ExactSizeIterator for Iter<'a, K> { fn len(&self) -> usize { self.iter.len() } } -#[unstable(feature = "fused", issue = "35602")] impl<'a, K> FusedIterator for Iter<'a, K> {} -#[stable(feature = "std_debug", since = "1.16.0")] impl<'a, K: fmt::Debug> fmt::Debug for Iter<'a, K> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.debug_list().entries(self.clone()).finish() } } -#[stable(feature = "rust1", since = "1.0.0")] impl Iterator for IntoIter { type Item = K; @@ -1082,16 +1028,13 @@ impl Iterator for IntoIter { self.iter.size_hint() } } -#[stable(feature = "rust1", since = "1.0.0")] impl ExactSizeIterator for IntoIter { fn len(&self) -> usize { self.iter.len() } } -#[unstable(feature = "fused", issue = "35602")] impl FusedIterator for IntoIter {} -#[stable(feature = "std_debug", since = "1.16.0")] impl fmt::Debug for IntoIter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let entries_iter = self.iter @@ -1102,7 +1045,6 @@ impl fmt::Debug for IntoIter { } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K> Iterator for Drain<'a, K> { type Item = K; @@ -1113,16 +1055,13 @@ impl<'a, K> Iterator for Drain<'a, K> { self.iter.size_hint() } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, K> ExactSizeIterator for Drain<'a, K> { fn len(&self) -> usize { self.iter.len() } } -#[unstable(feature = "fused", issue = "35602")] impl<'a, K> FusedIterator for Drain<'a, K> {} -#[stable(feature = "std_debug", since = "1.16.0")] impl<'a, K: fmt::Debug> fmt::Debug for Drain<'a, K> { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let entries_iter = self.iter @@ -1133,14 +1072,12 @@ impl<'a, K: fmt::Debug> fmt::Debug for Drain<'a, K> { } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, S> Clone for Intersection<'a, T, S> { fn clone(&self) -> Intersection<'a, T, S> { Intersection { iter: self.iter.clone(), ..*self } } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, S> Iterator for Intersection<'a, T, S> where T: Eq + Hash, S: BuildHasher @@ -1166,7 +1103,6 @@ impl<'a, T, S> Iterator for Intersection<'a, T, S> } } -#[stable(feature = "std_debug", since = "1.16.0")] impl<'a, T, S> fmt::Debug for Intersection<'a, T, S> where T: fmt::Debug + Eq + Hash, S: BuildHasher @@ -1176,21 +1112,18 @@ impl<'a, T, S> fmt::Debug for Intersection<'a, T, S> } } -#[unstable(feature = "fused", issue = "35602")] impl<'a, T, S> FusedIterator for Intersection<'a, T, S> where T: Eq + Hash, S: BuildHasher { } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, S> Clone for Difference<'a, T, S> { fn clone(&self) -> Difference<'a, T, S> { Difference { iter: self.iter.clone(), ..*self } } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, S> Iterator for Difference<'a, T, S> where T: Eq + Hash, S: BuildHasher @@ -1216,14 +1149,12 @@ impl<'a, T, S> Iterator for Difference<'a, T, S> } } -#[unstable(feature = "fused", issue = "35602")] impl<'a, T, S> FusedIterator for Difference<'a, T, S> where T: Eq + Hash, S: BuildHasher { } -#[stable(feature = "std_debug", since = "1.16.0")] impl<'a, T, S> fmt::Debug for Difference<'a, T, S> where T: fmt::Debug + Eq + Hash, S: BuildHasher @@ -1233,14 +1164,12 @@ impl<'a, T, S> fmt::Debug for Difference<'a, T, S> } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, S> Clone for SymmetricDifference<'a, T, S> { fn clone(&self) -> SymmetricDifference<'a, T, S> { SymmetricDifference { iter: self.iter.clone() } } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, S> Iterator for SymmetricDifference<'a, T, S> where T: Eq + Hash, S: BuildHasher @@ -1255,14 +1184,12 @@ impl<'a, T, S> Iterator for SymmetricDifference<'a, T, S> } } -#[unstable(feature = "fused", issue = "35602")] impl<'a, T, S> FusedIterator for SymmetricDifference<'a, T, S> where T: Eq + Hash, S: BuildHasher { } -#[stable(feature = "std_debug", since = "1.16.0")] impl<'a, T, S> fmt::Debug for SymmetricDifference<'a, T, S> where T: fmt::Debug + Eq + Hash, S: BuildHasher @@ -1272,21 +1199,18 @@ impl<'a, T, S> fmt::Debug for SymmetricDifference<'a, T, S> } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, S> Clone for Union<'a, T, S> { fn clone(&self) -> Union<'a, T, S> { Union { iter: self.iter.clone() } } } -#[unstable(feature = "fused", issue = "35602")] impl<'a, T, S> FusedIterator for Union<'a, T, S> where T: Eq + Hash, S: BuildHasher { } -#[stable(feature = "std_debug", since = "1.16.0")] impl<'a, T, S> fmt::Debug for Union<'a, T, S> where T: fmt::Debug + Eq + Hash, S: BuildHasher @@ -1296,7 +1220,6 @@ impl<'a, T, S> fmt::Debug for Union<'a, T, S> } } -#[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, S> Iterator for Union<'a, T, S> where T: Eq + Hash, S: BuildHasher diff --git a/src/lib.rs b/src/lib.rs index 7701a95a578..ad366cdc63d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -2,6 +2,7 @@ #![feature(dropck_eyepatch)] #![feature(allocator_api)] #![feature(rand, alloc, needs_drop, shared, unique, fused, placement_new_protocol)] +#![feature(sip_hash_13)] extern crate alloc; extern crate rand; @@ -9,12 +10,13 @@ extern crate rand; pub use std::*; -mod hash; +#[path="hash/mod.rs"] +mod impls; pub mod hash_map { - pub use super::hash::map::*; + pub use super::impls::map::*; } pub mod hash_set { - pub use super::hash::set::*; + pub use super::impls::set::*; }