rust trait

July 31, 2022

父（超） trait（supertrait）

实现子 trait 时还需要已经实现父 trait

rust

trait Super {
    fn s(&self);
}

trait Child: Super {
    fn c(&self);
    fn s(&self); // 不是覆盖
}

struct Test();

impl Super for Test {
    fn s(&self) {
        println!("call Super::s()")
    }
}

impl Child for Test {
    // 只能实现 Child 中的函数，而不能实现 Super 中的函数
    fn c(&self) {
        println!("call Child::c()")
    }
    fn s(&self) {
        println!("call Child::s()")
    }
}

fn main() {
    let test = Test();
    test.c();
    // 无法使用 test.s();
    Super::s(&test);
    Child::s(&test);
}

相关内容参见：完全限定语法与消歧义：调用相同名称的方法

trait 标注生命周期

结构体若含引用成员（则结构体本身必须标注生命周期），结构体在实现 trait 时也需要通过泛型指定生命周期

摘自 https://www.rustwiki.org.cn/zh-CN/rust-by-example/scope/lifetime/trait.html

rust

// 带有生命周期标注的结构体。
#[derive(Debug)]
 struct Borrowed<'a> {
     x: &'a i32,
 }

// 给 impl 标注生命周期。
impl<'a> Default for Borrowed<'a> {
    fn default() -> Self {
        Self {
            x: &10,
        }
    }
}

fn main() {
    let b: Borrowed = Default::default();
    println!("b is {:?}", b);
}

trait bond

假设已有如下定义：

rust

trait Value {
    fn value(&self) -> isize;
}

struct Int32(i32);

struct Int64(i64);

impl Value for Int32 {
    fn value(&self) -> isize {
        self.0 as isize
    }
}
impl Value for Int64 {
    fn value(&self) -> isize {
        self.0 as isize
    }
}

使用 impl 约束，可指定参数类型实现了给定 trait

rust


fn sum(lhs: impl Value, rhs: impl Value) -> isize {
    lhs.value() + rhs.value()
}

fn main() {
    println!("{}", sum(Int32(1), Int64(2)));
}

在上例中，只要实现了给定 trait 就可以作为参数

下面的例子实现了对参数类型的限制，要求两个参数不仅实现了给定 trait，二者类型还需相同

rust

fn sum<T: Value>(lhs: T, rhs: T) -> isize {
    // 注意 T: Value 表示类型 T 实现了 Value，而不使用语法： T impl Value
    lhs.value() + rhs.value()
}

fn main() {
    println!("{}", sum(Int32(1), Int32(2)));
    println!("{}", sum(Int64(1), Int64(2)));
}

也可以使用 where 限定，效果一致

rust

fn sum<T>(lhs: T, rhs: T) -> isize
where
    T: Value,
{
    lhs.value() + rhs.value()
}

需要多重约束时，将多个 trait 用加号 + 连接即可

使用 dyn 返回 trait

欲返回非具体的类型（动态大小类型，DST，unsized 在 rust 中表达为 ?Sized）
需要返回 Box 包装的值，并使用 dyn 语法，表示允许任意实现 trait 的类型
当然，返回值（和使用 impl 约束一样）将只能使用 trait 上存在的函数

rust

enum IntStruct {
    Int32,
    Int64,
}

fn get_int_struct(r#type: IntStruct, value: isize) -> Box<dyn Value> {
    match r#type {
        IntStruct::Int32 => Box::new(Int32(value as i32)),
        IntStruct::Int64 => Box::new(Int64(value as i64)),
    }
}

fn main() {
    println!("{}", get_int_struct(IntStruct::Int32, 32).value()); // => 32
    println!("{}", get_int_struct(IntStruct::Int64, 64).value()); // => 64
}

显然该 trait 不能是 Sized

trait Trait {}
struct Impl;
impl Trait for Impl {}
let x: &dyn Trait = &Impl; // OK


trait TraitSized: Sized {}
struct ImplSized;
impl TraitSized for ImplSized {}
let y: &dyn TraitSized = &ImplSized; // Error!

参见：
动态大小类型和 Sized trait
为使用不同类型的值而设计的 trait 对象

泛型覆盖实现（Generic Blanket Impls）

rust

use std::convert::TryInto;
use std::fmt::Debug;
use std::ops::Rem;

trait Even {
    fn is_even(self) -> bool;
}

// generic blanket impl
impl<T> Even for T
where
    T: Rem<Output = T> + PartialEq<T> + Sized,
    u8: TryInto<T>,
    <u8 as TryInto<T>>::Error: Debug,
{
    fn is_even(self) -> bool {
        // these unwraps will never panic
        self % 2.try_into().unwrap() == 0.try_into().unwrap()
    }
}

#[test] // ✅
fn test_is_even() {
    assert!(2_i8.is_even());
    assert!(4_u8.is_even());
    assert!(6_i16.is_even());
    // etc
}

虚类型参数

“虚”指的是该类型仅在编译时静态检查，运行时不存在（零成本抽象）

std::marker 提供两个虚类型

struct PhantomData<T> where T: ?Sized;
// size_of::<PhantomData<T>>() == 0
// align_of::<PhantomData<T>>() == 1

pub struct PhantomPinned;

参见：https://www.rustwiki.org.cn/zh-CN/rust-by-example/generics/phantom.html

派生 trait

#[derive] 属性能够让编译器提供某些 trait 的实现（无需手动实现）
具体参见：https://www.rustwiki.org.cn/zh-CN/rust-by-example/trait/derive.html

标准库 trait

https://github.com/pretzelhammer/rust-blog/blob/master/posts/tour-of-rusts-standard-library-traits.md

https://doc.rust-lang.org/std/

https://www.rustwiki.org.cn/zh-CN/std/

闭包 trait

定义于 std::ops

FnMut

FnOnce

类型转换 trait

定义于 std::str

FromStr

定义于 std::convert

From & Into

TryFrom & TryInto

AsRef & AsMut

定义于 std::borrow

Borrow & BorrowMut

ToOwned

关于 AsRef/Borrow 和 AsMut/BorrowMut （下以 AsRef/Borrow 举例）

AsRef 和 Borrow 的签名实际上完全相同，因此它们之间主要是语义方面的区别

为类型 X 实现 Borrow<Borrowed>.borrow() 得到 &Borrowed，
要求 X 与 Borrowed 等价，即它们的 Eq Ord 和 Hash （在转换前后）必须相等
标准库的表述就是类型的不同表现形式，如 Box<T> 和 T，Rc<T> 和 T，String 和 str
这些类型提供了对底层数据的引用，即它们能够通过底层数据类型的形式而被借用（如果还允许可变，则还可以实现 BorrowMut<Borrowed>）
此 trait 带有默认实现

为类型 X 实现 AsRef<T>.as_ref() 得到 &T，要求 X 与 T 均自反（不要求 X 与 T 相等），即，为 T 实现 AsRef<T>.as_ref() 得到 &T
不过此 trait 并没有自反的默认实现，此外 AsMut 不依赖 AsRef（而 BorrowMut 依赖 Borrow）
常见的例如函数接受 AsRef<Path>，这样更方便调用方使用（相当于一种重载(Overload)机制）

其次，Borrow 在 std::borrow 模块下，而 AsRef 在 std::convert 模块下
我们可以看出 AsRef 具有转换语义，Borrow 则是借用语义

我们知道 rust 是没有重载 & 运算符的，重载 * 的是 Deref 和 DerefMut（下以 Deref 为例）
为 T 实现 Deref<Target = U>，要求 T 与 U 行为相同
Deref 使用关联类型而不是泛型，这意味着 Deref 只能得到一种类型
使得 &T 可隐式转换为 &U, *t == *Deref::deref(&t)
与前面的 trait 不同的是，Deref 是为智能指针设计的

比较 trait

定义于 std::cmp

PartialEq & Eq

PartialOrd & Ord

定义于 std::hash

Hash

格式化输出 trait

定义于 std::fmt

Display & Debug

定义于 std::string

ToString
实现了 Display 则编译器自动实现 ToString
偏好实现 Display 而不是实现 ToString

IO trait

定义于 std::io

Read & Write & Seek

运算符重载 trait

定义于 std::ops

参见：https://www.rustwiki.org.cn/zh-CN/std/ops/index.html

std::default::Default

表示某个类型的默认值，rust 也提供 #[derive(Default)] 派生宏

std::marker::Sized

表示在编译时大小已知的类型。

https://stackoverflow.com/questions/30938499/why-is-the-sized-bound-necessary-in-this-trait

未来会有 Unsize 来表示 ?Sized

std::clone::Clone

一般实现为：通过一个引用，克隆出一个实值（有所有权）

More formally: if T: Copy, x: T, and y: &T, then let x = y.clone(); is equivalent to let x = *y；

rust

pub trait Clone: Sized {
    // Required method
    fn clone(&self) -> Self;

    // Provided method
    fn clone_from(&mut self, source: &Self) { ... }
}

如果所有字段均为 Clone，则此 trait 可以与 #[derive] 一起使用。

std::marker::Copy

如果类型实现 Copy，则它具有复制语义。也就是不发生所有权转移。

rust

#[derive(Copy, Clone)]
// Clone 是 Copy 的一个 super trait，所以实现了 Copy 的类型也必须实现 Clone

表明实现该 trait 的值足够简单（就像基本类型），以至于可以直接在栈上复制，无需转移所有权（赋值时）（我们知道 Clone 则需要显式调用一些方法）

注意实现了 Drop 就不能实现 Copy 了，因为实现 Drop 就会有额外的释放行为
可变引用和一些智能指针是不能 Copy 的，因为这样复制的是指针本身，而不是指针指向的数据
（只复制指针肯定是不安全的，此时应当使用 Rc）

参见：https://www.rustwiki.org.cn/zh-CN/core/marker/trait.Copy.html

std::ops::Drop

相当于析构函数，生命期结束时自动调用（先进后出），只能通过 std::mem::drop 间接调用

另见：rust 智能指针

std::marker::Sync

（编译器自动实现）表明类型可以在线程之间安全地共享引用

&T 是 Send 当且仅当 T 是 Sync
&mut T 是 Send 当且仅当 T 是 Send
&T 和 &mut T 是 Sync 当且仅当 T 是 Sync

std::marker::Send

（编译器自动实现）表明类型可以在线程边界间传递

例如，Rc 不是 Send，而 Arc 是 Send

std::pin::Pin

#[repr(transparent)]
pub struct Pin<P> { /* private fields */ }

表明数据在内存中的位置是固定的（不会移动）
即指针（是地址）指向的数据不会改变（但注意Rust编译器认为任何值都是可移动的）

std::marker::Unpin

几乎所有类型都会自动实现这个 trait

需要持有 PhantomPinned 表明不是 Unpin，即 impl !Unpin for PhantomPinned

std::iter::Iterator

trait Iterator {
    type Item;
    fn next(&mut self) -> Option<Self::Item>;
}

参见：https://www.rustwiki.org.cn/zh-CN/std/iter/

←Back to home