Rollup merge of #76238 - denisvasilik:intra-doc-links-core-iterator, r=jyn514
Move to intra-doc links for library/core/src/iter/traits/iterator.rs Helps with #75080. @jyn514 We're almost finished with this issue. Thanks for mentoring. If you have other topics to work on just let me know, I will be around in Discord. @rustbot modify labels: T-doc, A-intra-doc-links Known issues: * Link from `core` to `std` (#74481): [`OsStr`] [`String`] [`VecDeque<T>`]
This commit is contained in:
Dylan DPC
GitHub
commit
4918ed96ee
@ -21,8 +21,8 @@ fn _assert_is_object_safe(_: &dyn Iterator<Item = ()>) {}
|
||||
/// generally, please see the [module-level documentation]. In particular, you
|
||||
/// may want to know how to [implement `Iterator`][impl].
|
||||
///
|
||||
/// [module-level documentation]: index.html
|
||||
/// [impl]: index.html#implementing-iterator
|
||||
/// [module-level documentation]: crate::iter
|
||||
/// [impl]: crate::iter#implementing-iterator
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
#[rustc_on_unimplemented(
|
||||
on(
|
||||
@ -211,7 +211,7 @@ pub trait Iterator {
|
||||
/// returning the number of times it saw [`Some`]. Note that [`next`] has to be
|
||||
/// called at least once even if the iterator does not have any elements.
|
||||
///
|
||||
/// [`next`]: #tymethod.next
|
||||
/// [`next`]: Iterator::next
|
||||
///
|
||||
/// # Overflow Behavior
|
||||
///
|
||||
@ -448,9 +448,7 @@ pub trait Iterator {
|
||||
/// }
|
||||
/// ```
|
||||
///
|
||||
/// [`once`]: fn.once.html
|
||||
/// [`Iterator`]: trait.Iterator.html
|
||||
/// [`IntoIterator`]: trait.IntoIterator.html
|
||||
/// [`once`]: crate::iter::once
|
||||
/// [`OsStr`]: ../../std/ffi/struct.OsStr.html
|
||||
#[inline]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
@ -495,9 +493,6 @@ pub trait Iterator {
|
||||
/// [`Iterator`] itself. For example, slices (`&[T]`) implement
|
||||
/// [`IntoIterator`], and so can be passed to `zip()` directly:
|
||||
///
|
||||
/// [`IntoIterator`]: trait.IntoIterator.html
|
||||
/// [`Iterator`]: trait.Iterator.html
|
||||
///
|
||||
/// ```
|
||||
/// let s1 = &[1, 2, 3];
|
||||
/// let s2 = &[4, 5, 6];
|
||||
@ -529,8 +524,8 @@ pub trait Iterator {
|
||||
/// assert_eq!((2, 'o'), zipper[2]);
|
||||
/// ```
|
||||
///
|
||||
/// [`enumerate`]: #method.enumerate
|
||||
/// [`next`]: #tymethod.next
|
||||
/// [`enumerate`]: Iterator::enumerate
|
||||
/// [`next`]: Iterator::next
|
||||
#[inline]
|
||||
#[stable(feature = "rust1", since = "1.0.0")]
|
||||
fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter>
|
||||
@ -733,8 +728,8 @@ pub trait Iterator {
|
||||
/// Why `filter_map` and not just [`filter`] and [`map`]? The key is in this
|
||||
/// part:
|
||||
///
|
||||
/// [`filter`]: #method.filter
|
||||
/// [`map`]: #method.map
|
||||
/// [`filter`]: Iterator::filter
|
||||
/// [`map`]: Iterator::map
|
||||
///
|
||||
/// > If the closure returns [`Some(element)`][`Some`], then that element is returned.
|
||||
///
|
||||
@ -801,7 +796,7 @@ pub trait Iterator {
|
||||
///
|
||||
/// [`usize`]: type@usize
|
||||
/// [`usize::MAX`]: crate::usize::MAX
|
||||
/// [`zip`]: #method.zip
|
||||
/// [`zip`]: Iterator::zip
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@ -836,8 +831,8 @@ pub trait Iterator {
|
||||
/// anything other than fetching the next value) of the [`next`] method
|
||||
/// will occur.
|
||||
///
|
||||
/// [`peek`]: crate::iter::Peekable::peek
|
||||
/// [`next`]: #tymethod.next
|
||||
/// [`peek`]: Peekable::peek
|
||||
/// [`next`]: Iterator::next
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@ -875,7 +870,7 @@ pub trait Iterator {
|
||||
|
||||
/// Creates an iterator that [`skip`]s elements based on a predicate.
|
||||
///
|
||||
/// [`skip`]: #method.skip
|
||||
/// [`skip`]: Iterator::skip
|
||||
///
|
||||
/// `skip_while()` takes a closure as an argument. It will call this
|
||||
/// closure on each element of the iterator, and ignore elements
|
||||
@ -1042,8 +1037,8 @@ pub trait Iterator {
|
||||
///
|
||||
/// Here's the same example, but with [`take_while`] and [`map`]:
|
||||
///
|
||||
/// [`take_while`]: #method.take_while
|
||||
/// [`map`]: #method.map
|
||||
/// [`take_while`]: Iterator::take_while
|
||||
/// [`map`]: Iterator::map
|
||||
///
|
||||
/// ```
|
||||
/// let a = [-1i32, 4, 0, 1];
|
||||
@ -1103,7 +1098,7 @@ pub trait Iterator {
|
||||
/// It is also not specified what this iterator returns after the first` None` is returned.
|
||||
/// If you need fused iterator, use [`fuse`].
|
||||
///
|
||||
/// [`fuse`]: #method.fuse
|
||||
/// [`fuse`]: Iterator::fuse
|
||||
#[inline]
|
||||
#[unstable(feature = "iter_map_while", reason = "recently added", issue = "68537")]
|
||||
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
|
||||
@ -1189,7 +1184,7 @@ pub trait Iterator {
|
||||
/// An iterator adaptor similar to [`fold`] that holds internal state and
|
||||
/// produces a new iterator.
|
||||
///
|
||||
/// [`fold`]: #method.fold
|
||||
/// [`fold`]: Iterator::fold
|
||||
///
|
||||
/// `scan()` takes two arguments: an initial value which seeds the internal
|
||||
/// state, and a closure with two arguments, the first being a mutable
|
||||
@ -1245,8 +1240,8 @@ pub trait Iterator {
|
||||
/// one item for each element, and `flat_map()`'s closure returns an
|
||||
/// iterator for each element.
|
||||
///
|
||||
/// [`map`]: #method.map
|
||||
/// [`flatten`]: #method.flatten
|
||||
/// [`map`]: Iterator::map
|
||||
/// [`flatten`]: Iterator::flatten
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@ -1332,7 +1327,7 @@ pub trait Iterator {
|
||||
/// two-dimensional and not one-dimensional. To get a one-dimensional
|
||||
/// structure, you have to `flatten()` again.
|
||||
///
|
||||
/// [`flat_map()`]: #method.flat_map
|
||||
/// [`flat_map()`]: Iterator::flat_map
|
||||
#[inline]
|
||||
#[stable(feature = "iterator_flatten", since = "1.29.0")]
|
||||
fn flatten(self) -> Flatten<Self>
|
||||
@ -1639,7 +1634,7 @@ pub trait Iterator {
|
||||
/// assert_eq!(Ok(vec![1, 3]), result);
|
||||
/// ```
|
||||
///
|
||||
/// [`iter`]: #tymethod.next
|
||||
/// [`iter`]: Iterator::next
|
||||
/// [`String`]: ../../std/string/struct.String.html
|
||||
/// [`char`]: type@char
|
||||
#[inline]
|
||||
@ -1660,8 +1655,8 @@ pub trait Iterator {
|
||||
///
|
||||
/// See also [`is_partitioned()`] and [`partition_in_place()`].
|
||||
///
|
||||
/// [`is_partitioned()`]: #method.is_partitioned
|
||||
/// [`partition_in_place()`]: #method.partition_in_place
|
||||
/// [`is_partitioned()`]: Iterator::is_partitioned
|
||||
/// [`partition_in_place()`]: Iterator::partition_in_place
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@ -1715,8 +1710,8 @@ pub trait Iterator {
|
||||
///
|
||||
/// See also [`is_partitioned()`] and [`partition()`].
|
||||
///
|
||||
/// [`is_partitioned()`]: #method.is_partitioned
|
||||
/// [`partition()`]: #method.partition
|
||||
/// [`is_partitioned()`]: Iterator::is_partitioned
|
||||
/// [`partition()`]: Iterator::partition
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@ -1778,8 +1773,8 @@ pub trait Iterator {
|
||||
///
|
||||
/// See also [`partition()`] and [`partition_in_place()`].
|
||||
///
|
||||
/// [`partition()`]: #method.partition
|
||||
/// [`partition_in_place()`]: #method.partition_in_place
|
||||
/// [`partition()`]: Iterator::partition
|
||||
/// [`partition_in_place()`]: Iterator::partition_in_place
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@ -1878,8 +1873,8 @@ pub trait Iterator {
|
||||
/// This can also be thought of as the fallible form of [`for_each()`]
|
||||
/// or as the stateless version of [`try_fold()`].
|
||||
///
|
||||
/// [`for_each()`]: #method.for_each
|
||||
/// [`try_fold()`]: #method.try_fold
|
||||
/// [`for_each()`]: Iterator::for_each
|
||||
/// [`try_fold()`]: Iterator::try_fold
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@ -2005,11 +2000,13 @@ pub trait Iterator {
|
||||
accum
|
||||
}
|
||||
|
||||
/// The same as [`fold()`](#method.fold), but uses the first element in the
|
||||
/// The same as [`fold()`], but uses the first element in the
|
||||
/// iterator as the initial value, folding every subsequent element into it.
|
||||
/// If the iterator is empty, return `None`; otherwise, return the result
|
||||
/// of the fold.
|
||||
///
|
||||
/// [`fold()`]: Iterator::fold
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// Find the maximum value:
|
||||
@ -2607,8 +2604,6 @@ pub trait Iterator {
|
||||
/// This is only possible if the iterator has an end, so `rev()` only
|
||||
/// works on [`DoubleEndedIterator`]s.
|
||||
///
|
||||
/// [`DoubleEndedIterator`]: trait.DoubleEndedIterator.html
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
@ -2639,7 +2634,7 @@ pub trait Iterator {
|
||||
///
|
||||
/// This function is, in some sense, the opposite of [`zip`].
|
||||
///
|
||||
/// [`zip`]: #method.zip
|
||||
/// [`zip`]: Iterator::zip
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@ -2718,7 +2713,7 @@ pub trait Iterator {
|
||||
/// This is useful when you have an iterator over `&T`, but you need an
|
||||
/// iterator over `T`.
|
||||
///
|
||||
/// [`clone`]: crate::clone::Clone::clone
|
||||
/// [`clone`]: Clone::clone
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
@ -3206,7 +3201,7 @@ pub trait Iterator {
|
||||
/// assert!(![0.0, 1.0, f32::NAN].iter().is_sorted_by(|a, b| a.partial_cmp(b)));
|
||||
/// ```
|
||||
///
|
||||
/// [`is_sorted`]: #method.is_sorted
|
||||
/// [`is_sorted`]: Iterator::is_sorted
|
||||
#[unstable(feature = "is_sorted", reason = "new API", issue = "53485")]
|
||||
fn is_sorted_by<F>(mut self, mut compare: F) -> bool
|
||||
where
|
||||
@ -3235,7 +3230,7 @@ pub trait Iterator {
|
||||
/// the elements, as determined by `f`. Apart from that, it's equivalent to [`is_sorted`]; see
|
||||
/// its documentation for more information.
|
||||
///
|
||||
/// [`is_sorted`]: #method.is_sorted
|
||||
/// [`is_sorted`]: Iterator::is_sorted
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
|
||||
Loading…
Reference in New Issue
Block a user