Enum alloc::borrow::Cow

1.0.0 · source ·
pub enum Cow<'a, B>where
    B: ToOwned + ?Sized + 'a,{
    Borrowed(&'a B),
    Owned(<B as ToOwned>::Owned),
}
Expand description

写时克隆智能指针。

Cow 类型是一种智能指针,提供了写时克隆功能:它可以封装并提供对借用数据的不可变访问,并在需要可变的或所有权时懒惰地克隆数据。

该类型旨在通过 Borrow trait 处理常规借用数据。

Cow 实现了 Deref,这意味着您可以直接在它包含的数据上调用非可变方法。 如果需要进行可变的,则 to_mut 将获得一个拥有值的变量引用,必要时进行克隆。

如果需要引用计数指针,请注意 Rc::make_mutArc::make_mut 也可以提供写时克隆功能。

Examples

use std::borrow::Cow;

fn abs_all(input: &mut Cow<'_, [i32]>) {
    for i in 0..input.len() {
        let v = input[i];
        if v < 0 {
            // 如果尚未拥有,则克隆到 vector 中。
            input.to_mut()[i] = -v;
        }
    }
}

// 因为 `input` 不需要可变的,所以不会发生克隆。
let slice = [0, 1, 2];
let mut input = Cow::from(&slice[..]);
abs_all(&mut input);

// 发生克隆是因为需要对 `input` 进行可变的。
let slice = [-1, 0, 1];
let mut input = Cow::from(&slice[..]);
abs_all(&mut input);

// 因为 `input` 已被拥有,所以不会发生克隆。
let mut input = Cow::from(vec![-1, 0, 1]);
abs_all(&mut input);
Run

另一个示例显示如何将 Cow 保留在结构体中:

use std::borrow::Cow;

struct Items<'a, X> where [X]: ToOwned<Owned = Vec<X>> {
    values: Cow<'a, [X]>,
}

impl<'a, X: Clone + 'a> Items<'a, X> where [X]: ToOwned<Owned = Vec<X>> {
    fn new(v: Cow<'a, [X]>) -> Self {
        Items { values: v }
    }
}

// 根据切片的借用值创建容器
let readonly = [1, 2];
let borrowed = Items::new((&readonly[..]).into());
match borrowed {
    Items { values: Cow::Borrowed(b) } => println!("borrowed {b:?}"),
    _ => panic!("expect borrowed value"),
}

let mut clone_on_write = borrowed;
// 将切片中的数据可变的为拥有的 vec,并在顶部推入新值
clone_on_write.values.to_mut().push(3);
println!("clone_on_write = {:?}", clone_on_write.values);

// 数据被可变的。让我们来看看。
match clone_on_write {
    Items { values: Cow::Owned(_) } => println!("clone_on_write contains owned data"),
    _ => panic!("expect owned data"),
}
Run

Variants§

§

Borrowed(&'a B)

借用的数据。

§

Owned(<B as ToOwned>::Owned)

拥有的数据。

Implementations§

source§

impl<B: ?Sized + ToOwned> Cow<'_, B>

const: unstable · source

pub fn is_borrowed(&self) -> bool

🔬This is a nightly-only experimental API. (cow_is_borrowed #65143)

如果借用了数据 (即 to_mut 需要其他工作),则返回 true。

Examples
#![feature(cow_is_borrowed)]
use std::borrow::Cow;

let cow = Cow::Borrowed("moo");
assert!(cow.is_borrowed());

let bull: Cow<'_, str> = Cow::Owned("...moo?".to_string());
assert!(!bull.is_borrowed());
Run
const: unstable · source

pub fn is_owned(&self) -> bool

🔬This is a nightly-only experimental API. (cow_is_borrowed #65143)

如果数据已拥有,即 to_mut 为无操作,则返回 true。

Examples
#![feature(cow_is_borrowed)]
use std::borrow::Cow;

let cow: Cow<'_, str> = Cow::Owned("moo".to_string());
assert!(cow.is_owned());

let bull = Cow::Borrowed("...moo?");
assert!(!bull.is_owned());
Run
source

pub fn to_mut(&mut self) -> &mut <B as ToOwned>::Owned

获取对数据拥有形式的可变引用。

如果数据尚未拥有,则克隆数据

Examples
use std::borrow::Cow;

let mut cow = Cow::Borrowed("foo");
cow.to_mut().make_ascii_uppercase();

assert_eq!(
  cow,
  Cow::Owned(String::from("FOO")) as Cow<'_, str>
);
Run
source

pub fn into_owned(self) -> <B as ToOwned>::Owned

提取拥有的数据。

如果数据尚未拥有,则克隆数据

Examples

Cow::Borrowed 上调用 into_owned 会返回借用数据的克隆:

use std::borrow::Cow;

let s = "Hello world!";
let cow = Cow::Borrowed(s);

assert_eq!(
  cow.into_owned(),
  String::from(s)
);
Run

Cow::Owned 上调用 into_owned 会返回拥有所有权的数据。 数据被移出 Cow 而不被克隆。

use std::borrow::Cow;

let s = "Hello world!";
let cow: Cow<'_, str> = Cow::Owned(String::from(s));

assert_eq!(
  cow.into_owned(),
  String::from(s)
);
Run

Trait Implementations§

1.14.0 · source§

impl<'a> Add<&'a str> for Cow<'a, str>

§

type Output = Cow<'a, str>

应用 + 运算符后的结果类型。
source§

fn add(self, rhs: &'a str) -> Self::Output

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> Add<Cow<'a, str>> for Cow<'a, str>

§

type Output = Cow<'a, str>

应用 + 运算符后的结果类型。
source§

fn add(self, rhs: Cow<'a, str>) -> Self::Output

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> AddAssign<&'a str> for Cow<'a, str>

source§

fn add_assign(&mut self, rhs: &'a str)

执行 += 操作。 Read more
1.14.0 · source§

impl<'a> AddAssign<Cow<'a, str>> for Cow<'a, str>

source§

fn add_assign(&mut self, rhs: Cow<'a, str>)

执行 += 操作。 Read more
source§

impl<T: ?Sized + ToOwned> AsRef<T> for Cow<'_, T>

source§

fn as_ref(&self) -> &T

将此类型转换为 (通常是推断的) 输入类型的共享引用。
source§

impl<'a, B> Borrow<B> for Cow<'a, B>where B: ToOwned + ?Sized,

source§

fn borrow(&self) -> &B

从拥有的值中一成不变地借用。 Read more
source§

impl<B: ?Sized + ToOwned> Clone for Cow<'_, B>

source§

fn clone(&self) -> Self

返回值的副本。 Read more
source§

fn clone_from(&mut self, source: &Self)

source 执行复制分配。 Read more
source§

impl<B> Debug for Cow<'_, B>where B: Debug + ToOwned<Owned: Debug> + ?Sized,

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。 Read more
1.11.0 · source§

impl<B> Default for Cow<'_, B>where B: ToOwned<Owned: Default> + ?Sized,

source§

fn default() -> Self

使用包含的拥有值的默认值创建一个拥有的 Cow<’a, B>。

source§

impl<B: ?Sized + ToOwned> Deref for Cow<'_, B>where B::Owned: Borrow<B>,

§

type Target = B

解引用后的结果类型。
source§

fn deref(&self) -> &B

解引用值。
source§

impl<B> Display for Cow<'_, B>where B: Display + ToOwned<Owned: Display> + ?Sized,

source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。 Read more
1.19.0 · source§

impl<'a> Extend<Cow<'a, str>> for String

source§

fn extend<I: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: I)

使用迭代器的内容扩展集合。 Read more
source§

fn extend_one(&mut self, s: Cow<'a, str>)

🔬This is a nightly-only experimental API. (extend_one #72631)
用一个元素扩展一个集合。
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)
在集合中为给定数量的附加元素保留容量。 Read more
1.8.0 · source§

impl<'a, T: Clone> From<&'a [T]> for Cow<'a, [T]>

source§

fn from(s: &'a [T]) -> Cow<'a, [T]>

从一个切片创建一个 CowBorrowed 变体。

此转换不会分配或克隆数据。

1.28.0 · source§

impl<'a> From<&'a CStr> for Cow<'a, CStr>

source§

fn from(s: &'a CStr) -> Cow<'a, CStr>

CStr 转换为借用的 Cow,无需复制或分配。

1.28.0 · source§

impl<'a> From<&'a CString> for Cow<'a, CStr>

source§

fn from(s: &'a CString) -> Cow<'a, CStr>

&CString 转换为借用的 Cow,无需复制或分配。

1.28.0 · source§

impl<'a> From<&'a String> for Cow<'a, str>

source§

fn from(s: &'a String) -> Cow<'a, str>

String 引用转换为 Borrowed 变体。 不执行堆分配,并且不复制字符串。

Example
let s = "eggplant".to_string();
assert_eq!(Cow::from(&s), Cow::Borrowed("eggplant"));
Run
1.28.0 · source§

impl<'a, T: Clone> From<&'a Vec<T, Global>> for Cow<'a, [T]>

source§

fn from(v: &'a Vec<T>) -> Cow<'a, [T]>

Vec 的引用创建 CowBorrowed 变体。

此转换不会分配或克隆数据。

source§

impl<'a> From<&'a str> for Cow<'a, str>

source§

fn from(s: &'a str) -> Cow<'a, str>

将字符串切片转换为 Borrowed 变体。 不执行堆分配,并且不复制字符串。

Example
assert_eq!(Cow::from("eggplant"), Cow::Borrowed("eggplant"));
Run
1.28.0 · source§

impl<'a> From<CString> for Cow<'a, CStr>

source§

fn from(s: CString) -> Cow<'a, CStr>

无需复制或分配即可将 CString 转换为拥有所有权的 Cow

1.45.0 · source§

impl<T: Clone> From<Cow<'_, [T]>> for Box<[T]>

source§

fn from(cow: Cow<'_, [T]>) -> Box<[T]>

Cow<'_, [T]> 转换为 Box<[T]>

cowCow::Borrowed 变体时,此转换在堆上分配并复制底层切片。 否则,它将尝试重用拥有所有权的 Vec 的分配。

1.45.0 · source§

impl From<Cow<'_, CStr>> for Box<CStr>

source§

fn from(cow: Cow<'_, CStr>) -> Box<CStr>

通过复制借用的内容将 Cow<'a, CStr> 转换为 Box<CStr>

1.45.0 · source§

impl From<Cow<'_, str>> for Box<str>

source§

fn from(cow: Cow<'_, str>) -> Box<str>

Cow<'_, str> 转换为 Box<str>

cowCow::Borrowed 变体时,此转换在堆上分配并复制底层 str。 否则,它将尝试重用拥有所有权的 String 的分配。

Examples
use std::borrow::Cow;

let unboxed = Cow::Borrowed("hello");
let boxed: Box<str> = Box::from(unboxed);
println!("{boxed}");
Run
let unboxed = Cow::Owned("hello".to_string());
let boxed: Box<str> = Box::from(unboxed);
println!("{boxed}");
Run
1.14.0 · source§

impl<'a, T> From<Cow<'a, [T]>> for Vec<T>where [T]: ToOwned<Owned = Vec<T>>,

source§

fn from(s: Cow<'a, [T]>) -> Vec<T>

将写时克隆切片转换为 vector。

如果 s 已经拥有 Vec<T>,则直接返回。 如果 s 是借用了一个切片,将通过克隆 s 的项来分配和填充一个新的 Vec

Examples
let o: Cow<'_, [i32]> = Cow::Owned(vec![1, 2, 3]);
let b: Cow<'_, [i32]> = Cow::Borrowed(&[1, 2, 3]);
assert_eq!(Vec::from(o), Vec::from(b));
Run
1.45.0 · source§

impl<'a, B> From<Cow<'a, B>> for Arc<B>where B: ToOwned + ?Sized, Arc<B>: From<&'a B> + From<B::Owned>,

source§

fn from(cow: Cow<'a, B>) -> Arc<B>

通过复制其内容,从写时克隆指针创建一个原子引用计数指针。

Example
let cow: Cow<'_, str> = Cow::Borrowed("eggplant");
let shared: Arc<str> = Arc::from(cow);
assert_eq!("eggplant", &shared[..]);
Run
1.45.0 · source§

impl<'a, B> From<Cow<'a, B>> for Rc<B>where B: ToOwned + ?Sized, Rc<B>: From<&'a B> + From<B::Owned>,

source§

fn from(cow: Cow<'a, B>) -> Rc<B>

通过复制其内容,从写时克隆指针创建一个引用计数指针。

Example
let cow: Cow<'_, str> = Cow::Borrowed("eggplant");
let shared: Rc<str> = Rc::from(cow);
assert_eq!("eggplant", &shared[..]);
Run
1.28.0 · source§

impl<'a> From<Cow<'a, CStr>> for CString

source§

fn from(s: Cow<'a, CStr>) -> Self

通过复制借用的内容将 Cow<'a, CStr> 转换为 CString

1.22.0 · source§

impl<'a> From<Cow<'a, str>> for Box<dyn Error>

source§

fn from(err: Cow<'a, str>) -> Box<dyn Error>

Cow 转换为 dyn Error 的 box。

Examples
use std::error::Error;
use std::mem;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error>::from(a_cow_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
Run
1.14.0 · source§

impl<'a> From<Cow<'a, str>> for String

source§

fn from(s: Cow<'a, str>) -> String

将写时克隆字符串转换为 String 的拥有实例。

这将提取拥有所有权的字符串,如果尚未拥有,则克隆该字符串。

Example
// 如果字符串不被拥有...
let cow: Cow<'_, str> = Cow::Borrowed("eggplant");
// 它将在堆上分配并复制字符串。
let owned: String = String::from(cow);
assert_eq!(&owned[..], "eggplant");
Run
1.22.0 · source§

impl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a>

source§

fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a>

Cow 转换为 Dyn Error + Send + Sync 的 box。

Examples
use std::error::Error;
use std::mem;
use std::borrow::Cow;

let a_cow_str_error = Cow::from("a str error");
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_cow_str_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
Run
source§

impl<'a> From<String> for Cow<'a, str>

source§

fn from(s: String) -> Cow<'a, str>

String 转换为 Owned 变体。 不执行堆分配,并且不复制字符串。

Example
let s = "eggplant".to_string();
let s2 = "eggplant".to_string();
assert_eq!(Cow::from(s), Cow::<'static, str>::Owned(s2));
Run
1.8.0 · source§

impl<'a, T: Clone> From<Vec<T, Global>> for Cow<'a, [T]>

source§

fn from(v: Vec<T>) -> Cow<'a, [T]>

从拥有所有权的 Vec 实例创建 CowOwned 变体。

此转换不会分配或克隆数据。

1.12.0 · source§

impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>

source§

fn from_iter<I: IntoIterator<Item = &'b str>>(it: I) -> Cow<'a, str>

从迭代器创建一个值。 Read more
1.19.0 · source§

impl<'a> FromIterator<Cow<'a, str>> for String

source§

fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> String

从迭代器创建一个值。 Read more
1.12.0 · source§

impl<'a> FromIterator<String> for Cow<'a, str>

source§

fn from_iter<I: IntoIterator<Item = String>>(it: I) -> Cow<'a, str>

从迭代器创建一个值。 Read more
source§

impl<'a, T> FromIterator<T> for Cow<'a, [T]>where T: Clone,

source§

fn from_iter<I: IntoIterator<Item = T>>(it: I) -> Cow<'a, [T]>

从迭代器创建一个值。 Read more
1.12.0 · source§

impl<'a> FromIterator<char> for Cow<'a, str>

source§

fn from_iter<I: IntoIterator<Item = char>>(it: I) -> Cow<'a, str>

从迭代器创建一个值。 Read more
source§

impl<B> Hash for Cow<'_, B>where B: Hash + ToOwned + ?Sized,

source§

fn hash<H: Hasher>(&self, state: &mut H)

将该值输入给定的 HasherRead more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

将这种类型的切片送入给定的 Hasher 中。 Read more
source§

impl<B> Ord for Cow<'_, B>where B: Ord + ToOwned + ?Sized,

source§

fn cmp(&self, other: &Self) -> Ordering

此方法返回 selfother 之间的 OrderingRead more
1.21.0 · source§

fn max(self, other: Self) -> Selfwhere Self: Sized,

比较并返回两个值中的最大值。 Read more
1.21.0 · source§

fn min(self, other: Self) -> Selfwhere Self: Sized,

比较并返回两个值中的最小值。 Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

将值限制在某个时间间隔内。 Read more
source§

impl<T, U> PartialEq<&[U]> for Cow<'_, [T]>where T: PartialEq<U> + Clone,

source§

fn eq(&self, other: &&[U]) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &&[U]) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b> PartialEq<&'b str> for Cow<'a, str>

source§

fn eq(&self, other: &&'b str) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &&'b str) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<T, U> PartialEq<&mut [U]> for Cow<'_, [T]>where T: PartialEq<U> + Clone,

source§

fn eq(&self, other: &&mut [U]) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &&mut [U]) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str

source§

fn eq(&self, other: &Cow<'a, str>) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &Cow<'a, str>) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b> PartialEq<Cow<'a, str>> for String

source§

fn eq(&self, other: &Cow<'a, str>) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &Cow<'a, str>) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b> PartialEq<Cow<'a, str>> for str

source§

fn eq(&self, other: &Cow<'a, str>) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &Cow<'a, str>) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b, B, C> PartialEq<Cow<'b, C>> for Cow<'a, B>where B: PartialEq<C> + ToOwned + ?Sized, C: ToOwned + ?Sized,

source§

fn eq(&self, other: &Cow<'b, C>) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b> PartialEq<String> for Cow<'a, str>

source§

fn eq(&self, other: &String) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &String) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<T, U, A: Allocator> PartialEq<Vec<U, A>> for Cow<'_, [T]>where T: PartialEq<U> + Clone,

source§

fn eq(&self, other: &Vec<U, A>) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &Vec<U, A>) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b> PartialEq<str> for Cow<'a, str>

source§

fn eq(&self, other: &str) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &str) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, B> PartialOrd<Cow<'a, B>> for Cow<'a, B>where B: PartialOrd + ToOwned + ?Sized,

source§

fn partial_cmp(&self, other: &Cow<'a, B>) -> Option<Ordering>

如果存在,则此方法返回 selfother 值之间的顺序。 Read more
source§

fn lt(&self, other: &Rhs) -> bool

此方法测试的内容少于 (对于 selfother),并且由 < 操作员使用。 Read more
source§

fn le(&self, other: &Rhs) -> bool

此方法测试小于或等于 (对于 selfother),并且由 <= 运算符使用。 Read more
source§

fn gt(&self, other: &Rhs) -> bool

此方法测试大于 (对于 selfother),并且由 > 操作员使用。 Read more
source§

fn ge(&self, other: &Rhs) -> bool

此方法测试是否大于或等于 (对于 selfother),并且由 >= 运算符使用。 Read more
1.17.0 · source§

impl ToString for Cow<'_, str>

source§

fn to_string(&self) -> String

将给定值转换为 StringRead more
source§

impl<B> Eq for Cow<'_, B>where B: Eq + ToOwned + ?Sized,

Auto Trait Implementations§

§

impl<'a, B: ?Sized> RefUnwindSafe for Cow<'a, B>where B: RefUnwindSafe, <B as ToOwned>::Owned: RefUnwindSafe,

§

impl<'a, B: ?Sized> Send for Cow<'a, B>where B: Sync, <B as ToOwned>::Owned: Send,

§

impl<'a, B: ?Sized> Sync for Cow<'a, B>where B: Sync, <B as ToOwned>::Owned: Sync,

§

impl<'a, B: ?Sized> Unpin for Cow<'a, B>where <B as ToOwned>::Owned: Unpin,

§

impl<'a, B: ?Sized> UnwindSafe for Cow<'a, B>where B: RefUnwindSafe, <B as ToOwned>::Owned: UnwindSafe,

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

获取 selfTypeIdRead more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

从拥有的值中一成不变地借用。 Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

从拥有的值中借用。 Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

返回未更改的参数。

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

调用 U::from(self)

也就是说,这种转换是 From<T> for U 实现选择执行的任何操作。

source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

获得所有权后的结果类型。
source§

fn to_owned(&self) -> T

从借用的数据创建拥有的数据,通常是通过克隆。 Read more
source§

fn clone_into(&self, target: &mut T)

使用借来的数据来替换拥有的数据,通常是通过克隆。 Read more
source§

impl<T> ToString for Twhere T: Display + ?Sized,

source§

default fn to_string(&self) -> String

将给定值转换为 StringRead more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

发生转换错误时返回的类型。
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

执行转换。
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

发生转换错误时返回的类型。
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

执行转换。