Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
int
Rust
提交
5719d221
R
Rust
项目概览
int
/
Rust
接近 1 年 前同步成功
通知
1
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
DevOps
流水线
流水线任务
计划
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
R
Rust
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
DevOps
DevOps
流水线
流水线任务
计划
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
流水线任务
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
5719d221
编写于
8月 29, 2021
作者:
P
patrick-gu
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
Add links in docs for some primitive types
上级
926f0699
变更
4
隐藏空白更改
内联
并排
Showing
4 changed file
with
85 addition
and
72 deletion
+85
-72
library/core/src/array/mod.rs
library/core/src/array/mod.rs
+4
-4
library/core/src/bool.rs
library/core/src/bool.rs
+2
-2
library/core/src/char/methods.rs
library/core/src/char/methods.rs
+41
-37
library/std/src/primitive_docs.rs
library/std/src/primitive_docs.rs
+38
-29
未找到文件。
library/core/src/array/mod.rs
浏览文件 @
5719d221
...
...
@@ -310,9 +310,9 @@ fn index_mut(&mut self, index: I) -> &mut Self::Output {
/// on large arrays or check the emitted code. Also try to avoid chained
/// maps (e.g. `arr.map(...).map(...)`).
///
/// In many cases, you can instead use [`Iterator::map`] by calling
`.iter()`
/// or
`.into_iter()` on your array. `[T; N]::map` is only necessary if you
/// really need a new array of the same size as the result. Rust's lazy
/// In many cases, you can instead use [`Iterator::map`] by calling
[`.iter()`](slice::iter)
/// or
[`.into_iter()`](IntoIterator::into_iter) on your array. `[T; N]::map` is only necessary
///
if you
really need a new array of the same size as the result. Rust's lazy
/// iterators tend to get optimized very well.
///
///
...
...
@@ -396,7 +396,7 @@ pub fn as_mut_slice(&mut self) -> &mut [T] {
///
/// This method is particularly useful if combined with other methods, like
/// [`map`](#method.map). This way, you can avoid moving the original
/// array if its elements are not
`Copy`
.
/// array if its elements are not
[`Copy`]
.
///
/// ```
/// #![feature(array_methods)]
...
...
library/core/src/bool.rs
浏览文件 @
5719d221
...
...
@@ -2,7 +2,7 @@
#[lang
=
"bool"
]
impl
bool
{
/// Returns
`Some(t)` if the `bool` is `true`, or `None`
otherwise.
/// Returns
<code>[Some]\(t)</code> if the `bool` is [`true`](keyword.true.html), or [`None`]
otherwise.
///
/// # Examples
///
...
...
@@ -18,7 +18,7 @@ pub fn then_some<T>(self, t: T) -> Option<T> {
if
self
{
Some
(
t
)
}
else
{
None
}
}
/// Returns
`Some(f())` if the `bool` is `true`, or `None`
otherwise.
/// Returns
<code>[Some]\(f())</code> if the `bool` is [`true`](keyword.true.html), or [`None`]
otherwise.
///
/// # Examples
///
...
...
library/core/src/char/methods.rs
浏览文件 @
5719d221
...
...
@@ -29,11 +29,11 @@ impl char {
pub
const
REPLACEMENT_CHARACTER
:
char
=
'\
u
{
FFFD
}
'
;
/// The version of [Unicode](https://www.unicode.org/) that the Unicode parts of
/// `char` and
`str`
methods are based on.
/// `char` and
[`str`]
methods are based on.
///
/// New versions of Unicode are released regularly and subsequently all methods
/// in the standard library depending on Unicode are updated. Therefore the
/// behavior of some `char` and
`str`
methods and the value of this constant
/// behavior of some `char` and
[`str`]
methods and the value of this constant
/// changes over time. This is *not* considered to be a breaking change.
///
/// The version numbering scheme is explained in
...
...
@@ -42,7 +42,7 @@ impl char {
pub
const
UNICODE_VERSION
:
(
u8
,
u8
,
u8
)
=
crate
::
unicode
::
UNICODE_VERSION
;
/// Creates an iterator over the UTF-16 encoded code points in `iter`,
/// returning unpaired surrogates as
`Err`
s.
/// returning unpaired surrogates as
[`Err`]
s.
///
/// # Examples
///
...
...
@@ -70,7 +70,7 @@ impl char {
/// );
/// ```
///
/// A lossy decoder can be obtained by replacing
`Err`
results with the replacement character:
/// A lossy decoder can be obtained by replacing
[`Err`]
results with the replacement character:
///
/// ```
/// use std::char::{decode_utf16, REPLACEMENT_CHARACTER};
...
...
@@ -93,10 +93,10 @@ pub fn decode_utf16<I: IntoIterator<Item = u16>>(iter: I) -> DecodeUtf16<I::Into
super
::
decode
::
decode_utf16
(
iter
)
}
/// Converts a
`u32`
to a `char`.
/// Converts a
[`u32`]
to a `char`.
///
/// Note that all `char`s are valid [`u32`]s, and can be cast to one with
///
`as`
:
///
[`as`](keyword.as.html)
:
///
/// ```
/// let c = '💯';
...
...
@@ -106,7 +106,7 @@ pub fn decode_utf16<I: IntoIterator<Item = u16>>(iter: I) -> DecodeUtf16<I::Into
/// ```
///
/// However, the reverse is not true: not all valid [`u32`]s are valid
/// `char`s. `from_u32()` will return
`None`
if the input is not a valid value
/// `char`s. `from_u32()` will return
[`None`]
if the input is not a valid value
/// for a `char`.
///
/// For an unsafe version of this function which ignores these checks, see
...
...
@@ -126,7 +126,7 @@ pub fn decode_utf16<I: IntoIterator<Item = u16>>(iter: I) -> DecodeUtf16<I::Into
/// assert_eq!(Some('❤'), c);
/// ```
///
/// Returning
`None`
when the input is not a valid `char`:
/// Returning
[`None`]
when the input is not a valid `char`:
///
/// ```
/// use std::char;
...
...
@@ -141,7 +141,7 @@ pub fn from_u32(i: u32) -> Option<char> {
super
::
convert
::
from_u32
(
i
)
}
/// Converts a
`u32`
to a `char`, ignoring validity.
/// Converts a
[`u32`]
to a `char`, ignoring validity.
///
/// Note that all `char`s are valid [`u32`]s, and can be cast to one with
/// `as`:
...
...
@@ -190,7 +190,7 @@ pub unsafe fn from_u32_unchecked(i: u32) -> char {
/// sixteen, hexadecimal, to give some common values. Arbitrary
/// radices are supported.
///
/// `from_digit()` will return
`None`
if the input is not a digit in
/// `from_digit()` will return
[`None`]
if the input is not a digit in
/// the given radix.
///
/// # Panics
...
...
@@ -214,7 +214,7 @@ pub unsafe fn from_u32_unchecked(i: u32) -> char {
/// assert_eq!(Some('b'), c);
/// ```
///
/// Returning
`None`
when the input is not a digit:
/// Returning
[`None`]
when the input is not a digit:
///
/// ```
/// use std::char;
...
...
@@ -299,7 +299,7 @@ pub fn is_digit(self, radix: u32) -> bool {
///
/// # Errors
///
/// Returns
`None`
if the `char` does not refer to a digit in the given radix.
/// Returns
[`None`]
if the `char` does not refer to a digit in the given radix.
///
/// # Panics
///
...
...
@@ -360,7 +360,7 @@ pub fn to_digit(self, radix: u32) -> Option<u32> {
/// println!();
/// ```
///
/// Using
`println!`
directly:
/// Using
[`println!`](macro.println.html)
directly:
///
/// ```
/// println!("{}", '❤'.escape_unicode());
...
...
@@ -372,7 +372,7 @@ pub fn to_digit(self, radix: u32) -> Option<u32> {
/// println!("\\u{{2764}}");
/// ```
///
/// Using
`to_string`
:
/// Using
[`to_string`](string/trait.ToString.html#tymethod.to_string)
:
///
/// ```
/// assert_eq!('❤'.escape_unicode().to_string(), "\\u{2764}");
...
...
@@ -422,8 +422,8 @@ pub(crate) fn escape_debug_ext(self, args: EscapeDebugExtArgs) -> EscapeDebug {
/// Returns an iterator that yields the literal escape code of a character
/// as `char`s.
///
/// This will escape the characters similar to the
`Debug`
implementations
/// of
`str`
or `char`.
/// This will escape the characters similar to the
[`Debug`](core::fmt::Debug)
implementations
/// of
[`str`]
or `char`.
///
/// # Examples
///
...
...
@@ -436,7 +436,7 @@ pub(crate) fn escape_debug_ext(self, args: EscapeDebugExtArgs) -> EscapeDebug {
/// println!();
/// ```
///
/// Using
`println!`
directly:
/// Using
[`println!`](macro.println.html)
directly:
///
/// ```
/// println!("{}", '\n'.escape_debug());
...
...
@@ -448,7 +448,7 @@ pub(crate) fn escape_debug_ext(self, args: EscapeDebugExtArgs) -> EscapeDebug {
/// println!("\\n");
/// ```
///
/// Using
`to_string`
:
/// Using
[`to_string`](string/trait.ToString.html#tymethod.to_string)
:
///
/// ```
/// assert_eq!('\n'.escape_debug().to_string(), "\\n");
...
...
@@ -490,7 +490,7 @@ pub fn escape_debug(self) -> EscapeDebug {
/// println!();
/// ```
///
/// Using
`println!`
directly:
/// Using
[`println!`](macro.println.html)
directly:
///
/// ```
/// println!("{}", '"'.escape_default());
...
...
@@ -502,7 +502,7 @@ pub fn escape_debug(self) -> EscapeDebug {
/// println!("\\\"");
/// ```
///
/// Using
`to_string`
:
/// Using
[`to_string`](string/trait.ToString.html#tymethod.to_string)
:
///
/// ```
/// assert_eq!('"'.escape_default().to_string(), "\\\"");
...
...
@@ -543,8 +543,9 @@ pub fn escape_default(self) -> EscapeDefault {
/// assert_eq!(len, 4);
/// ```
///
/// The `&str` type guarantees that its contents are UTF-8, and so we can compare the length it
/// would take if each code point was represented as a `char` vs in the `&str` itself:
/// The <code>[&](reference)[str]</code> type guarantees that its contents are UTF-8,
/// and so we can compare the length it would take if each code point was represented
/// as a `char` vs in the <code>[&](reference)[str]</code> itself:
///
/// ```
/// // as chars
...
...
@@ -637,7 +638,7 @@ pub fn encode_utf8(self, dst: &mut [u8]) -> &mut str {
unsafe
{
from_utf8_unchecked_mut
(
encode_utf8_raw
(
self
as
u32
,
dst
))
}
}
/// Encodes this character as UTF-16 into the provided
`u16`
buffer,
/// Encodes this character as UTF-16 into the provided
[`u16`]
buffer,
/// and then returns the subslice of the buffer that contains the encoded character.
///
/// # Panics
...
...
@@ -647,7 +648,7 @@ pub fn encode_utf8(self, dst: &mut [u8]) -> &mut str {
///
/// # Examples
///
/// In both of these examples, '𝕊' takes two
`u16`
s to encode.
/// In both of these examples, '𝕊' takes two
[`u16`]
s to encode.
///
/// ```
/// let mut b = [0; 2];
...
...
@@ -671,7 +672,7 @@ pub fn encode_utf16(self, dst: &mut [u16]) -> &mut [u16] {
encode_utf16_raw
(
self
as
u32
,
dst
)
}
/// Returns
`true`
if this `char` has the `Alphabetic` property.
/// Returns
[`true`](keyword.true.html)
if this `char` has the `Alphabetic` property.
///
/// `Alphabetic` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and
/// specified in the [Unicode Character Database][ucd] [`DerivedCoreProperties.txt`].
...
...
@@ -701,7 +702,7 @@ pub fn is_alphabetic(self) -> bool {
}
}
/// Returns
`true`
if this `char` has the `Lowercase` property.
/// Returns
[`true`](keyword.true.html)
if this `char` has the `Lowercase` property.
///
/// `Lowercase` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and
/// specified in the [Unicode Character Database][ucd] [`DerivedCoreProperties.txt`].
...
...
@@ -733,7 +734,7 @@ pub fn is_lowercase(self) -> bool {
}
}
/// Returns
`true`
if this `char` has the `Uppercase` property.
/// Returns
[`true`](keyword.true.html)
if this `char` has the `Uppercase` property.
///
/// `Uppercase` is described in Chapter 4 (Character Properties) of the [Unicode Standard] and
/// specified in the [Unicode Character Database][ucd] [`DerivedCoreProperties.txt`].
...
...
@@ -765,7 +766,7 @@ pub fn is_uppercase(self) -> bool {
}
}
/// Returns
`true`
if this `char` has the `White_Space` property.
/// Returns
[`true`](keyword.true.html)
if this `char` has the `White_Space` property.
///
/// `White_Space` is specified in the [Unicode Character Database][ucd] [`PropList.txt`].
///
...
...
@@ -793,7 +794,8 @@ pub fn is_whitespace(self) -> bool {
}
}
/// Returns `true` if this `char` satisfies either [`is_alphabetic()`] or [`is_numeric()`].
/// Returns [`true`](keyword.true.html) if this `char` satisfies either
/// [`is_alphabetic()`] or [`is_numeric()`].
///
/// [`is_alphabetic()`]: #method.is_alphabetic
/// [`is_numeric()`]: #method.is_numeric
...
...
@@ -818,7 +820,7 @@ pub fn is_alphanumeric(self) -> bool {
self
.is_alphabetic
()
||
self
.is_numeric
()
}
/// Returns
`true`
if this `char` has the general category for control codes.
/// Returns
[`true`](keyword.true.html)
if this `char` has the general category for control codes.
///
/// Control codes (code points with the general category of `Cc`) are described in Chapter 4
/// (Character Properties) of the [Unicode Standard] and specified in the [Unicode Character
...
...
@@ -843,7 +845,7 @@ pub fn is_control(self) -> bool {
unicode
::
Cc
(
self
)
}
/// Returns
`true`
if this `char` has the `Grapheme_Extend` property.
/// Returns
[`true`](keyword.true.html)
if this `char` has the `Grapheme_Extend` property.
///
/// `Grapheme_Extend` is described in [Unicode Standard Annex #29 (Unicode Text
/// Segmentation)][uax29] and specified in the [Unicode Character Database][ucd]
...
...
@@ -857,7 +859,7 @@ pub(crate) fn is_grapheme_extended(self) -> bool {
unicode
::
Grapheme_Extend
(
self
)
}
/// Returns
`true`
if this `char` has one of the general categories for numbers.
/// Returns
[`true`](keyword.true.html)
if this `char` has one of the general categories for numbers.
///
/// The general categories for numbers (`Nd` for decimal digits, `Nl` for letter-like numeric
/// characters, and `No` for other numeric characters) are specified in the [Unicode Character
...
...
@@ -925,7 +927,7 @@ pub fn is_numeric(self) -> bool {
/// println!();
/// ```
///
/// Using
`println!`
directly:
/// Using
[`println!`](macro.println.html)
directly:
///
/// ```
/// println!("{}", 'İ'.to_lowercase());
...
...
@@ -937,7 +939,7 @@ pub fn is_numeric(self) -> bool {
/// println!("i\u{307}");
/// ```
///
/// Using
`to_string`
:
/// Using
[`to_string`](string/trait.ToString.html#tymethod.to_string)
:
///
/// ```
/// assert_eq!('C'.to_lowercase().to_string(), "c");
...
...
@@ -990,7 +992,7 @@ pub fn to_lowercase(self) -> ToLowercase {
/// println!();
/// ```
///
/// Using
`println!`
directly:
/// Using
[`println!`](macro.println.html)
directly:
///
/// ```
/// println!("{}", 'ß'.to_uppercase());
...
...
@@ -1002,7 +1004,7 @@ pub fn to_lowercase(self) -> ToLowercase {
/// println!("SS");
/// ```
///
/// Using
`to_string`
:
/// Using
[`to_string`](string/trait.ToString.html#tymethod.to_string)
:
///
/// ```
/// assert_eq!('c'.to_uppercase().to_string(), "C");
...
...
@@ -1131,7 +1133,7 @@ pub const fn to_ascii_lowercase(&self) -> char {
/// Checks that two values are an ASCII case-insensitive match.
///
/// Equivalent to
`to_ascii_lowercase(a) == to_ascii_lowercase(b)`
.
/// Equivalent to
<code>[to_ascii_lowercase]\(a) == [to_ascii_lowercase]\(b)</code>
.
///
/// # Examples
///
...
...
@@ -1144,6 +1146,8 @@ pub const fn to_ascii_lowercase(&self) -> char {
/// assert!(upper_a.eq_ignore_ascii_case(&upper_a));
/// assert!(!upper_a.eq_ignore_ascii_case(&lower_z));
/// ```
///
/// [to_ascii_lowercase]: #method.to_ascii_lowercase
#[stable(feature
=
"ascii_methods_on_intrinsics"
,
since
=
"1.23.0"
)]
#[rustc_const_stable(feature
=
"const_ascii_methods_on_intrinsics"
,
since
=
"1.52.0"
)]
#[inline]
...
...
library/std/src/primitive_docs.rs
浏览文件 @
5719d221
...
...
@@ -3,16 +3,16 @@
#[doc(alias
=
"false"
)]
/// The boolean type.
///
/// The `bool` represents a value, which could only be either
`true` or `false`
. If you cast
/// a `bool` into an integer,
`true` will be 1 and `false`
will be 0.
/// The `bool` represents a value, which could only be either
[`true`] or [`false`]
. If you cast
/// a `bool` into an integer,
[`true`] will be 1 and [`false`]
will be 0.
///
/// # Basic usage
///
/// `bool` implements various traits, such as [`BitAnd`], [`BitOr`], [`Not`], etc.,
/// which allow us to perform boolean operations using `&`, `|` and `!`.
///
///
`if`
requires a `bool` value as its conditional. [`assert!`], which is an
/// important macro in testing, checks whether an expression is
`true`
and panics
///
[`if`]
requires a `bool` value as its conditional. [`assert!`], which is an
/// important macro in testing, checks whether an expression is
[`true`]
and panics
/// if it isn't.
///
/// ```
...
...
@@ -20,9 +20,12 @@
/// assert!(!bool_val);
/// ```
///
/// [`true`]: keyword.true.html
/// [`false`]: keyword.false.html
/// [`BitAnd`]: ops::BitAnd
/// [`BitOr`]: ops::BitOr
/// [`Not`]: ops::Not
/// [`if`]: keyword.if.html
///
/// # Examples
///
...
...
@@ -574,11 +577,11 @@ mod prim_pointer {}
///
/// # Editions
///
/// Prior to Rust 1.53, arrays did not implement
`IntoIterator`
by value, so the method call
///
`array.into_iter()` auto-referenced into a slice iterator. Right now, the old behavior
///
is preserved in the 2015 and 2018 editions of Rust for compatibility, ignoring
///
`IntoIterator` by value. In the future, the behavior on the 2015 and 2018 edition
/// might be made consistent to the behavior of later editions.
/// Prior to Rust 1.53, arrays did not implement
[`IntoIterator`]
by value, so the method call
///
<code>array.[into_iter()]</code> auto-referenced into a slice iterator.
///
Right now, the old behavior is preserved in the 2015 and 2018 editions of Rust for
///
compatibility, ignoring [`IntoIterator`] by value. In the future, the behavior on the 2015 and
///
2018 edition
might be made consistent to the behavior of later editions.
///
/// ```rust,edition2018
/// # #![allow(array_into_iter)] // override our `deny(warnings)`
...
...
@@ -604,8 +607,9 @@ mod prim_pointer {}
/// }
/// ```
///
/// Starting in the 2021 edition, `array.into_iter()` will use `IntoIterator` normally to iterate
/// by value, and `iter()` should be used to iterate by reference like previous editions.
/// Starting in the 2021 edition, <code>array.[into_iter()]</code> will use [`IntoIterator`]
/// normally to iterate by value, and [`iter()`](slice::iter) should be used to iterate by
/// reference like previous editions.
///
/// ```rust,edition2021,ignore
/// # // FIXME: ignored because 2021 testing is still unstable
...
...
@@ -624,16 +628,16 @@ mod prim_pointer {}
/// }
/// ```
///
/// Future language versions might start treating the
`array.into_iter()`
/// Future language versions might start treating the
<code>array.[into_iter()]</code>
/// syntax on editions 2015 and 2018 the same as on edition 2021. So code using
/// those older editions should still be written with this change in mind, to
/// prevent breakage in the future. The safest way to accomplish this is to
/// avoid the
`into_iter` syntax on those editions. If an edition update is not
/// viable/desired, there are multiple alternatives:
/// * use
`iter`
, equivalent to the old behavior, creating references
/// avoid the
[`into_iter`](IntoIterator::into_iter) syntax on those editions.
///
If an edition update is not
viable/desired, there are multiple alternatives:
/// * use
[`iter`](slice::iter)
, equivalent to the old behavior, creating references
/// * use [`array::IntoIter`], equivalent to the post-2021 behavior (Rust 1.51+)
/// * replace
`for ... in array.into_iter() {` with `for ... in array {`,
/// equivalent to the post-2021 behavior (Rust 1.53+)
/// * replace
<code>[for] ... [in] array.[into_iter()] {</code>` with
///
<code>[for] ... [in] array {</code>,
equivalent to the post-2021 behavior (Rust 1.53+)
///
/// ```rust,edition2018
/// use std::array::IntoIter;
...
...
@@ -672,6 +676,9 @@ mod prim_pointer {}
/// [`Borrow`]: borrow::Borrow
/// [`BorrowMut`]: borrow::BorrowMut
/// [slice pattern]: ../reference/patterns.html#slice-patterns
/// [into_iter()]: IntoIterator::into_iter
/// [for]: keyword.for.html
/// [in]: keyword.in.html
#[stable(feature
=
"rust1"
,
since
=
"1.0.0"
)]
mod
prim_array
{}
...
...
@@ -829,7 +836,7 @@ mod prim_str {}
/// ```
///
/// The sequential nature of the tuple applies to its implementations of various
/// traits.
For example, in `PartialOrd` and `Ord`
, the elements are compared
/// traits.
For example, in [`PartialOrd`] and [`Ord`]
, the elements are compared
/// sequentially until the first non-equal set is found.
///
/// For more about tuples, see [the book](../book/ch03-02-data-types.html#the-tuple-type).
...
...
@@ -1033,14 +1040,16 @@ mod prim_usize {}
/// References, both shared and mutable.
///
/// A reference represents a borrow of some owned value. You can get one by using the `&` or `&mut`
/// operators on a value, or by using a `ref` or `ref mut` pattern.
/// operators on a value, or by using a [`ref`](keyword.ref.html) or
/// <code>[ref](keyword.ref.html) [mut](keyword.mut.html)</code> pattern.
///
/// For those familiar with pointers, a reference is just a pointer that is assumed to be
/// aligned, not null, and pointing to memory containing a valid value of `T` - for example,
/// `&bool` can only point to an allocation containing the integer values `1` (`true`) or `0`
/// (`false`), but creating a `&bool` that points to an allocation containing
/// the value `3` causes undefined behaviour.
/// In fact, `Option<&T>` has the same memory representation as a
/// <code>&[bool]</code> can only point to an allocation containing the integer values `1`
/// ([`true`](keyword.true.html)) or `0` ([`false`](keyword.false.html)), but creating a
/// <code>&[bool]</code> that points to an allocation containing the value `3` causes
/// undefined behaviour.
/// In fact, <code>[Option]\<&T></code> has the same memory representation as a
/// nullable but aligned pointer, and can be passed across FFI boundaries as such.
///
/// In most cases, references can be used much like the original value. Field access, method
...
...
@@ -1088,7 +1097,7 @@ mod prim_usize {}
/// The following traits are implemented for all `&T`, regardless of the type of its referent:
///
/// * [`Copy`]
/// * [`Clone`] \(Note that this will not defer to `T`'s
`Clone`
implementation if it exists!)
/// * [`Clone`] \(Note that this will not defer to `T`'s
[`Clone`]
implementation if it exists!)
/// * [`Deref`]
/// * [`Borrow`]
/// * [`Pointer`]
...
...
@@ -1097,7 +1106,7 @@ mod prim_usize {}
/// [`Borrow`]: borrow::Borrow
/// [`Pointer`]: fmt::Pointer
///
/// `&mut T` references get all of the above except
`Copy` and `Clone`
(to prevent creating
/// `&mut T` references get all of the above except
[`Copy`] and [`Clone`]
(to prevent creating
/// multiple simultaneous mutable borrows), plus the following, regardless of the type of its
/// referent:
///
...
...
@@ -1125,18 +1134,18 @@ mod prim_usize {}
/// [`Hash`]: hash::Hash
/// [`ToSocketAddrs`]: net::ToSocketAddrs
///
/// `&mut T` references get all of the above except
`ToSocketAddrs`
, plus the following, if `T`
/// `&mut T` references get all of the above except
[`ToSocketAddrs`]
, plus the following, if `T`
/// implements that trait:
///
/// * [`AsMut`]
/// * [`FnMut`] \(in addition, `&mut T` references get [`FnOnce`] if
`T: FnMut`
)
/// * [`FnMut`] \(in addition, `&mut T` references get [`FnOnce`] if
<code>T: [FnMut]</code>
)
/// * [`fmt::Write`]
/// * [`Iterator`]
/// * [`DoubleEndedIterator`]
/// * [`ExactSizeIterator`]
/// * [`FusedIterator`]
/// * [`TrustedLen`]
/// * [`Send`] \(note that `&T` references only get
`Send` if `T: Sync`
)
/// * [`Send`] \(note that `&T` references only get
[`Send`] if <code>T: [Sync]</code>
)
/// * [`io::Write`]
/// * [`Read`]
/// * [`Seek`]
...
...
@@ -1168,7 +1177,7 @@ mod prim_ref {}
/// Function pointers are pointers that point to *code*, not data. They can be called
/// just like functions. Like references, function pointers are, among other things, assumed to
/// not be null, so if you want to pass a function pointer over FFI and be able to accommodate null
/// pointers, make your type
`Option<fn()>`
with your required signature.
/// pointers, make your type
<code>[Option]\<fn()></code>
with your required signature.
///
/// ### Safety
///
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录