Change 'Example' to 'Examples' throughout collections' rustdocs.

2 files changed, 47 insertions, 47 deletions

diff --git a/src/libcollections/tree/map.rs b/src/libcollections/tree/map.rs
index 3818be5a197..24395ca6493 100644
--- a/src/libcollections/tree/map.rs
+++ b/src/libcollections/tree/map.rs
@@ -31,7 +31,7 @@ use vec::Vec;
 /// as a right child. The time complexity is the same, and re-balancing
 /// operations are more frequent but also cheaper.
 ///
-/// # Example
+/// # Examples
 ///
 /// ```
 /// use std::collections::TreeMap;
@@ -207,7 +207,7 @@ impl<K: Ord, Sized? Q, V> IndexMut<Q, V> for TreeMap<K, V> where Q: BorrowFrom<K
 impl<K: Ord, V> TreeMap<K, V> {
     /// Creates an empty `TreeMap`.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -218,7 +218,7 @@ impl<K: Ord, V> TreeMap<K, V> {
 
     /// Gets a lazy iterator over the keys in the map, in ascending order.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -240,7 +240,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     /// Gets a lazy iterator over the values in the map, in ascending order
     /// with respect to the corresponding keys.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -261,7 +261,7 @@ impl<K: Ord, V> TreeMap<K, V> {
 
     /// Gets a lazy iterator over the key-value pairs in the map, in ascending order.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -287,7 +287,7 @@ impl<K: Ord, V> TreeMap<K, V> {
 
     /// Gets a lazy reverse iterator over the key-value pairs in the map, in descending order.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -308,7 +308,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     /// Gets a lazy forward iterator over the key-value pairs in the
     /// map, with the values being mutable.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -340,7 +340,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     /// Gets a lazy reverse iterator over the key-value pairs in the
     /// map, with the values being mutable.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -365,7 +365,7 @@ impl<K: Ord, V> TreeMap<K, V> {
 
     /// Gets a lazy iterator that consumes the treemap.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -393,7 +393,7 @@ impl<K: Ord, V> TreeMap<K, V> {
 
     /// Return the number of elements in the map.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -408,7 +408,7 @@ impl<K: Ord, V> TreeMap<K, V> {
 
     /// Return true if the map contains no elements.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -424,7 +424,7 @@ impl<K: Ord, V> TreeMap<K, V> {
 
     /// Clears the map, removing all values.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -451,7 +451,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     /// The key may be any borrowed form of the map's key type, but the ordering
     /// on the borrowed form *must* match the ordering on the key type.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -474,7 +474,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     /// The key may be any borrowed form of the map's key type, but the ordering
     /// on the borrowed form *must* match the ordering on the key type.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -503,7 +503,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     /// The key may be any borrowed form of the map's key type, but the ordering
     /// on the borrowed form *must* match the ordering on the key type.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -533,7 +533,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     /// Inserts a key-value pair from the map. If the key already had a value
     /// present in the map, that value is returned. Otherwise, `None` is returned.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -565,7 +565,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     /// The key may be any borrowed form of the map's key type, but the ordering
     /// on the borrowed form *must* match the ordering on the key type.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -590,7 +590,7 @@ impl<K, V> TreeMap<K, V> {
     /// with current key and guides tree navigation. That means `f` should
     /// be aware of natural ordering of the tree.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use collections::tree_map::TreeMap;
@@ -620,7 +620,7 @@ impl<K, V> TreeMap<K, V> {
     /// with current key and guides tree navigation. That means `f` should
     /// be aware of natural ordering of the tree.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// let mut t = collections::tree_map::TreeMap::new();
@@ -691,7 +691,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     /// Returns a lazy iterator to the first key-value pair whose key is not less than `k`
     /// If all keys in map are less than `k` an empty iterator is returned.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -713,7 +713,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     /// Returns a lazy iterator to the first key-value pair whose key is greater than `k`
     /// If all keys in map are less than or equal to `k` an empty iterator is returned.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -749,7 +749,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     /// If all keys in map are less than `k` an empty iterator is
     /// returned.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
@@ -783,7 +783,7 @@ impl<K: Ord, V> TreeMap<K, V> {
     /// If all keys in map are less than or equal to `k` an empty iterator
     /// is returned.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeMap;
diff --git a/src/libcollections/tree/set.rs b/src/libcollections/tree/set.rs
index 15bf4988619..ea9aff56448 100644
--- a/src/libcollections/tree/set.rs
+++ b/src/libcollections/tree/set.rs
@@ -27,7 +27,7 @@ use tree_map::{TreeMap, Entries, RevEntries, MoveEntries};
 /// only requirement is that the type of the elements contained ascribes to the
 /// `Ord` trait.
 ///
-/// ## Example
+/// ## Examples
 ///
 /// ```{rust}
 /// use std::collections::TreeSet;
@@ -142,7 +142,7 @@ impl<T: Ord> Default for TreeSet<T> {
 impl<T: Ord> TreeSet<T> {
     /// Creates an empty `TreeSet`.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -154,7 +154,7 @@ impl<T: Ord> TreeSet<T> {
 
     /// Gets a lazy iterator over the values in the set, in ascending order.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -173,7 +173,7 @@ impl<T: Ord> TreeSet<T> {
 
     /// Gets a lazy iterator over the values in the set, in descending order.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -192,7 +192,7 @@ impl<T: Ord> TreeSet<T> {
     /// Creates a consuming iterator, that is, one that moves each value out of the
     /// set in ascending order. The set cannot be used after calling this.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -211,7 +211,7 @@ impl<T: Ord> TreeSet<T> {
     /// Gets a lazy iterator pointing to the first value not less than `v` (greater or equal).
     /// If all elements in the set are less than `v` empty iterator is returned.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -230,7 +230,7 @@ impl<T: Ord> TreeSet<T> {
     /// If all elements in the set are less than or equal to `v` an
     /// empty iterator is returned.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -247,7 +247,7 @@ impl<T: Ord> TreeSet<T> {
 
     /// Visits the values representing the difference, in ascending order.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -275,7 +275,7 @@ impl<T: Ord> TreeSet<T> {
 
     /// Visits the values representing the symmetric difference, in ascending order.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -302,7 +302,7 @@ impl<T: Ord> TreeSet<T> {
 
     /// Visits the values representing the intersection, in ascending order.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -326,7 +326,7 @@ impl<T: Ord> TreeSet<T> {
 
     /// Visits the values representing the union, in ascending order.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -349,7 +349,7 @@ impl<T: Ord> TreeSet<T> {
 
     /// Return the number of elements in the set
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -365,7 +365,7 @@ impl<T: Ord> TreeSet<T> {
 
     /// Returns true if the set contains no elements
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -380,7 +380,7 @@ impl<T: Ord> TreeSet<T> {
 
     /// Clears the set, removing all values.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -400,7 +400,7 @@ impl<T: Ord> TreeSet<T> {
     /// but the ordering on the borrowed form *must* match the
     /// ordering on the value type.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -420,7 +420,7 @@ impl<T: Ord> TreeSet<T> {
     /// Returns `true` if the set has no elements in common with `other`.
     /// This is equivalent to checking for an empty intersection.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -441,7 +441,7 @@ impl<T: Ord> TreeSet<T> {
 
     /// Returns `true` if the set is a subset of another.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -482,7 +482,7 @@ impl<T: Ord> TreeSet<T> {
 
     /// Returns `true` if the set is a superset of another.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -507,7 +507,7 @@ impl<T: Ord> TreeSet<T> {
     /// Adds a value to the set. Returns `true` if the value was not already
     /// present in the set.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -529,7 +529,7 @@ impl<T: Ord> TreeSet<T> {
     /// but the ordering on the borrowed form *must* match the
     /// ordering on the value type.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -669,7 +669,7 @@ impl<'a, T: Ord> Iterator<&'a T> for UnionItems<'a, T> {
 impl<T: Ord + Clone> BitOr<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
     /// Returns the union of `self` and `rhs` as a new `TreeSet<T>`.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -690,7 +690,7 @@ impl<T: Ord + Clone> BitOr<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
 impl<T: Ord + Clone> BitAnd<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
     /// Returns the intersection of `self` and `rhs` as a new `TreeSet<T>`.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -711,7 +711,7 @@ impl<T: Ord + Clone> BitAnd<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
 impl<T: Ord + Clone> BitXor<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
     /// Returns the symmetric difference of `self` and `rhs` as a new `TreeSet<T>`.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;
@@ -732,7 +732,7 @@ impl<T: Ord + Clone> BitXor<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
 impl<T: Ord + Clone> Sub<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
     /// Returns the difference of `self` and `rhs` as a new `TreeSet<T>`.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::TreeSet;