rust return impl Trait

impl Trait：静态分发
dyn Trait：动态分发

静态分发：在编译期就确定了具体返回类型，函数只能返回一种类型。
动态分发：在运行时才能确定具体返回类型，函数可以返回多种类型。

Trait Object：指向trait的指针，假设Animal是一个triait，那么&Animal和Box<Animal>都是一种Trait Object。

胖指针：用于指代动态大小类型(DST)的引用和原始指针(切片或特征对象)。胖指针包含一个指针以及一些使DST完成(例如长度)的信息。

返回值为impl Trait时用dyn Trait是没问题的

trait Animal {
    fn get_kind(&self) -> String;
 
    fn default_impl(&self) {
        println!("default impl");
    }
}
 
impl dyn Animal {
    fn trait_object() {
        println!("trait object");
    }
}
 
#[derive(Debug)]
struct Dog {}
 
impl Animal for Dog {
    fn get_kind(&self) -> String {
        "Dog".to_string()
    }
}
 
struct Cat {}
 
impl Animal for Cat {
    fn get_kind(&self) -> String {
        "Cat".to_string()
    }
}
 
// 静态分发
fn get_animal_static() -> impl Animal {
    let x = 1;
    if x == 1 {
        Dog {}
    } else {
        Dog {}
    }
}
 
// 动态分发
fn get_animal_dyn() -> Box<dyn Animal> {
    let x = 0;
    if x == 1 {
        Box::new(Dog {})
    } else {
        Box::new(Cat {})
    }
}
 
fn main() {
    let dog = Dog {};
    dog.default_impl();
 
    let cat = Cat {};
    cat.default_impl();
 
    // 只有 trait objects 才能调用
    // dog.trait_object();
    // cat.trait_object();
 
    <dyn Animal>::trait_object();
    let _ = &<dyn Animal>::trait_object();
 
    let animal = get_animal_static();
    // Dog
    println!("{}", animal.get_kind());
 
    let animal = get_animal_dyn();
    // Cat
    println!("{}", animal.get_kind());
}