标准 trait

1. 内存相关: `Clone`/`Copy`/`Drop`

1.1 Clone trait

#![allow(unused)]
fn main() {
pub trait Clone {
  fn clone(&self) -> Self;

  fn clone_from(&mut self, source: &Self) {
    *self = source.clone()
  }
}
}

clone_from方法在实例a已经存在, 在clone过程中会分配内存, 那么用a.clone_from(&b)可以避免内存分配, 提高效率.

Clone trait可以通过派生宏直接实现#[derive(Clone)].

1.2 Copy trait

#![allow(unused)]
fn main() {
pub trait Copy: Clone {}
}

这个trait没有任何行为, 但它可以用作 trait bound 来进行类型安全检查, 所以叫 标志trait

Copy trait可以通过派生宏直接实现#[derive(Copy)].

1.3 Drop trait

#![allow(unused)]
fn main() {
pub trait Drop {
    fn drop(&mut self);
}
}

大部分场景无需为数据结构提供 Drop trait, 系统默认会依次对数据结构的每个域做 drop. 但有两种情况你可能需要手工实现 Drop.

希望在数据结束生命周期的时候做一些事情, 比如记日志.
需要对资源回收的场景. 编译器并不知道你额外使用了哪些资源, 也就无法帮助你 drop 它们. 比如说锁资源的释放, 在 MutexGuard 中实现了 Drop 来释放锁资源

注意:

Copy trait 和 Drop trait 是互斥的, 两者不能共存, 当你尝试为同一种数据类型实现 Copy 时, 同时也实现 Drop, 编译器就会报错. 这其实很好理解：**Copy 是按位做浅拷贝, 那么它会默认拷贝的数据没有需要释放的资源；而 Drop 恰恰是为了释放额外的资源而生的. **

2. 标记 trait: `Sized`/`Send`/`Sync`/`Unpin`

2.1 Sized trait

#![allow(unused)]
fn main() {
pub trait Sized { }
}

Sized trait 用于标记有具体大小的类型. 在使用泛型参数时, Rust 编译器会自动为泛型参数加上 Sized 约束.

大部分时候, 我们都希望能自动添加这样的约束, 因为这样定义出的泛型结构, 在编译期, 大小是固定的, 可以作为参数传递给函数.

在少数情况下, 需要 T 是可变类型的那么需要?Sized 来摆脱这个约束.

#![allow(unused)]
fn main() {
// 这样B就可以是[T]或者str类型,大小都不固定.
// 注意  Borrowed(&'a B) 大小是固定的, 因为它是对B的一个引用, 而且引用的大小是固定的.
pub enum Cow<'a, B: ?Sized + 'a> where B: ToOwned,
{
    // 借用的数据
    Borrowed(&'a B),
    // 拥有的数据
    Owned(<B as ToOwned>::Owned),
}
}

2.2 Send/Sync

#![allow(unused)]
fn main() {
pub unsafe auto trait Send {}
pub unsafe auto trait Sync {}
}

这两个 trait 都是 unsafe auto trait, auto 意味着编译器会在合适的场合, 自动为数据结构添加它们的实现, 而 unsafe 代表实现的这个 trait 可能会违背 Rust 的内存安全准则, 如果开发者手工实现这两个 trait , 要自己为它们的安全性负责.

Send/Sync 是 Rust 并发安全的基础：

如果一个类型 T 实现了 Send trait, 意味着 T 可以安全地从一个线程移动到另一个线程, 也就是说所有权可以在线程间移动.
如果一个类型 T 实现了 Sync trait, 则意味着 &T 可以安全地在多个线程中共享. 一个类型 T 满足 Sync trait, 当且仅当 &T 满足 Send trait.

对于 Send/Sync 在线程安全中的作用, 可以这么看, **如果一个类型 T: Send, 那么 T 在某个线程中的独占访问是线程安全的；如果一个类型 T: Sync, 那么 T 在线程间的只读共享是安全的. **

对于我们自己定义的数据结构, 如果其内部的所有域都实现了 Send / Sync, 那么这个数据结构会被自动添加 Send / Sync.

标准库中, 不支持 Send / Sync 的数据结构主要有：

裸指针 *const T / *mut T. 它们是不安全的, 所以既不是 Send 也不是 Sync.
UnsafeCell 不支持 Sync. 也就是说, 任何使用了 Cell 或者 RefCell 的数据结构不支持 Sync.
引用计数 Rc 不支持 Send 也不支持 Sync. 所以 Rc 无法跨线程.

2.3 Unpin

todo.

3. 类型转换: `From`/`Into`/`AsRef`/`AsMut`

3.1 From / Into 和 TryFrom / TryInto

#![allow(unused)]
fn main() {
pub trait From<T> {
    fn from(T) -> Self;
}

pub trait Into<T> {
    fn into(self) -> T;
}

// 实现 From 会自动实现 Into
impl<T, U> Into<U> for T where U: From<T> {
    fn into(self) -> U {
        U::from(self)
    }
}

// From(Into)是自反的
// 把类型 T 的值转换成类型 T,  会直接返回
impl<T> From<T> for T {
    fn from(t: T) -> T {
        t
    }
}
}

From<T> 可以根据上下文做类型推导, 使用场景更多；而且实现了 From<T> 会自动实现 Into<T>, 反之不会. 所以需要的时候, 只要实现 From<T> 即可.

而且From<T>(Into<T>)是自反的, 把类型 T 的值转换成类型 T, 会直接返回, 这样在接口设计时变得灵活, 比如函数接受一个IpAddr为参数, 我们可以使用Into<IpAddr>让更多的类型被这个函数使用.

#![allow(unused)]
fn main() {
use std::net::IpAddr;

fn print(v: impl Into<IpAddr>) {
    println!("{:?}", v.into());
}
}

合理地使用From<T> / Into<T>, 可以让代码变得简洁, 符合 Rust 可读性强的风格, 更符合开闭原则.

注意, 如果你的数据类型在转换过程中有可能出现错误, 可以使用 TryFrom<T> 和 TryInto<T>, 用法与From<T>/ Into<T> 一样

#![allow(unused)]
fn main() {
pub trait TryFrom<T> {
    type Error;

    fn try_from(value: T) -> Result<Self, Self::Error>;
}
pub trait TryInto<T> {
    type Error;

    fn try_into(self) -> Result<T, Self::Error>;
}
}

3.2 AsRef / AsMut

AsRef<T> 和 AsMut<T> 就很好理解了, 用于从引用到引用的转换.

在 trait 的定义上, 都允许 T 使用大小可变的类型, 如 str、[u8] 等. AsMut<t> 除了使用可变引用生成可变引用外, 其它都和 AsRef<T> 一样.

注意, 如果你的代码出现 v.as_ref().clone() 这样的语句, 也就是说你要对 v 进行引用转换, 然后又得到了拥有所有权的值, 那么你应该实现 From<T>, 然后做 v.into().

#![allow(unused)]
fn main() {
pub trait AsRef<T> where T: ?Sized {
    fn as_ref(&self) -> &T;
}

pub trait AsMut<T> where T: ?Sized {
    fn as_mut(&mut self) -> &mut T;
}
}

4. `Deref` / `DerefMut`

#![allow(unused)]
fn main() {
pub trait Deref {
    // 解引用出来的结果类型
    type Target: ?Sized;
    
    fn deref(&self) -> &Self::Target;
}

pub trait DerefMut: Deref {
    fn deref_mut(&mut self) -> &mut Self::Target;
}
}

5. `Debug` / `Display` / `Default`

#![allow(unused)]
fn main() {
pub trait Debug {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
}

pub trait Display {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>;
}

pub trait Default {
    fn default() -> Self;
}
}

Debug 和 Display 两个 trait 的签名一样, 都接受一个 &self 和一个 &mut Formatter.

Debug 是为开发者调试打印数据结构所设计的, 可以通过派生宏直接生成.通过{:?}来打印.
Display 是给用户显示数据结构所设计的, 必须手工实现.通过{}打印.

Default trait 用于为类型提供缺省值. 它也可以通过 derive 宏 #[derive(Default)] 来生成实现, 前提是类型中的每个字段都实现了 Default trait.

knowledge