nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-29 18:23:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix linkchecker doc errors

Browse Source 
Also includes small doc fixes.
This commit is contained in:
Lukas Bergdoll 2024-04-17 17:50:05 +02:00
parent 8300f67c6e
commit 88fb5edb65
2 changed files with 12 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
library/alloc/src/slice.rs
View File

@ -193,7 +193,7 @@ impl<T> [T] {
/// The current implementation is based on [driftsort] by Orson Peters and Lukas Bergdoll, which /// The current implementation is based on [driftsort] by Orson Peters and Lukas Bergdoll, which
/// combines the fast average case of quicksort with the fast worst case and partial run /// combines the fast average case of quicksort with the fast worst case and partial run
/// detection of mergesort, achieving linear time on fully sorted and reversed inputs. On inputs /// detection of mergesort, achieving linear time on fully sorted and reversed inputs. On inputs
/// with k distinct elements, the expected time to sort the data is *O(*n* log(*k*))*. /// with k distinct elements, the expected time to sort the data is *O(*n* \* log(*k*))*.
/// ///
/// The auxiliary memory allocation behavior depends on the input length. Short slices are /// The auxiliary memory allocation behavior depends on the input length. Short slices are
/// handled without allocation, medium sized slices allocate `self.len()` and beyond that it /// handled without allocation, medium sized slices allocate `self.len()` and beyond that it
@ -252,7 +252,7 @@ impl<T> [T] {
/// The current implementation is based on [driftsort] by Orson Peters and Lukas Bergdoll, which /// The current implementation is based on [driftsort] by Orson Peters and Lukas Bergdoll, which
/// combines the fast average case of quicksort with the fast worst case and partial run /// combines the fast average case of quicksort with the fast worst case and partial run
/// detection of mergesort, achieving linear time on fully sorted and reversed inputs. On inputs /// detection of mergesort, achieving linear time on fully sorted and reversed inputs. On inputs
/// with k distinct elements, the expected time to sort the data is *O(*n* log(*k*))*. /// with k distinct elements, the expected time to sort the data is *O(*n* \* log(*k*))*.
/// ///
/// The auxiliary memory allocation behavior depends on the input length. Short slices are /// The auxiliary memory allocation behavior depends on the input length. Short slices are
/// handled without allocation, medium sized slices allocate `self.len()` and beyond that it /// handled without allocation, medium sized slices allocate `self.len()` and beyond that it
@ -298,7 +298,7 @@ impl<T> [T] {
/// The current implementation is based on [driftsort] by Orson Peters and Lukas Bergdoll, which /// The current implementation is based on [driftsort] by Orson Peters and Lukas Bergdoll, which
/// combines the fast average case of quicksort with the fast worst case and partial run /// combines the fast average case of quicksort with the fast worst case and partial run
/// detection of mergesort, achieving linear time on fully sorted and reversed inputs. On inputs /// detection of mergesort, achieving linear time on fully sorted and reversed inputs. On inputs
/// with k distinct elements, the expected time to sort the data is *O(*n* log(*k*))*. /// with k distinct elements, the expected time to sort the data is *O(*n* \* log(*k*))*.
/// ///
/// The auxiliary memory allocation behavior depends on the input length. Short slices are /// The auxiliary memory allocation behavior depends on the input length. Short slices are
/// handled without allocation, medium sized slices allocate `self.len()` and beyond that it /// handled without allocation, medium sized slices allocate `self.len()` and beyond that it

18
library/core/src/slice/mod.rs
View File

@ -2893,7 +2893,7 @@ impl<T> [T] {
/// The current implementation is based on [ipnsort] by Lukas Bergdoll and Orson Peters, which /// The current implementation is based on [ipnsort] by Lukas Bergdoll and Orson Peters, which
/// combines the fast average case of quicksort with the fast worst case of heapsort, achieving /// combines the fast average case of quicksort with the fast worst case of heapsort, achieving
/// linear time on fully sorted and reversed inputs. On inputs with k distinct elements, the /// linear time on fully sorted and reversed inputs. On inputs with k distinct elements, the
/// expected time to sort the data is *O(*n* log(*k*))*. /// expected time to sort the data is *O(*n* \* log(*k*))*.
/// ///
/// It is typically faster than stable sorting, except in a few special cases, e.g., when the /// It is typically faster than stable sorting, except in a few special cases, e.g., when the
/// slice is partially sorted. /// slice is partially sorted.
@ -2950,7 +2950,7 @@ impl<T> [T] {
/// The current implementation is based on [ipnsort] by Lukas Bergdoll and Orson Peters, which /// The current implementation is based on [ipnsort] by Lukas Bergdoll and Orson Peters, which
/// combines the fast average case of quicksort with the fast worst case of heapsort, achieving /// combines the fast average case of quicksort with the fast worst case of heapsort, achieving
/// linear time on fully sorted and reversed inputs. On inputs with k distinct elements, the /// linear time on fully sorted and reversed inputs. On inputs with k distinct elements, the
/// expected time to sort the data is *O(*n* log(*k*))*. /// expected time to sort the data is *O(*n* \* log(*k*))*.
/// ///
/// It is typically faster than stable sorting, except in a few special cases, e.g., when the /// It is typically faster than stable sorting, except in a few special cases, e.g., when the
/// slice is partially sorted. /// slice is partially sorted.
@ -2994,7 +2994,7 @@ impl<T> [T] {
/// The current implementation is based on [ipnsort] by Lukas Bergdoll and Orson Peters, which /// The current implementation is based on [ipnsort] by Lukas Bergdoll and Orson Peters, which
/// combines the fast average case of quicksort with the fast worst case of heapsort, achieving /// combines the fast average case of quicksort with the fast worst case of heapsort, achieving
/// linear time on fully sorted and reversed inputs. On inputs with k distinct elements, the /// linear time on fully sorted and reversed inputs. On inputs with k distinct elements, the
/// expected time to sort the data is *O(*n* log(*k*))*. /// expected time to sort the data is *O(*n* \* log(*k*))*.
/// ///
/// It is typically faster than stable sorting, except in a few special cases, e.g., when the /// It is typically faster than stable sorting, except in a few special cases, e.g., when the
/// slice is partially sorted. /// slice is partially sorted.
@ -3042,8 +3042,8 @@ impl<T> [T] {
/// Median of Medians using Tukey's Ninther for pivot selection, which guarantees linear runtime /// Median of Medians using Tukey's Ninther for pivot selection, which guarantees linear runtime
/// for all inputs. /// for all inputs.
/// ///
/// It is typically faster than sorting, except in a few special cases, e.g., when the slice is /// It is typically faster than stable sorting, except in a few special cases, e.g., when the
/// nearly fully sorted, where [`slice::sort`] may be faster. /// slice is nearly fully sorted, where `slice::sort` may be faster.
/// ///
/// [`sort_unstable`]: slice::sort_unstable /// [`sort_unstable`]: slice::sort_unstable
/// ///
@ -3103,8 +3103,8 @@ impl<T> [T] {
/// Median of Medians using Tukey's Ninther for pivot selection, which guarantees linear runtime /// Median of Medians using Tukey's Ninther for pivot selection, which guarantees linear runtime
/// for all inputs. /// for all inputs.
/// ///
/// It is typically faster than sorting, except in a few special cases, e.g., when the slice is /// It is typically faster than stable sorting, except in a few special cases, e.g., when the
/// nearly fully sorted, where [`slice::sort`] may be faster. /// slice is nearly fully sorted, where `slice::sort` may be faster.
/// ///
/// [`sort_unstable`]: slice::sort_unstable /// [`sort_unstable`]: slice::sort_unstable
/// ///
@ -3168,8 +3168,8 @@ impl<T> [T] {
/// Median of Medians using Tukey's Ninther for pivot selection, which guarantees linear runtime /// Median of Medians using Tukey's Ninther for pivot selection, which guarantees linear runtime
/// for all inputs. /// for all inputs.
/// ///
/// It is typically faster than sorting, except in a few special cases, e.g., when the slice is /// It is typically faster than stable sorting, except in a few special cases, e.g., when the
/// nearly fully sorted, where [`slice::sort`] may be faster. /// slice is nearly fully sorted, where `slice::sort` may be faster.
/// ///
/// [`sort_unstable`]: slice::sort_unstable /// [`sort_unstable`]: slice::sort_unstable
/// ///