Skip to content

Commit e15538d

Browse files
GankraManishearth
Gankra
authored and
Manishearth
committed
fix outdated docs
Conflicts: src/libstd/collections/mod.rs
1 parent 3a9b4e5 commit e15538d

File tree

7 files changed

+88
-88
lines changed

7 files changed

+88
-88
lines changed

‎src/libcollections/binary_heap.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -183,7 +183,7 @@ impl<T: Ord> BinaryHeap<T> {
183183
/// ```
184184
/// use std::collections::BinaryHeap;
185185
/// let mut heap = BinaryHeap::new();
186-
/// heap.push(4u);
186+
/// heap.push(4);
187187
/// ```
188188
#[stable(feature = "rust1", since = "1.0.0")]
189189
pub fn new() -> BinaryHeap<T> { BinaryHeap { data: vec![] } }
@@ -198,7 +198,7 @@ impl<T: Ord> BinaryHeap<T> {
198198
/// ```
199199
/// use std::collections::BinaryHeap;
200200
/// let mut heap = BinaryHeap::with_capacity(10);
201-
/// heap.push(4u);
201+
/// heap.push(4);
202202
/// ```
203203
#[stable(feature = "rust1", since = "1.0.0")]
204204
pub fn with_capacity(capacity: usize) -> BinaryHeap<T> {
@@ -292,7 +292,7 @@ impl<T: Ord> BinaryHeap<T> {
292292
/// use std::collections::BinaryHeap;
293293
/// let mut heap = BinaryHeap::with_capacity(100);
294294
/// assert!(heap.capacity() >= 100);
295-
/// heap.push(4u);
295+
/// heap.push(4);
296296
/// ```
297297
#[stable(feature = "rust1", since = "1.0.0")]
298298
pub fn capacity(&self) -> usize { self.data.capacity() }
@@ -315,7 +315,7 @@ impl<T: Ord> BinaryHeap<T> {
315315
/// let mut heap = BinaryHeap::new();
316316
/// heap.reserve_exact(100);
317317
/// assert!(heap.capacity() >= 100);
318-
/// heap.push(4u);
318+
/// heap.push(4);
319319
/// ```
320320
#[stable(feature = "rust1", since = "1.0.0")]
321321
pub fn reserve_exact(&mut self, additional: usize) {
@@ -336,7 +336,7 @@ impl<T: Ord> BinaryHeap<T> {
336336
/// let mut heap = BinaryHeap::new();
337337
/// heap.reserve(100);
338338
/// assert!(heap.capacity() >= 100);
339-
/// heap.push(4u);
339+
/// heap.push(4);
340340
/// ```
341341
#[stable(feature = "rust1", since = "1.0.0")]
342342
pub fn reserve(&mut self, additional: usize) {

‎src/libcollections/btree/map.rs

+28-28
Original file line numberDiff line numberDiff line change
@@ -173,7 +173,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
173173
/// use std::collections::BTreeMap;
174174
///
175175
/// let mut a = BTreeMap::new();
176-
/// a.insert(1u, "a");
176+
/// a.insert(1, "a");
177177
/// a.clear();
178178
/// assert!(a.is_empty());
179179
/// ```
@@ -203,7 +203,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
203203
/// use std::collections::BTreeMap;
204204
///
205205
/// let mut map = BTreeMap::new();
206-
/// map.insert(1u, "a");
206+
/// map.insert(1, "a");
207207
/// assert_eq!(map.get(&1), Some(&"a"));
208208
/// assert_eq!(map.get(&2), None);
209209
/// ```
@@ -235,7 +235,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
235235
/// use std::collections::BTreeMap;
236236
///
237237
/// let mut map = BTreeMap::new();
238-
/// map.insert(1u, "a");
238+
/// map.insert(1, "a");
239239
/// assert_eq!(map.contains_key(&1), true);
240240
/// assert_eq!(map.contains_key(&2), false);
241241
/// ```
@@ -255,7 +255,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
255255
/// use std::collections::BTreeMap;
256256
///
257257
/// let mut map = BTreeMap::new();
258-
/// map.insert(1u, "a");
258+
/// map.insert(1, "a");
259259
/// match map.get_mut(&1) {
260260
/// Some(x) => *x = "b",
261261
/// None => (),
@@ -317,7 +317,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
317317
/// use std::collections::BTreeMap;
318318
///
319319
/// let mut map = BTreeMap::new();
320-
/// assert_eq!(map.insert(37u, "a"), None);
320+
/// assert_eq!(map.insert(37, "a"), None);
321321
/// assert_eq!(map.is_empty(), false);
322322
///
323323
/// map.insert(37, "b");
@@ -429,7 +429,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
429429
/// use std::collections::BTreeMap;
430430
///
431431
/// let mut map = BTreeMap::new();
432-
/// map.insert(1u, "a");
432+
/// map.insert(1, "a");
433433
/// assert_eq!(map.remove(&1), Some("a"));
434434
/// assert_eq!(map.remove(&1), None);
435435
/// ```
@@ -1170,16 +1170,16 @@ impl<K, V> BTreeMap<K, V> {
11701170
/// use std::collections::BTreeMap;
11711171
///
11721172
/// let mut map = BTreeMap::new();
1173-
/// map.insert(1u, "a");
1174-
/// map.insert(2u, "b");
1175-
/// map.insert(3u, "c");
1173+
/// map.insert(1, "a");
1174+
/// map.insert(2, "b");
1175+
/// map.insert(3, "c");
11761176
///
11771177
/// for (key, value) in map.iter() {
11781178
/// println!("{}: {}", key, value);
11791179
/// }
11801180
///
11811181
/// let (first_key, first_value) = map.iter().next().unwrap();
1182-
/// assert_eq!((*first_key, *first_value), (1u, "a"));
1182+
/// assert_eq!((*first_key, *first_value), (1, "a"));
11831183
/// ```
11841184
#[stable(feature = "rust1", since = "1.0.0")]
11851185
pub fn iter(&self) -> Iter<K, V> {
@@ -1203,9 +1203,9 @@ impl<K, V> BTreeMap<K, V> {
12031203
/// use std::collections::BTreeMap;
12041204
///
12051205
/// let mut map = BTreeMap::new();
1206-
/// map.insert("a", 1u);
1207-
/// map.insert("b", 2u);
1208-
/// map.insert("c", 3u);
1206+
/// map.insert("a", 1);
1207+
/// map.insert("b", 2);
1208+
/// map.insert("c", 3);
12091209
///
12101210
/// // add 10 to the value if the key isn't "a"
12111211
/// for (key, value) in map.iter_mut() {
@@ -1235,9 +1235,9 @@ impl<K, V> BTreeMap<K, V> {
12351235
/// use std::collections::BTreeMap;
12361236
///
12371237
/// let mut map = BTreeMap::new();
1238-
/// map.insert(1u, "a");
1239-
/// map.insert(2u, "b");
1240-
/// map.insert(3u, "c");
1238+
/// map.insert(1, "a");
1239+
/// map.insert(2, "b");
1240+
/// map.insert(3, "c");
12411241
///
12421242
/// for (key, value) in map.into_iter() {
12431243
/// println!("{}: {}", key, value);
@@ -1264,11 +1264,11 @@ impl<K, V> BTreeMap<K, V> {
12641264
/// use std::collections::BTreeMap;
12651265
///
12661266
/// let mut a = BTreeMap::new();
1267-
/// a.insert(1u, "a");
1268-
/// a.insert(2u, "b");
1267+
/// a.insert(1, "a");
1268+
/// a.insert(2, "b");
12691269
///
12701270
/// let keys: Vec<usize> = a.keys().cloned().collect();
1271-
/// assert_eq!(keys, vec![1u,2,]);
1271+
/// assert_eq!(keys, vec![1,2,]);
12721272
/// ```
12731273
#[stable(feature = "rust1", since = "1.0.0")]
12741274
pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
@@ -1286,8 +1286,8 @@ impl<K, V> BTreeMap<K, V> {
12861286
/// use std::collections::BTreeMap;
12871287
///
12881288
/// let mut a = BTreeMap::new();
1289-
/// a.insert(1u, "a");
1290-
/// a.insert(2u, "b");
1289+
/// a.insert(1, "a");
1290+
/// a.insert(2, "b");
12911291
///
12921292
/// let values: Vec<&str> = a.values().cloned().collect();
12931293
/// assert_eq!(values, vec!["a","b"]);
@@ -1309,7 +1309,7 @@ impl<K, V> BTreeMap<K, V> {
13091309
///
13101310
/// let mut a = BTreeMap::new();
13111311
/// assert_eq!(a.len(), 0);
1312-
/// a.insert(1u, "a");
1312+
/// a.insert(1, "a");
13131313
/// assert_eq!(a.len(), 1);
13141314
/// ```
13151315
#[stable(feature = "rust1", since = "1.0.0")]
@@ -1324,7 +1324,7 @@ impl<K, V> BTreeMap<K, V> {
13241324
///
13251325
/// let mut a = BTreeMap::new();
13261326
/// assert!(a.is_empty());
1327-
/// a.insert(1u, "a");
1327+
/// a.insert(1, "a");
13281328
/// assert!(!a.is_empty());
13291329
/// ```
13301330
#[stable(feature = "rust1", since = "1.0.0")]
@@ -1474,13 +1474,13 @@ impl<K: Ord, V> BTreeMap<K, V> {
14741474
/// use std::collections::Bound::{Included, Unbounded};
14751475
///
14761476
/// let mut map = BTreeMap::new();
1477-
/// map.insert(3u, "a");
1478-
/// map.insert(5u, "b");
1479-
/// map.insert(8u, "c");
1477+
/// map.insert(3, "a");
1478+
/// map.insert(5, "b");
1479+
/// map.insert(8, "c");
14801480
/// for (&key, &value) in map.range(Included(&4), Included(&8)) {
14811481
/// println!("{}: {}", key, value);
14821482
/// }
1483-
/// assert_eq!(Some((&5u, &"b")), map.range(Included(&4), Unbounded).next());
1483+
/// assert_eq!(Some((&5, &"b")), map.range(Included(&4), Unbounded).next());
14841484
/// ```
14851485
#[unstable(feature = "collections",
14861486
reason = "matches collection reform specification, waiting for dust to settle")]
@@ -1539,7 +1539,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
15391539
/// }
15401540
/// }
15411541
///
1542-
/// assert_eq!(count["a"], 3u);
1542+
/// assert_eq!(count["a"], 3);
15431543
/// ```
15441544
#[stable(feature = "rust1", since = "1.0.0")]
15451545
pub fn entry(&mut self, mut key: K) -> Entry<K, V> {

‎src/libcollections/btree/set.rs

+26-26
Original file line numberDiff line numberDiff line change
@@ -114,14 +114,14 @@ impl<T> BTreeSet<T> {
114114
/// ```
115115
/// use std::collections::BTreeSet;
116116
///
117-
/// let set: BTreeSet<usize> = [1u, 2, 3, 4].iter().map(|&x| x).collect();
117+
/// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().map(|&x| x).collect();
118118
///
119119
/// for x in set.iter() {
120120
/// println!("{}", x);
121121
/// }
122122
///
123123
/// let v: Vec<usize> = set.iter().map(|&x| x).collect();
124-
/// assert_eq!(v, vec![1u,2,3,4]);
124+
/// assert_eq!(v, vec![1,2,3,4]);
125125
/// ```
126126
#[stable(feature = "rust1", since = "1.0.0")]
127127
pub fn iter(&self) -> Iter<T> {
@@ -135,10 +135,10 @@ impl<T> BTreeSet<T> {
135135
/// ```
136136
/// use std::collections::BTreeSet;
137137
///
138-
/// let set: BTreeSet<usize> = [1u, 2, 3, 4].iter().map(|&x| x).collect();
138+
/// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().map(|&x| x).collect();
139139
///
140140
/// let v: Vec<usize> = set.into_iter().collect();
141-
/// assert_eq!(v, vec![1u,2,3,4]);
141+
/// assert_eq!(v, vec![1,2,3,4]);
142142
/// ```
143143
#[stable(feature = "rust1", since = "1.0.0")]
144144
pub fn into_iter(self) -> IntoIter<T> {
@@ -162,13 +162,13 @@ impl<T: Ord> BTreeSet<T> {
162162
/// use std::collections::Bound::{Included, Unbounded};
163163
///
164164
/// let mut set = BTreeSet::new();
165-
/// set.insert(3u);
166-
/// set.insert(5u);
167-
/// set.insert(8u);
165+
/// set.insert(3);
166+
/// set.insert(5);
167+
/// set.insert(8);
168168
/// for &elem in set.range(Included(&4), Included(&8)) {
169169
/// println!("{}", elem);
170170
/// }
171-
/// assert_eq!(Some(&5u), set.range(Included(&4), Unbounded).next());
171+
/// assert_eq!(Some(&5), set.range(Included(&4), Unbounded).next());
172172
/// ```
173173
#[unstable(feature = "collections",
174174
reason = "matches collection reform specification, waiting for dust to settle")]
@@ -189,15 +189,15 @@ impl<T: Ord> BTreeSet<T> {
189189
/// use std::collections::BTreeSet;
190190
///
191191
/// let mut a = BTreeSet::new();
192-
/// a.insert(1u);
193-
/// a.insert(2u);
192+
/// a.insert(1);
193+
/// a.insert(2);
194194
///
195195
/// let mut b = BTreeSet::new();
196-
/// b.insert(2u);
197-
/// b.insert(3u);
196+
/// b.insert(2);
197+
/// b.insert(3);
198198
///
199199
/// let diff: Vec<usize> = a.difference(&b).cloned().collect();
200-
/// assert_eq!(diff, vec![1u]);
200+
/// assert_eq!(diff, vec![1]);
201201
/// ```
202202
#[stable(feature = "rust1", since = "1.0.0")]
203203
pub fn difference<'a>(&'a self, other: &'a BTreeSet<T>) -> Difference<'a, T> {
@@ -212,15 +212,15 @@ impl<T: Ord> BTreeSet<T> {
212212
/// use std::collections::BTreeSet;
213213
///
214214
/// let mut a = BTreeSet::new();
215-
/// a.insert(1u);
216-
/// a.insert(2u);
215+
/// a.insert(1);
216+
/// a.insert(2);
217217
///
218218
/// let mut b = BTreeSet::new();
219-
/// b.insert(2u);
220-
/// b.insert(3u);
219+
/// b.insert(2);
220+
/// b.insert(3);
221221
///
222222
/// let sym_diff: Vec<usize> = a.symmetric_difference(&b).cloned().collect();
223-
/// assert_eq!(sym_diff, vec![1u,3]);
223+
/// assert_eq!(sym_diff, vec![1,3]);
224224
/// ```
225225
#[stable(feature = "rust1", since = "1.0.0")]
226226
pub fn symmetric_difference<'a>(&'a self, other: &'a BTreeSet<T>)
@@ -236,15 +236,15 @@ impl<T: Ord> BTreeSet<T> {
236236
/// use std::collections::BTreeSet;
237237
///
238238
/// let mut a = BTreeSet::new();
239-
/// a.insert(1u);
240-
/// a.insert(2u);
239+
/// a.insert(1);
240+
/// a.insert(2);
241241
///
242242
/// let mut b = BTreeSet::new();
243-
/// b.insert(2u);
244-
/// b.insert(3u);
243+
/// b.insert(2);
244+
/// b.insert(3);
245245
///
246246
/// let intersection: Vec<usize> = a.intersection(&b).cloned().collect();
247-
/// assert_eq!(intersection, vec![2u]);
247+
/// assert_eq!(intersection, vec![2]);
248248
/// ```
249249
#[stable(feature = "rust1", since = "1.0.0")]
250250
pub fn intersection<'a>(&'a self, other: &'a BTreeSet<T>)
@@ -260,13 +260,13 @@ impl<T: Ord> BTreeSet<T> {
260260
/// use std::collections::BTreeSet;
261261
///
262262
/// let mut a = BTreeSet::new();
263-
/// a.insert(1u);
263+
/// a.insert(1);
264264
///
265265
/// let mut b = BTreeSet::new();
266-
/// b.insert(2u);
266+
/// b.insert(2);
267267
///
268268
/// let union: Vec<usize> = a.union(&b).cloned().collect();
269-
/// assert_eq!(union, vec![1u,2]);
269+
/// assert_eq!(union, vec![1,2]);
270270
/// ```
271271
#[stable(feature = "rust1", since = "1.0.0")]
272272
pub fn union<'a>(&'a self, other: &'a BTreeSet<T>) -> Union<'a, T> {

‎src/libcollections/ring_buf.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -388,7 +388,7 @@ impl<T> RingBuf<T> {
388388
/// use std::collections::RingBuf;
389389
///
390390
/// let mut buf = RingBuf::with_capacity(15);
391-
/// buf.extend(0u..4);
391+
/// buf.extend(0..4);
392392
/// assert_eq!(buf.capacity(), 15);
393393
/// buf.shrink_to_fit();
394394
/// assert!(buf.capacity() >= 4);

0 commit comments

Comments
 (0)