@@ -370,6 +370,8 @@ mod prim_unit { }
370
370
//
371
371
/// Raw, unsafe pointers, `*const T`, and `*mut T`.
372
372
///
373
+ /// *[See also the `std::ptr` module](ptr/index.html).*
374
+ ///
373
375
/// Working with raw pointers in Rust is uncommon,
374
376
/// typically limited to a few patterns.
375
377
///
@@ -444,8 +446,6 @@ mod prim_unit { }
444
446
/// but C APIs hand out a lot of pointers generally, so are a common source
445
447
/// of raw pointers in Rust.
446
448
///
447
- /// *[See also the `std::ptr` module](ptr/index.html).*
448
- ///
449
449
/// [`null`]: ../std/ptr/fn.null.html
450
450
/// [`null_mut`]: ../std/ptr/fn.null_mut.html
451
451
/// [`is_null`]: ../std/primitive.pointer.html#method.is_null
@@ -563,6 +563,8 @@ mod prim_array { }
563
563
//
564
564
/// A dynamically-sized view into a contiguous sequence, `[T]`.
565
565
///
566
+ /// *[See also the `std::slice` module](slice/index.html).*
567
+ ///
566
568
/// Slices are a view into a block of memory represented as a pointer and a
567
569
/// length.
568
570
///
@@ -585,24 +587,20 @@ mod prim_array { }
585
587
/// assert_eq!(x, &[1, 7, 3]);
586
588
/// ```
587
589
///
588
- /// *[See also the `std::slice` module](slice/index.html).*
589
- ///
590
590
#[ stable( feature = "rust1" , since = "1.0.0" ) ]
591
591
mod prim_slice { }
592
592
593
593
#[ doc( primitive = "str" ) ]
594
594
//
595
595
/// String slices.
596
596
///
597
+ /// *[See also the `std::str` module](str/index.html).*
598
+ ///
597
599
/// The `str` type, also called a 'string slice', is the most primitive string
598
600
/// type. It is usually seen in its borrowed form, `&str`. It is also the type
599
601
/// of string literals, `&'static str`.
600
602
///
601
- /// Strings slices are always valid UTF-8.
602
- ///
603
- /// This documentation describes a number of methods and trait implementations
604
- /// on the `str` type. For technical reasons, there is additional, separate
605
- /// documentation in the [`std::str`](str/index.html) module as well.
603
+ /// String slices are always valid UTF-8.
606
604
///
607
605
/// # Examples
608
606
///
@@ -862,23 +860,23 @@ mod prim_u128 { }
862
860
//
863
861
/// The pointer-sized signed integer type.
864
862
///
863
+ /// *[See also the `std::isize` module](isize/index.html).*
864
+ ///
865
865
/// The size of this primitive is how many bytes it takes to reference any
866
866
/// location in memory. For example, on a 32 bit target, this is 4 bytes
867
867
/// and on a 64 bit target, this is 8 bytes.
868
- ///
869
- /// *[See also the `std::isize` module](isize/index.html).*
870
868
#[ stable( feature = "rust1" , since = "1.0.0" ) ]
871
869
mod prim_isize { }
872
870
873
871
#[ doc( primitive = "usize" ) ]
874
872
//
875
873
/// The pointer-sized unsigned integer type.
876
874
///
875
+ /// *[See also the `std::usize` module](usize/index.html).*
876
+ ///
877
877
/// The size of this primitive is how many bytes it takes to reference any
878
878
/// location in memory. For example, on a 32 bit target, this is 4 bytes
879
879
/// and on a 64 bit target, this is 8 bytes.
880
- ///
881
- /// *[See also the `std::usize` module](usize/index.html).*
882
880
#[ stable( feature = "rust1" , since = "1.0.0" ) ]
883
881
mod prim_usize { }
884
882
0 commit comments