Rust Trait

观感

Rust的Trait和Golang的interface看起来非常相似，从开发者角度来看，都可以实现具体类型的抽象化。

golang:

type geometry interface {
    area() float64
}

type rect struct {
    width, height float64
}

func (r rect) area() float64 {
    return r.width * r.height
}

func measure(g geometry) {
    fmt.Println(g)
    fmt.Println(g.area())
}

func main() {
    r := rect{width: 3, height: 4}
    measure(r)
}

Rust:

use core::f64::consts::PI;
use core::fmt::Debug;

trait Geometry {
    fn area(&self) -> f64;
}

#[derive(Debug)]
struct Rect {
    width: f64,
    height: f64,
}

impl Geometry for Rect {
    fn area(&self) -> f64 {
        self.width * self.height
    }
}

fn main() {
    fn measure<T>(g: &T)
    where T: Geometry + Debug 
    {
        println!("{:?}", g);
        println!("{:?}", g.area());
    }
    
    let r = Rect{width: 3.0, height: 4.0};
    
    measure(&r);
}

从上面的代码可以简单看出来，Golang中的Interface与具体的结构体之间是自动关联的，不像Rust需要显式的用一个impl来关联。

此外，回顾下前文范型相关的内容看，Rust可以为非确定类型实现trait，但是Golang仅能对确定的struct实现Interface。

pub trait MetroCodeCheck {
    fn metro_status(&self) -> String;
}

impl<T> MetroCodeCheck for T
where
    T: TravelCodeCheck,
{
    fn metro_status(&self) -> String {
        format!("{}", self.travel_status())
    }
}

在这个例子中，为T类型实现了MetroCodeCheck，而T是一个范型，可能对应于其他的已定义的类型，并不与一个确切的类型绑定。

静态分发

下面我们通过模拟编译器的行为来分别分析静态分发。对于Golang而言，仅允许动态分发，每一个Interface中的方法地址是从值中动态加载然后调用的，所以只有在运行期间才能知道具体的函数。

考虑一个例子：

type Foo interface { bar() }

func call_bar(value Foo) { value.bar() }

type X int;
type Y string;
func (X) bar() {}
func (Y) bar() {}

func main() {
    call_bar(X(1))
    call_bar(Y("foo"))
}

如果用C语言模拟Golang的原理，忽略掉一些必要的细节后，会得到类似的代码：

void bar_int(...) { ... }
void bar_string(...) { ... }

struct Foo {
    void* data;
    struct FooVTable* vtable;
}
struct FooVTable {
    void (*bar)(void*);
}

void call_bar(struct Foo value) {
    value.vtable.bar(value.data);
}

static struct FooVTable int_vtable = { bar_int };
static struct FooVTable string_vtable = { bar_string };

int main() {
    int* i = malloc(sizeof *i);
    *i = 1;
    struct Foo int_data = { i, &int_vtable };
    call_bar(int_data);

    string* s = malloc(sizeof *s);
    *s = "abc";
    struct Foo string_data = { s, &string_vtable };
    call_bar(string_data);
}

可以看出Interface中的函数的地址保存在vtable中，在调用过程中，必须先根找到对应的vtable才能获取到函数地址。

如果是Rust，会得到如下的C代码：

void bar_int(...) { ... }
void bar_string(...) { ... }

void call_bar_int(int value) {
    bar_int(value);
}
void call_bar_string(string value) {
    bar_string(value);
}

int main() {
    call_bar_int(1);
    call_bar_string("abc");
    return 1;
}

Rust直接在编译阶段为不同的类型生成了不同的函数版本，然后直接根据类型调用不同的版本即可，不涉及到从vtable获取函数地址。

从调用过程可以直接看出，静态分发模式下，省去了动态查找，也可以做一些更加深层次的优化，导致的结果就是Rust比Golang效率更高，但是可能会导致代码膨胀。

动态分发

Rust同时支持静态分发与动态分发，看一个实际的例子。

trait Animal {
    fn speak(&self);
}
struct Dog;
impl Animal for Dog {
    fn speak(&self) {
        println!("旺旺.....");
    }
}
struct Cat;
impl Animal for Cat {
    fn speak(&self) {
        println!("喵喵.....");
    }
}

如果是采用静态分发，那么使用方法如下：

fn animal_speak<T: Animal>(animal: T) {
    animal.speak();
}

fn main() {
    let dog = Dog;
    let cat = Cat;

    animal_speak(dog);
    animal_speak(cat);
}

实际上相当于为Dog与Cat分别实现了animal_speak方法：

fn dog_speak(dog: dog) {
    dog.speak();
}

fn cat_speak(cat: Cat) {
    cat.speak();
}

如果是动态分发，那么使用方法如下：

fn animal_speak(animal: &dyn Animal) {
    animal.speak();
}

fn main() {
    let dog = Dog;
    let cat = Cat;

    animal_speak(dog);
    animal_speak(cat);
}

这里使用了dyn作为动态分发的标记。

总结

Rust trait同时支持静态分发与动态分发，静态分发不需要通过虚表来寻找实际需要的函数指针，而是直接获取了函数指针，中间少了一步寻址过程。

从性能角度看，动态分发会带来运行时开销，静态分发性能更好，但是可能会造成二进制文件膨胀。