Go语言的接口和Rust的Trait的对比

go语言的接口是鸭子的方式，即struct本身拥有的方法如果包含某个接口里定义的所有方法声明，则认为这个struct实现了该接口，举例子：

type A struct {
    Face int
}

// A结构体实现了f()方法
func (a A) f() {
    fmt.Println("A onwer func", a.Face)
}

// 由于A拥有的方法里包含了Test接口里所有声明的方法，所以A自动实现了Test接口，同理Test2，但是Test3则没有实现
type Test interface {
    f()
}

type Test2 interface {
    f()
}

type Test3 interface {
    f()
    k()
}

func main() {
    aa := A {Face: 9}
    // 执行A本身的f方法
    aa.f()
    
    var ivar1 Test
    ivar1 = aa
    // 通过A实现的Test接口来执行实现的接口方法
    ivar1.f()
    
    var ivar2 Test2
    ivar2 = aa
    // ok，同上
    ivar2.f()
    
    var ivar3 Test3
    // 报错，因为A没有实现Test3
    ivar3 = aa
    ivar3.f()
}

可以看到，go里针对不同的接口，它的实现方式只能是一种，不能针对A接口有A的实现，针对B接口有B的实现（接口方法签名一致）

而Rust可以实现go的全部功能，而且更灵活和清晰（主动impl），控制粒度更细：

struct FooT {
    cat: i32
}

impl FooT {
    fn printc(&self) {
        println!("EEE:{:?}", self.cat);
    }
}

trait Test2 {
    fn printc(&self);
}

impl Test2 for FooT {
    fn printc(&self) {
        // 如果要实现Test2的也是用FooT自己的方法，这里直接调用self.printc()即可
        println!("Test2:{:?}", self.cat);
    }
}

trait Test3 {
    fn printc(&self);
}

impl Test3 for FooT {
    fn printc(&self) {
        println!("Test3:{:?}", self.cat);
    }
}

fn main() {
    let st = FooT{cat: 9};
    // 调用的是FooT自己的方法，输出的是EEE:9
    st.printc();
    
    let st1: &dyn Test2 = &st;
    // 调用的是FooT实现了Test2 trait的方法，输出的是Test2:9
    st1.printc();
    
    let st2: &dyn Test3 = &st;
    // 调用的是FooT实现了Test3 trait的方法，输出的是Test3:9
    st2.printc();
}

当然，也可能是我go和rust理解不够，可能有误，希望能指出