diff options
| -rw-r--r-- | library/core/src/convert/mod.rs | 27 | ||||
| -rw-r--r-- | library/core/src/iter/mod.rs | 30 |
2 files changed, 35 insertions, 22 deletions
diff --git a/library/core/src/convert/mod.rs b/library/core/src/convert/mod.rs index 31761017dcf..7849d267cca 100644 --- a/library/core/src/convert/mod.rs +++ b/library/core/src/convert/mod.rs @@ -134,8 +134,8 @@ pub const fn identity<T>(x: T) -> T { /// want to accept all references that can be converted to [`&str`] as an argument. /// Since both [`String`] and [`&str`] implement `AsRef<str>` we can accept both as input argument. /// -/// [`Option<T>`]: crate::option::Option -/// [`Result<T, E>`]: crate::result::Result +/// [`Option<T>`]: Option +/// [`Result<T, E>`]: Result /// [`Borrow`]: crate::borrow::Borrow /// [`Eq`]: crate::cmp::Eq /// [`Ord`]: crate::cmp::Ord @@ -168,8 +168,8 @@ pub trait AsRef<T: ?Sized> { /// **Note: This trait must not fail**. If the conversion can fail, use a /// dedicated method which returns an [`Option<T>`] or a [`Result<T, E>`]. /// -/// [`Option<T>`]: crate::option::Option -/// [`Result<T, E>`]: crate::result::Result +/// [`Option<T>`]: Option +/// [`Result<T, E>`]: Result /// /// # Generic Implementations /// @@ -195,7 +195,7 @@ pub trait AsRef<T: ?Sized> { /// assert_eq!(*boxed_num, 1); /// ``` /// -/// [`Box<T>`]: crate::boxed::Box<T> +/// [`Box<T>`]: ../../std/boxed/struct.Box.html #[stable(feature = "rust1", since = "1.0.0")] pub trait AsMut<T: ?Sized> { /// Performs the conversion. @@ -269,10 +269,10 @@ pub trait AsMut<T: ?Sized> { /// is_hello(s); /// ``` /// -/// [`Option<T>`]: crate::option::Option -/// [`Result<T, E>`]: crate::result::Result +/// [`Option<T>`]: Option +/// [`Result<T, E>`]: Result /// [`String`]: ../../std/string/struct.String.html -/// [`Vec`]: crate::vec::Vec<T> +/// [`Vec`]: ../../std/vec/struct.Vec.html #[stable(feature = "rust1", since = "1.0.0")] pub trait Into<T>: Sized { /// Performs the conversion. @@ -358,9 +358,10 @@ pub trait Into<T>: Sized { /// } /// ``` /// -/// [`Option<T>`]: crate::option::Option -/// [`Result<T, E>`]: crate::result::Result +/// [`Option<T>`]: Option +/// [`Result<T, E>`]: Result /// [`String`]: ../../std/string/struct.String.html +/// [`from`]: From::from /// [book]: ../../book/ch09-00-error-handling.html #[rustc_diagnostic_item = "from_trait"] #[stable(feature = "rust1", since = "1.0.0")] @@ -418,7 +419,7 @@ pub trait TryInto<T>: Sized { /// # Generic Implementations /// /// - `TryFrom<T> for U` implies [`TryInto`]`<U> for T` -/// - [`TryFrom::try_from`] is reflexive, which means that `TryFrom<T> for T` +/// - [`try_from`] is reflexive, which means that `TryFrom<T> for T` /// is implemented and cannot fail -- the associated `Error` type for /// calling `T::try_from()` on a value of type `T` is [`Infallible`]. /// When the [`!`] type is stabilized [`Infallible`] and [`!`] will be @@ -467,7 +468,7 @@ pub trait TryInto<T>: Sized { /// assert!(try_successful_smaller_number.is_ok()); /// ``` /// -/// [`i32::MAX`]: crate::i32::MAX +/// [`try_from`]: TryFrom::try_from /// [`!`]: ../../std/primitive.never.html #[stable(feature = "try_from", since = "1.34.0")] pub trait TryFrom<T>: Sized { @@ -670,8 +671,6 @@ impl AsRef<str> for str { /// the two `impl`s will start to overlap /// and therefore will be disallowed by the language’s trait coherence rules. /// -/// [`Ok`]: super::result::Result::Ok -/// [`Result`]: super::result::Result /// [never]: ../../std/primitive.never.html #[stable(feature = "convert_infallible", since = "1.34.0")] #[derive(Copy)] diff --git a/library/core/src/iter/mod.rs b/library/core/src/iter/mod.rs index a2e200ef63d..e482eab5b3d 100644 --- a/library/core/src/iter/mod.rs +++ b/library/core/src/iter/mod.rs @@ -152,11 +152,13 @@ //! produce an iterator. What gives? //! //! There's a trait in the standard library for converting something into an -//! iterator: [`IntoIterator`]. This trait has one method, [`IntoIterator::into_iter`], +//! iterator: [`IntoIterator`]. This trait has one method, [`into_iter`], //! which converts the thing implementing [`IntoIterator`] into an iterator. //! Let's take a look at that `for` loop again, and what the compiler converts //! it into: //! +//! [`into_iter`]: IntoIterator::into_iter +//! //! ``` //! let values = vec![1, 2, 3, 4, 5]; //! @@ -209,7 +211,7 @@ //! often called 'iterator adapters', as they're a form of the 'adapter //! pattern'. //! -//! Common iterator adapters include [`Iterator::map`], [`Iterator::take`], and [`Iterator::filter`]. +//! Common iterator adapters include [`map`], [`take`], and [`filter`]. //! For more, see their documentation. //! //! If an iterator adapter panics, the iterator will be in an unspecified (but @@ -217,12 +219,16 @@ //! across versions of Rust, so you should avoid relying on the exact values //! returned by an iterator which panicked. //! +//! [`map`]: Iterator::map +//! [`take`]: Iterator::take +//! [`filter`]: Iterator::filter +//! //! # Laziness //! //! Iterators (and iterator [adapters](#adapters)) are *lazy*. This means that //! just creating an iterator doesn't _do_ a whole lot. Nothing really happens //! until you call [`next`]. This is sometimes a source of confusion when -//! creating an iterator solely for its side effects. For example, the [`Iterator::map`] +//! creating an iterator solely for its side effects. For example, the [`map`] //! method calls a closure on each element it iterates over: //! //! ``` @@ -239,8 +245,8 @@ //! do nothing unless consumed //! ``` //! -//! The idiomatic way to write a [`Iterator::map`] for its side effects is to use a -//! `for` loop or call the [`Iterator::for_each`] method: +//! The idiomatic way to write a [`map`] for its side effects is to use a +//! `for` loop or call the [`for_each`] method: //! //! ``` //! let v = vec![1, 2, 3, 4, 5]; @@ -252,9 +258,14 @@ //! } //! ``` //! -//! Another common way to evaluate an iterator is to use the [`Iterator::collect`] +//! [`map`]: Iterator::map +//! [`for_each`]: Iterator::for_each +//! +//! Another common way to evaluate an iterator is to use the [`collect`] //! method to produce a new collection. //! +//! [`collect`]: Iterator::collect +//! //! # Infinity //! //! Iterators do not have to be finite. As an example, an open-ended range is @@ -264,7 +275,7 @@ //! let numbers = 0..; //! ``` //! -//! It is common to use the [`Iterator::take`] iterator adapter to turn an infinite +//! It is common to use the [`take`] iterator adapter to turn an infinite //! iterator into a finite one: //! //! ``` @@ -280,7 +291,7 @@ //! //! Bear in mind that methods on infinite iterators, even those for which a //! result can be determined mathematically in finite time, may not terminate. -//! Specifically, methods such as [`Iterator::min`], which in the general case require +//! Specifically, methods such as [`min`], which in the general case require //! traversing every element in the iterator, are likely not to return //! successfully for any infinite iterators. //! @@ -290,6 +301,9 @@ //! // `ones.min()` causes an infinite loop, so we won't reach this point! //! println!("The smallest number one is {}.", least); //! ``` +//! +//! [`take`]: Iterator::take +//! [`min`]: Iterator::min #![stable(feature = "rust1", since = "1.0.0")] |