Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Move to intra-doc links for library/core/src/iter/traits/iterator.rs #76238

Merged
merged 6 commits into from
Sep 3, 2020
Merged

Move to intra-doc links for library/core/src/iter/traits/iterator.rs #76238

Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
07cd4c8
Use intra-doc links
denisvasilik Sep 1, 2020
7cf0fe1
Apply suggestions from review
denisvasilik Sep 2, 2020
1a438bb
Revert module level documentation link
denisvasilik Sep 2, 2020
3a03589
Revert link removal
denisvasilik Sep 2, 2020
83143a1
Revert link removal of
denisvasilik Sep 2, 2020
89e7fb3
Revert link removal of Some(T)
denisvasilik Sep 2, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
75 changes: 35 additions & 40 deletions library/core/src/iter/traits/iterator.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -22,8 +22,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
jyn514 marked this conversation as resolved.
Show resolved Hide resolved
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_on_unimplemented(
on(
Expand Down Expand Up @@ -212,7 +212,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
///
Expand Down Expand Up @@ -449,9 +449,7 @@ pub trait Iterator {
/// }
/// ```
///
/// [`once`]: fn.once.html
/// [`Iterator`]: trait.Iterator.html
/// [`IntoIterator`]: trait.IntoIterator.html
/// [`once`]: crate::iter::once
jyn514 marked this conversation as resolved.
Show resolved Hide resolved
/// [`OsStr`]: ../../std/ffi/struct.OsStr.html
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
Expand Down Expand Up @@ -496,9 +494,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];
Expand Down Expand Up @@ -530,8 +525,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>
Expand Down Expand Up @@ -734,8 +729,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.
///
Expand Down Expand Up @@ -802,7 +797,7 @@ pub trait Iterator {
///
/// [`usize`]: type@usize
/// [`usize::MAX`]: crate::usize::MAX
/// [`zip`]: #method.zip
/// [`zip`]: Iterator::zip
///
/// # Examples
///
Expand Down Expand Up @@ -837,8 +832,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
///
Expand Down Expand Up @@ -876,7 +871,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
Expand Down Expand Up @@ -1043,8 +1038,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];
Expand Down Expand Up @@ -1104,7 +1099,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>
Expand Down Expand Up @@ -1190,7 +1185,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
Expand Down Expand Up @@ -1246,8 +1241,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
///
Expand Down Expand Up @@ -1333,7 +1328,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>
Expand Down Expand Up @@ -1640,7 +1635,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]
Expand All @@ -1661,8 +1656,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
///
Expand Down Expand Up @@ -1716,8 +1711,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
///
Expand Down Expand Up @@ -1779,8 +1774,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
///
Expand Down Expand Up @@ -1879,8 +1874,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
///
Expand Down Expand Up @@ -2006,11 +2001,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:
Expand Down Expand Up @@ -2602,8 +2599,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
///
/// ```
Expand Down Expand Up @@ -2634,7 +2629,7 @@ pub trait Iterator {
///
/// This function is, in some sense, the opposite of [`zip`].
///
/// [`zip`]: #method.zip
/// [`zip`]: Iterator::zip
///
/// # Examples
///
Expand Down Expand Up @@ -2713,7 +2708,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
///
Expand Down Expand Up @@ -3197,7 +3192,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
Expand Down Expand Up @@ -3226,7 +3221,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
///
Expand Down