rust中trait的使用方法详解

trait TraitA {}

struct Atype;

impl TraitA for Atype {}

fn print<T: std::fmt::Display>(p: Point<T>){...}

// 下列代码涉及所有权三态
trait Sport {
    fn play(&self) {} // 注意这里一对花括号，就是trait的关联函数的默认实现
    fn play_mut(&mut self);
    fn play_own(self);
    fn play_some() -> Self;
}

struct Football;
impl Sport for Football {
    // 由于play函数在trait中有关联函数的默认实现，结构体则可以不实现此函数
    fn play_mut(&mut self) {}
    fn play_own(self) {}
    fn play_some() -> Self { Self }
}

fn main() {
    let mut f = Football;
    f.play();
    f.play_mut();
    f.play_own();
    let _g = Football::play_some();
    let _g = <Football as Sport>::play_some(); // 等同于上一条代码
}

pub trait Sport {
    type ST; // 声明关联类型
    fn play(&self, st: Self::ST); // 将关联类型应用到关联函数
}

struct Football;
pub enum SportType {
    Land,
    Water,
}

impl Sport for Football {
    type ST = SportType; // 为关联类型指定具体类型
    fn play(&self, st: Self::ST){} // 方法中用到关联类型
}

fn main() {
    let f = Football;
    f.play(SportType::Land);
}

trait TraitA {
    type Mytype;
}

fn doit<T: TraitA>(a: T::Mytype) {} // 这里在函数中使用关联类型

struct TypeA;
impl TraitA for TypeA {
    type Mytype = String; // 具化关联类型为String
}

fn main() {
    doit::<TypeA>("abc".to_string()); // 指定泛型T为结构体TypeA
}

trait TraitA {
    type Item;
}
// 意思就是限制x必须是实现TraitA而且它的关联类型Item必须是String的类型
struct Foo<T: TraitA<Item=String>> {
    x: T
}

use std::fmt::Debug;

trait TraitA {
    type Item: Debug; // 这里对关联类型添加了Debug的约束
}

#[derive(Debug)]
struct A; // 这里在结构体A上自动derive Debug约束

struct B;

impl TraitA for B {
    type Item = A; // 这里类型A已经满足Debug约束
}

...
fn doit<T>(a: T)
where
    T: TriatA, // 约束T类型必须实现TraitA
    T::Item: Debug + PartialEq, // 同时约束trait的关联类型必须实现Debug和PartialEq
{
}

trait TraitA {
    const LEN: u32 = 10;
}

struct A;
impl TraitA from A {
    const LEN: u32 = 12;
}

fn doit<T: A + B + C + D + E + F>(t: T) -> i32 {}

fn doit<T>(t: T) -> u32
where
    T: A + B + C + D + E + F
{}

trait TraitB {}
trait TraitA: TraitB {}
// 等价于
trait TraitC where Self: TraitB {}

trait Shape {
    fn play(&self) {
        println!("1");
    }
}
trait Circle: Shape {
    fn play(&self) {
        println!("2");
    }
}
struct A;
impl Shape for A {}
impl Circle for A {}
impl A {
    fn play(&self) {
        println!("3");
    }
}

fn main() {
    let a = A;
    a.play(); // 调用类型A上实现的play方法
    <A as Circle>::play(&a); // 调用trait Circle上的play方法
    <A as Shape>::play(&a); // 调用trait Shape上的play方法
}

mod module_a {
    pub trait Shape {
        fn play(&self) {
            println!("1");
        }
    }
    pub struct A;
    impl Shape for A {}
}
mod module_b {
    use supper::module_a::Shape; // 需要同时引入A用到的trait
    use super::module_a::A;
    
    fn doit() {
        let a = A;
        a.play();
    }
}

trait TraitA {}
trait TraitB {}

impl<T: TraitB> TraitA for T {} // 为所有被TraitB约束的类型实现TraitA

impl TraitB for u32 {}
// impl TraitA for u32 {} // 无法再次实现