Automatic linkification of Items

Author: JohnHeitmann

src/libcollections/binary_heap.rs

@@ -20,7 +20,7 @@
 //!
 //! This is a larger example that implements [Dijkstra's algorithm][dijkstra]
 //! to solve the [shortest path problem][sssp] on a [directed graph][dir_graph].
-//! It shows how to use `BinaryHeap` with custom types.
+//! It shows how to use [`BinaryHeap`] with custom types.
 //!
 //! [dijkstra]: http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
 //! [sssp]: http://en.wikipedia.org/wiki/Shortest_path_problem
@@ -37,7 +37,7 @@
 //!     position: usize,
 //! }
 //!
-//! // The priority queue depends on `Ord`.
+//! // The priority queue depends on [`Ord`].
 //! // Explicitly implement the trait so the queue becomes a min-heap
 //! // instead of a max-heap.
 //! impl Ord for State {
@@ -47,14 +47,14 @@
 //!     }
 //! }
 //!
-//! // `PartialOrd` needs to be implemented as well.
+//! // [`PartialOrd`] needs to be implemented as well.
 //! impl PartialOrd for State {
 //!     fn partial_cmp(&self, other: &State) -> Option<Ordering> {
 //!         Some(self.cmp(other))
 //!     }
 //! }
 //!
-//! // Each node is represented as an `usize`, for a shorter implementation.
+//! // Each node is represented as an [`usize`], for a shorter implementation.
 //! struct Edge {
 //!     node: usize,
 //!     cost: usize,
@@ -147,6 +147,11 @@
 //!     assert_eq!(shortest_path(&graph, 4, 0), None);
 //! }
 //! ```
+//!
+//! [`BinaryHeap`]: /std/collections/binary_heap/struct.BinaryHeap.html
+//! [`Ord`]: /std/cmp/trait.Ord.html
+//! [`PartialOrd`]: /std/cmp/trait.PartialOrd.html
+//! [`usize`]: /std/primitive.usize.html
 
 #![allow(missing_docs)]
 #![stable(feature = "rust1", since = "1.0.0")]
@@ -168,17 +173,17 @@ use super::SpecExtend;
 /// This will be a max-heap.
 ///
 /// It is a logic error for an item to be modified in such a way that the
-/// item's ordering relative to any other item, as determined by the `Ord`
+/// item's ordering relative to any other item, as determined by the [`Ord`]
 /// trait, changes while it is in the heap. This is normally only possible
-/// through `Cell`, `RefCell`, global state, I/O, or unsafe code.
+/// through [`Cell`], [`RefCell`], global state, I/O, or unsafe code.
 ///
 /// # Examples
 ///
 /// ```
 /// use std::collections::BinaryHeap;
 ///
 /// // Type inference lets us omit an explicit type signature (which
-/// // would be `BinaryHeap<i32>` in this example).
+/// // would be [`BinaryHeap<i32>`] in this example).
 /// let mut heap = BinaryHeap::new();
 ///
 /// // We can use peek to look at the next item in the heap. In this case,
@@ -214,15 +219,21 @@ use super::SpecExtend;
 /// // The heap should now be empty.
 /// assert!(heap.is_empty())
 /// ```
+///
+/// [`BinaryHeap<i32>`]: /std/collections/binary_heap/struct.BinaryHeap.html
+/// [`Cell`]: /std/cell/struct.Cell.html
+/// [`Ord`]: /std/cmp/trait.Ord.html
+/// [`RefCell`]: /std/cell/struct.RefCell.html
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct BinaryHeap<T> {
     data: Vec<T>,
 }
 
 /// A container object that represents the result of the [`peek_mut()`] method
-/// on `BinaryHeap`. See its documentation for details.
+/// on [`BinaryHeap`]. See its documentation for details.
 ///
 /// [`peek_mut()`]: struct.BinaryHeap.html#method.peek_mut
+/// [`BinaryHeap`]: /std/collections/binary_heap/struct.BinaryHeap.html
 #[unstable(feature = "binary_heap_peek_mut", issue = "34392")]
 pub struct PeekMut<'a, T: 'a + Ord> {
     heap: &'a mut BinaryHeap<T>
@@ -945,7 +956,9 @@ impl<'a, T> Drop for Hole<'a, T> {
     }
 }
 
-/// `BinaryHeap` iterator.
+/// [`BinaryHeap`] iterator.
+///
+/// [`BinaryHeap`]: /std/collections/binary_heap/struct.BinaryHeap.html
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Iter<'a, T: 'a> {
     iter: slice::Iter<'a, T>,
@@ -985,7 +998,9 @@ impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
 
-/// An iterator that moves out of a `BinaryHeap`.
+/// An iterator that moves out of a [`BinaryHeap`].
+///
+/// [`BinaryHeap`]: /std/collections/binary_heap/struct.BinaryHeap.html
 #[stable(feature = "rust1", since = "1.0.0")]
 #[derive(Clone)]
 pub struct IntoIter<T> {
@@ -1018,7 +1033,9 @@ impl<T> DoubleEndedIterator for IntoIter<T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> ExactSizeIterator for IntoIter<T> {}
 
-/// An iterator that drains a `BinaryHeap`.
+/// An iterator that drains a [`BinaryHeap`].
+///
+/// [`BinaryHeap`]: /std/collections/binary_heap/struct.BinaryHeap.html
 #[stable(feature = "drain", since = "1.6.0")]
 pub struct Drain<'a, T: 'a> {
     iter: vec::Drain<'a, T>,

src/libcollections/borrow.rs

@@ -37,12 +37,15 @@ impl<'a, B: ?Sized> Borrow<B> for Cow<'a, B>
     }
 }
 
-/// A generalization of `Clone` to borrowed data.
+/// A generalization of [`Clone`] to borrowed data.
 ///
 /// Some types make it possible to go from borrowed to owned, usually by
-/// implementing the `Clone` trait. But `Clone` works only for going from `&T`
-/// to `T`. The `ToOwned` trait generalizes `Clone` to construct owned data
+/// implementing the [`Clone`] trait. But [`Clone`] works only for going from `&T`
+/// to `T`. The [`ToOwned`] trait generalizes [`Clone`] to construct owned data
 /// from any borrow of a given type.
+///
+/// [`Clone`]: /std/clone/trait.Clone.html
+/// [`ToOwned`]: /std/borrow/trait.ToOwned.html
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait ToOwned {
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -75,12 +78,12 @@ impl<T> ToOwned for T where T: Clone {
 
 /// A clone-on-write smart pointer.
 ///
-/// The type `Cow` is a smart pointer providing clone-on-write functionality: it
+/// The type [`Cow`] is a smart pointer providing clone-on-write functionality: it
 /// can enclose and provide immutable access to borrowed data, and clone the
 /// data lazily when mutation or ownership is required. The type is designed to
-/// work with general borrowed data via the `Borrow` trait.
+/// work with general borrowed data via the [`Borrow`] trait.
 ///
-/// `Cow` implements `Deref`, which means that you can call
+/// [`Cow`] implements [`Deref`], which means that you can call
 /// non-mutating methods directly on the data it encloses. If mutation
 /// is desired, `to_mut` will obtain a mutable reference to an owned
 /// value, cloning if necessary.
@@ -101,6 +104,10 @@ impl<T> ToOwned for T where T: Clone {
 ///     }
 /// }
 /// ```
+///
+/// [`Borrow`]: /std/borrow/trait.Borrow.html
+/// [`Cow`]: /std/borrow/enum.Cow.html
+/// [`Deref`]: /std/ops/trait.Deref.html
 #[stable(feature = "rust1", since = "1.0.0")]
 pub enum Cow<'a, B: ?Sized + 'a>
     where B: ToOwned

src/libcollections/btree/map.rs

@@ -56,16 +56,16 @@ use self::Entry::*;
 /// however, performance is excellent.
 ///
 /// It is a logic error for a key to be modified in such a way that the key's ordering relative to
-/// any other key, as determined by the `Ord` trait, changes while it is in the map. This is
-/// normally only possible through `Cell`, `RefCell`, global state, I/O, or unsafe code.
+/// any other key, as determined by the [`Ord`] trait, changes while it is in the map. This is
+/// normally only possible through [`Cell`], [`RefCell`], global state, I/O, or unsafe code.
 ///
 /// # Examples
 ///
 /// ```
 /// use std::collections::BTreeMap;
 ///
 /// // type inference lets us omit an explicit type signature (which
-/// // would be `BTreeMap<&str, &str>` in this example).
+/// // would be [`BTreeMap<&str, &str>`] in this example).
 /// let mut movie_reviews = BTreeMap::new();
 ///
 /// // review some movies.
@@ -98,15 +98,15 @@ use self::Entry::*;
 /// }
 /// ```
 ///
-/// `BTreeMap` also implements an [`Entry API`](#method.entry), which allows
+/// [`BTreeMap`] also implements an [`Entry API`](#method.entry), which allows
 /// for more complex methods of getting, setting, updating and removing keys and
 /// their values:
 ///
 /// ```
 /// use std::collections::BTreeMap;
 ///
 /// // type inference lets us omit an explicit type signature (which
-/// // would be `BTreeMap<&str, u8>` in this example).
+/// // would be [`BTreeMap<&str, u8>`] in this example).
 /// let mut player_stats = BTreeMap::new();
 ///
 /// fn random_stat_buff() -> u8 {
@@ -126,6 +126,13 @@ use self::Entry::*;
 /// let stat = player_stats.entry("attack").or_insert(100);
 /// *stat += random_stat_buff();
 /// ```
+///
+/// [`BTreeMap`]: /std/collections/struct.BTreeMap.html
+/// [`BTreeMap<&str, &str>`]: /std/collections/struct.BTreeMap.html
+/// [`BTreeMap<&str, u8>`]: /std/collections/struct.BTreeMap.html
+/// [`Cell`]: /std/cell/struct.Cell.html
+/// [`Ord`]: /std/cmp/trait.Ord.html
+/// [`RefCell`]: /std/cell/struct.RefCell.html
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct BTreeMap<K, V> {
     root: node::Root<K, V>,

src/libcollections/btree/node.rs

@@ -130,10 +130,13 @@ impl<K, V> InternalNode<K, V> {
     }
 }
 
-/// An owned pointer to a node. This basically is either `Box<LeafNode<K, V>>` or
-/// `Box<InternalNode<K, V>>`. However, it contains no information as to which of the two types
+/// An owned pointer to a node. This basically is either [`Box<LeafNode<K, V>>`] or
+/// [`Box<InternalNode<K, V>>`]. However, it contains no information as to which of the two types
 /// of nodes is acutally behind the box, and, partially due to this lack of information, has no
 /// destructor.
+///
+/// [`Box<InternalNode<K, V>>`]: /collections/boxed/struct.Box.html
+/// [`Box<LeafNode<K, V>>`]: /collections/boxed/struct.Box.html
 struct BoxedNode<K, V> {
     ptr: Unique<LeafNode<K, V>>
 }
@@ -274,12 +277,14 @@ impl<K, V> Root<K, V> {
 /// - `BorrowType`: This can be `Immut<'a>` or `Mut<'a>` for some `'a` or `Owned`.
 ///    When this is `Immut<'a>`, the `NodeRef` acts roughly like `&'a Node`,
 ///    when this is `Mut<'a>`, the `NodeRef` acts roughly like `&'a mut Node`,
-///    and when this is `Owned`, the `NodeRef` acts roughly like `Box<Node>`.
+///    and when this is `Owned`, the `NodeRef` acts roughly like [`Box<Node>`].
 /// - `K` and `V`: These control what types of things are stored in the nodes.
 /// - `Type`: This can be `Leaf`, `Internal`, or `LeafOrInternal`. When this is
 ///   `Leaf`, the `NodeRef` points to a leaf node, when this is `Internal` the
 ///   `NodeRef` points to an internal node, and when this is `LeafOrInternal` the
 ///   `NodeRef` could be pointing to either type of node.
+///
+/// [`Box<Node>`]: /collections/boxed/struct.Box.html
 pub struct NodeRef<BorrowType, K, V, Type> {
     height: usize,
     node: NonZero<*const LeafNode<K, V>>,

src/libcollections/btree/set.rs

@@ -45,7 +45,7 @@ use Bound;
 /// use std::collections::BTreeSet;
 ///
 /// // Type inference lets us omit an explicit type signature (which
-/// // would be `BTreeSet<&str>` in this example).
+/// // would be [`BTreeSet<&str>`] in this example).
 /// let mut books = BTreeSet::new();
 ///
 /// // Add some books.
@@ -68,6 +68,8 @@ use Bound;
 ///     println!("{}", book);
 /// }
 /// ```
+///
+/// [`BTreeSet<&str>`]: /std/collections/btree_set/struct.BTreeSet.html
 #[derive(Clone, Hash, PartialEq, Eq, Ord, PartialOrd)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct BTreeSet<T> {

src/libcollections/enum_set.rs

@@ -29,9 +29,14 @@ use core::ops::{Sub, BitOr, BitAnd, BitXor};
 /// A specialized set implementation to use enum types.
 ///
 /// It is a logic error for an item to be modified in such a way that the
-/// transformation of the item to or from a `usize`, as determined by the
-/// `CLike` trait, changes while the item is in the set. This is normally only
-/// possible through `Cell`, `RefCell`, global state, I/O, or unsafe code.
+/// transformation of the item to or from a [`usize`], as determined by the
+/// [`CLike`] trait, changes while the item is in the set. This is normally only
+/// possible through [`Cell`], [`RefCell`], global state, I/O, or unsafe code.
+///
+/// [`CLike`]: /collections/enum_set/trait.CLike.html
+/// [`Cell`]: /std/cell/struct.Cell.html
+/// [`RefCell`]: /std/cell/struct.RefCell.html
+/// [`usize`]: /std/primitive.usize.html
 #[derive(PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct EnumSet<E> {
     // We must maintain the invariant that no bits are set