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

Author: jbranchaud

src/libcollections/binary_heap.rs

@@ -15,7 +15,7 @@
 //! complexity. A priority queue can also be converted to a sorted vector in-place, allowing it to
 //! be used for an `O(n log n)` in-place heapsort.
 //!
-//! # Example
+//! # Examples
 //!
 //! This is a larger example which implements [Dijkstra's algorithm][dijkstra]
 //! to solve the [shortest path problem][sssp] on a [directed graph][dir_graph].
@@ -178,7 +178,7 @@ impl<T: Ord> Default for BinaryHeap<T> {
 impl<T: Ord> BinaryHeap<T> {
     /// Creates an empty `BinaryHeap` as a max-heap.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -192,7 +192,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// so that the `BinaryHeap` does not have to be reallocated
     /// until it contains at least that many values.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -206,7 +206,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// Creates a `BinaryHeap` from a vector. This is sometimes called
     /// `heapifying` the vector.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -225,7 +225,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// An iterator visiting all values in underlying vector, in
     /// arbitrary order.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -245,7 +245,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// the binary heap in arbitrary order.  The binary heap cannot be used
     /// after calling this.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -264,7 +264,7 @@ impl<T: Ord> BinaryHeap<T> {
 
     /// Returns the greatest item in a queue, or `None` if it is empty.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -284,7 +284,7 @@ impl<T: Ord> BinaryHeap<T> {
 
     /// Returns the number of elements the queue can hold without reallocating.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -306,7 +306,7 @@ impl<T: Ord> BinaryHeap<T> {
     ///
     /// Panics if the new capacity overflows `uint`.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -325,7 +325,7 @@ impl<T: Ord> BinaryHeap<T> {
     ///
     /// Panics if the new capacity overflows `uint`.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -348,7 +348,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// Removes the greatest item from a queue and returns it, or `None` if it
     /// is empty.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -375,7 +375,7 @@ impl<T: Ord> BinaryHeap<T> {
 
     /// Pushes an item onto the queue.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -398,7 +398,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// Pushes an item onto a queue then pops the greatest item off the queue in
     /// an optimized fashion.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -424,7 +424,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// an optimized fashion. The push is done regardless of whether the queue
     /// was empty.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -450,7 +450,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// Consumes the `BinaryHeap` and returns the underlying vector
     /// in arbitrary order.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;
@@ -468,7 +468,7 @@ impl<T: Ord> BinaryHeap<T> {
     /// Consumes the `BinaryHeap` and returns a vector in sorted
     /// (ascending) order.
     ///
-    /// # Example
+    /// # Examples
     ///
     /// ```
     /// use std::collections::BinaryHeap;