// 泛型类型：T 为泛型类型名称，名称位于类型名后的 <xx> 中。
// T 没有任何限界，默认为 Sized。
struct Point<T> { x: T, y: T, }

// 使用时，如果未指定泛型参数值，编译器自动推导
let p = Point{
    x: "5".to_string(),
    y : "hello".to_string()
};

// 使用时，为泛型参数指定具体类型，相当于实例化出一个匿名的具体类型
fn gen_spec_t(_s: Point<A>) {}
fn gen_spec_i32(_s: Point<i32>) {}

struct Val<T> {
    val: T,
}
// x 是 Val<f64> 类型
let x = Val{ val: 3.0 };
// y 是 Val<String> 类型
let y = Val{ val: "hello".to_string()};
// 3.0, hello
println!("{}, {}", x.value(), y.value());

// 泛型函数：类型参数位于函数名后的 <xx> 中。
fn generic<T>(_s: SGen<T>) {}

// 调用泛型函数时，使用比目鱼语法：method::<type>() 来指定泛型参数的具体类型。
generic::<char>(_);

struct Point<T, U> {
    x: T,
    y: U,
}

// impl 后需要列出泛型类型的所有泛型参数
impl<T, U> Point<T, U> {
    fn mixup<V, W>(self, other: Point<V, W>) -> Point<T, W> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

impl<T> Val<T> {
    // 方法可以使用 impl 指定的泛型参数
    fn value(&self) -> &T {
        &self.val
    }

    // 方法也可以有自己的泛型参数
    fn add<O: Debug>(&self, other: O) {
        println!("{:?}", other);
    }
}

let x = Val { val: 3.0 };
let y = Val { val: "hello".to_string(), };
println!("{}, {}", x.value(), y.value());
x.add(123); // 自动推断
x.add::<i32>(123); // 为泛型方法手动指定类型，使用比目鱼语法。

// 对 T 无限制，等效于 Sized 限界
struct Pair<T> { x: T, y: T,}

impl<T> Pair<T> {
    fn new(x: T, y: T) -> Self {
        Self { x, y, }
    }
}

// 为 T 添加额外的限制
impl<T: std::fmt::Debug + PartialOrd> Pair<T> {
    fn cmp_display(&self) {
        if self.x >= self.y {
            println!("The largest member is x = {:?}", self.x);
        } else {
            println!("The largest member is y = {:?}", self.y);
        }
    }
}

// 比目鱼语法
let _ = (1..5).collect::<Vec<i32>>();

// 编译器根据返回值自动推导
let _: Vec<i32> = (1..5).collect();

GenericParams :
   < >
   | < (GenericParam ,)* GenericParam ,? >

GenericParams :
   < >
   | < (GenericParam ,)* GenericParam ,? >

GenericParam :
   OuterAttribute* ( LifetimeParam | TypeParam | ConstParam )

LifetimeParam :
  LIFETIME_OR_LABEL ( : LifetimeBounds )?

LifetimeBounds :
  ( Lifetime + )* Lifetime?

Lifetime :
      LIFETIME_OR_LABEL
  | 'static
  | '_

ConstParam:
  const IDENTIFIER : Type ( = Block | IDENTIFIER | -?LITERAL )? // = 表示可以为常量指定缺省值

struct ArrayPair<T, const N: usize> {
    left: [T; N],
    right: [T; N],
}

impl<T: Debug, const N: usize> Debug for ArrayPair<T, N> {
    // ...
}

// 实例化常量参数，可以直接指定常量值或者使用 {xx} 常量表达式
fn foo<const N: usize>() {}

fn bar<T, const M: usize>() {
    foo::<M>();
    foo::<2021>();
    // OK：使用 <{xx}> 常量表达式
    foo::<{20 * 100 + 20 * 10 + 1}>();

    // Error: 常量表达式不支持泛型常量运算
    foo::<{ M + 1 }>();
    // Error: 常量表达式不支持泛型参数
    foo::<{ std::mem::size_of::<T>() }>();

    // OK
    let _: [u8; M];
    // Error: const expression contains the generic parameter `T`
    let _: [u8; std::mem::size_of::<T>()];
}

TypeParam :
  IDENTIFIER( : TypeParamBounds? )? ( = Type )? // = Type 表示可以给泛型参数设置缺省类型

TypeParamBounds :
  TypeParamBound ( + TypeParamBound )* +? // 泛型参数可以使用 + 连接多个限界条件，限界可以是 lifetime 或 trait bound

TypeParamBound :
      Lifetime | TraitBound

TraitBound :
      ?? ForLifetimes? TypePath // ?? 表示可选的 ？，表示该 trait boud 是可选。ForLifetimes 表示可以使用 HRTB 定义 TypePaht 中可用的 HRTB liftime。
  | ( ?? ForLifetimes? TypePath )  // 这里的括号为字面量, 不用于分组

// 如 ::std::ops::Index
TypePath :
  ::? TypePathSegment (:: TypePathSegment)* // 一个或多个 :: 分割的 TypePathSegment

// TypePathSegment 典型的情况是 :: 分割的标识符，如 ::std::ops::Index，但也支持更复杂的情况
TypePathSegment :
  PathIdentSegment (::? (GenericArgs | TypePathFn))?

PathIdentSegment →
    IDENTIFIER | super | self | Self | crate | $crate

// 函数闭包形式限界，如 fn myfunc(F: Fn(i32, &str) -> bool) {} 或 fn myfunc(S, F: Fn(i32, <S as Trait>::Assoc) -> bool)
// pub fn spawn<F, T>(f: F) -> JoinHandle<T> where F: FnOnce() -> T + Send + 'static, T: Send + 'static,
TypePathFn :
( TypePathFnInputs? ) (-> Type)?

// 这里的输入参数 Type 可以是各种类型的格式，如 QualifiedPathInType 对应的 <S as Trait>::Assoc
TypePathFnInputs :
  Type (, Type)* ,?

// 限界的 IDENTIFIER 本省是泛型类型，如 std::ops::Index 时，可以对它的泛型参数进一步限界，如:
// T: std::ops::Index<'a, std::ops::Range<usize>> //  GenericArgs = <'a, std::ops::Range<usize>>, GenericArg = 'a, GenericArg = std::ops::Range<usize>
GenericArgs :
      < >
  | < ( GenericArg , )* GenericArg ,? >

// GenericArgs 是生命期参数、类型参数、const 参数、绑定（binding）、bounds 等的组合。
GenericArg :
  Lifetime | Type | GenericArgsConst | GenericArgsBinding | GenericArgsBounds

// 类型参数 Type 的定义如上，它包含 TypePath，所以 <> 内形成一个递归嵌套的例子：
// fn myFunc<I> where I: std::ops::Index<std::ops::Range<usize>> // Type = std::ops::Range<usize>

// 泛型常量和标识符：
// fn myFunc<U, T: m::m2::MyTrait<23, 'x', U>> {} // LiteralExpression = 23,  LiteralExpression='x', SimplePathSegment = U
GenericArgsConst :
      BlockExpression
  | LiteralExpression
  | - LiteralExpression
  | SimplePathSegment

SimplePathSegment →
  IDENTIFIER | super | self | crate | $crate

// 为泛型参数的关联类型指定具体类型，这里的 IDENTIFIER 本身也可能是泛型，它的泛型参数为 GenericArgs（递归嵌套），如:
// fn add_all<T, U>(x: T, y: T) -> <T as Add<U>>::Output where T: Add<U, Output = Option<i32>>, //  IDENTIFIER = Output, Type = Option<i32>
//
//trait Trait { type Item<T>; }
//struct S;
//impl Trait for S { type Item<T> = Vec<T>;}
//fn multi_path<T>() -> Vec<i32> where S: Trait<Item<i32> = Vec<i32>>, // IDENTIFIER = S::Item, GenericArgs = <i32>, Type = Vec<i32>
//
GenericArgsBinding :
  IDENTIFIER GenericArgs? = Type // IDENTIFIER 必须是关联类型标识符

// 为泛型参数的关联类型进一步限界，这里的 IDENTIFIER 本身也可能是泛型，它的泛型参数为 GenericArgs（递归嵌套），如:
// fn f_extended<U>() where D: Trait2<Output: InnerTrait + AnotherTrait>, // IDENTIFIER = Output, TypeParamBounds = InnerTrait + AnotherTrait
// fn f5<T: outer::OuterTrait<Inner<u32>: outer::InnerTrait<u32>>>(x: T)    // IDENTIFIER = Inner, GenericArgs = <Inner<u32>，TypeParamBounds = outer::InnerTrait<u32>
//
GenericArgsBounds :
  IDENTIFIER GenericArgs? : TypeParamBounds

// 基本的 type 参数 + 单一 trait bound
fn f1<T: Clone>(x: T) -> T {
    x.clone()
}

// 多个 trait bound
fn f2<T: Clone + Default>(x: Option<T>) -> T {
    x.unwrap_or_default()
}

// 带生命周期 bound
fn f3<'a, T: 'a>(x: &'a T) -> &'a T {
    x
}

// lifetime 参数之间的 bound
fn f4<'a: 'b, 'b>(x: &'a &'b str) -> &'b str {
    x
}

// const 参数带 trait bound
fn f5<const N: usize>(x: [u8; N]) -> [u8; N]
where
    [u8; N]: Copy,
{
    x
}

// trait bound 使用 TypePath（简单路径）
fn f6<T: std::fmt::Debug>(x: T) {
    println!("{:?}", x);
}

// trait bound 使用 TypePath + 泛型参数
fn f7<T: std::ops::Add<Output = T>>(x: T, y: T) -> T {
    x + y
}

// trait bound 使用 TypePath + const 泛型
fn f8<const N: usize>(x: [u8; N])
where
    [u8; N]: PartialEq,
{
    let _ = x == x;
}

// trait bound 使用 TypePath + 函数式参数 (TypePathFn)
fn f9<F>(f: F, x: i32) -> bool
where
    F: Fn(i32) -> bool,
{
    f(x)
}

// Qualified Path in bound
trait Trait { type Item; }
struct S;
impl Trait for S {
    type Item = u32;
}

fn f10<T: Trait<Item = u32>>(x: T) -> T::Item {
    42
}

// Higher-Rank Trait Bound (HRTB)
fn f11<F>(f: F)
where
    F: for<'a> Fn(&'a str) -> &'a str,
{
    let _ = f("hi");
}

// 多层路径 + 组合泛型参数
fn f12<T>()
where
    T: ::std::iter::Iterator<Item = std::option::Option<String>>,
{
}

// ==========================
// 1. 基本 GenericArgsBinding
use std::ops::Add;

// 泛型函数，绑定 Add 的关联类型 Output
fn add_all<T, U>(x: T, y: T) -> <T as Add<U>>::Output
where
    T: Add<U, Output = Option<i32>>, // GenericArgsBinding: Output = Option<i32>
{
    x + y
}

fn main() {
    let a: Option<i32> = Some(1);
    let b: Option<i32> = Some(2);
    let c = add_all(a, b);
    println!("{:?}", c);
}

// ==========================
// 2. 带多层路径的 GenericArgsBinding
trait Trait {
    type Item<T>;
}

struct S;

impl Trait for S {
    type Item<T> = Vec<T>;
}

// 泛型函数，绑定 S::Item<T> 到具体类型 Vec<i32>
fn multi_path<T>() -> Vec<i32>
where
    S: Trait<Item<i32> = Vec<i32>>, // IDENTIFIER = S::Item, GenericArgs = <i32>, Type = Vec<i32>
{
    vec![1, 2, 3]
}

// ==========================
// 3. 带 const 泛型的 GenericArgsBinding
struct ArrayHolder<const N: usize>;

// Trait 带 const 泛型关联类型
trait Container {
    type Arr<const M: usize>;
}

struct C;

impl Container for C {
    type Arr<const M: usize> = [u8; M];
}

// 泛型函数，绑定关联类型到具体 const 数组类型
fn const_binding<const N: usize>() -> [u8; N]
where
    C: Container<Arr<N> = [u8; N]>, // IDENTIFIER = Arr, GenericArgs = <N>, Type = [u8; N]
{
    [0; N]
}

// ==========================
// 4. 带泛型 + 多层路径 + const 泛型
trait Trait2 {
    type Output<T, const M: usize>;
}

struct D;

impl Trait2 for D {
    type Output<T, const M: usize> = [T; M];
}

// 泛型函数示例
fn combined<T, const N: usize>() -> [T; N]
where
    D: Trait2<Output<T, N> = [T; N]>, // IDENTIFIER = Output, GenericArgs = <T, N>, Type = [T; N]
{
    // 这里只能用 Default 或 Copy 类型填充
    [T::default(); N]
}

mod outer {
    // Inner 是一个泛型 trait
    pub trait InnerTrait<T> {}

    // OuterTrait 的关联类型 Inner 是一个 trait，而不是具体类型
    pub trait OuterTrait {
        type Inner<U>: InnerTrait<U>;
    }
}

struct A;

// 泛型函数中直接在 fn 泛型参数列表使用 GenericArgsBounds
fn f5<T: outer::OuterTrait<Inner<u32>: outer::InnerTrait<u32>>>(x: T) {
    // IDENTIFIER = Inner, GenericArgs = <Inner<u32>，TypeParamBounds = outer::InnerTrait<u32>
}

// 使用带关联类型的 trait 做限界：
// 1. 可以不指定关联类型，在使用时由编译器推导；
// 2. 可以为关联类型做进一步限界
// 3. 可以使用关联类型
fn collect_into_vec<I: Iterator>(iter: I) -> Vec<I::Item> where I::Iterm: Debug {} // 对关联类型做进一步限界

// Iterator<Item=u8> 还是一个 trait，故：
// 1. 用作限界：
fn my_func<Iter: Iterator<Item=u8>>(iter: Iter) {}

// 2. 用作 trait object（需要将所有关联类型明确定义出来，否则编译时不能正确检查而报错）
fn dump(iter: &mut dyn Iterator<Item=String>) {}

struct EvenNumbers { count: usize, limit: usize, }
impl Iterator for EvenNumbers {
    // 实现 trait 时必须为关联类型指定 `具体类型` ，该具体类型需要满足该关联类型的限界要求。
    type Item = usize;

    // trait 的函数/方法，通过 Self::Item 引用关联类型
    fn next(&mut self) -> Option<Self::Item> {
        if self.count > self.limit {
            return None;
        }
        let ret = self.count * 2;
        self.count += 1;
        Some(ret)
    }
}

// https://doc.rust-lang.org/reference/items/generics.html#grammar-WhereClause
WhereClause → where ( WhereClauseItem , )* WhereClauseItem?
WhereClauseItem →
      LifetimeWhereClauseItem
    | TypeBoundWhereClauseItem
LifetimeWhereClauseItem → Lifetime : LifetimeBounds
// 进行限界的 Key 为 Type，而不是标识符
TypeBoundWhereClauseItem → ForLifetimes? Type : TypeParamBounds?

// 其中的 Type 类型定义如下：
Type →
      TypeNoBounds
    | ImplTraitType
    | TraitObjectType

TypeNoBounds →
      ParenthesizedType
    | ImplTraitTypeOneBound
    | TraitObjectTypeOneBound
    | TypePath
    | TupleType
    | NeverType
    | RawPointerType
    | ReferenceType
    | ArrayType
    | SliceType
    | InferredType
    | QualifiedPathInType
    | BareFunctionType
    | MacroInvocation

QualifiedPathInExpression → QualifiedPathType ( :: PathExprSegment )+
QualifiedPathType → < Type ( as TypePath )? > // 完全限定路径类型
QualifiedPathInType → QualifiedPathType ( :: TypePathSegment )+

// where 子句的 U 和 U::Assoc 均为合法的 Type 类型
trait Trait4 {
    type Assoc;
}
trait Trait5 {}

fn f3<U>()
where
    U: Trait4,      // 泛型参数 U 必须实现 Trait4
    U::Assoc: Trait5, // IDENTIFIER = Assoc, TypeParamBounds = Trait5
{
}

// 其中的 TypeNoBounds 的 QualifiedPathInType 是允许在 TypePath 中使用的格式, 如函数返回值的 Type 类型：
fn add_all<T, U>(x: T, y: T) -> <T as Add<U>>::Output
      where  T: Add<U, Output = Option<i32>>,

fn call_on_ref_zero<F>(f: F) where for<'a> F: Fn(&'a i32) {
    let zero = 0;
    f(&zero);
}
// 或者：
fn call_on_ref_zero<F>(f: F) where F: for<'a> Fn(&'a i32) {
    let zero = 0;
    f(&zero);
}

// 泛型 trait，泛型参数 A、B 没有定义限界，默认为 Sized。
trait Contains<A, B> {
    fn contains(&self, _: &A, _: &B) -> bool;
    fn first(&self) -> i32;
    fn last(&self) -> i32;
}

// 实现泛型 trait 时，可以指定具体类型或者继续使用泛型参数。
impl Contains<i32, i32> for Container {
    fn contains(&self, number_1: &i32, number_2: &i32) -> bool {
        (&self.0 == number_1) && (&self.1 == number_2)
    }
    fn first(&self) -> i32 { self.0 }
    fn last(&self) -> i32 { self.1 }
}

// 泛型参数可以使用 + 号连接的多个 trait 或 lifetime 作为限界。
fn compare_prints<T: Debug + Display>(t: &T) {
    println!("Debug: `{:?}`", t);
    println!("Display: `{}`", t);
}

fn compare_types<T: Debug, U: Debug>(t: &T, u: &U) {
    println!("t: `{:?}`", t);
    println!("u: `{:?}`", u);
}

// 对于复杂的、较长的限界, 可以使用 where 子句来定义
impl <A: TraitB + TraitC, D: TraitE + TraitF> MyTrait<A, D> for YourType {}
// 等效于
impl <A, D> MyTrait<A, D> for YourType
    where
        A: TraitB + TraitC,
        D: TraitE + TraitF
 {
     //..
 }

// 有些场景必须使用 where 来限界，比如这里限界的是 Option<T>
trait PrintInOption {
    fn print_in_option(self);
}

impl<T> PrintInOption for T where Option<T>: Debug {
    fn print_in_option(self) {
        println!("{:?}", Some(self));
    }
}

// 定义泛型 trait 时，泛型参数和关联类型都可以指定缺省类型，例如各种运算符重载 trait 都指定了默认类型。
pub trait Add<Rhs = Self> {
    // 关联类型也可以指定缺省类型，使用 type alias 语法。
    type Output = Self;

    // Required method
    fn add(self, rhs: Rhs) -> Self::Output;
}

trait Iterator {
    // 声明关联类型，同时对类型进行限界，使用 trait 限界语法。
    type Item: std::fmt::Display;

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

// 实现 trait 时，需要为泛型参数、关联类型指定具体类型
impl Add<Bar> for Foo {
    type Output = FooBar;

    fn add(self, _rhs: Bar) -> FooBar {
        FooBar
    }
}

// 例如：定义一个泛型函数，使用 Add trait 作为泛型参数的限界，同时指定 Rhs 类型和关联类型。
// 不能使用 Rhs = Rhs, 因为 Rhs 不是关联类型。
fn add_values<T, Rhs>(a: T, b: Rhs) -> T
    where T: Add<Rhs, Output = T>
  { a + b }

trait Float {
    // 定义常量时必须指定类型（编译器不会自动推导 const 值类型），但是可以不指定缺省值
    const ZERO: Self;
    const ONE: Self;
}

trait Greet{
    // 定义关联常量的类型和缺省值
    const GRETING: &'static str = "Hello",

    fn greet(&self) -> String;
}

// 实现 trait 时，为关联常量设置常量值
impl Float for f32 {
    const ZERO: f32 = 0.0;
    const ONE: f32 = 1.0;
}

trait Trait {}

fn foo<X: Trait>(t: X) {}

impl<'a> Trait for &'a i32 {}

fn main() {
    let t: &mut i32 = &mut 0;
    foo(t); // 报错。
}

// error[E0277]: the trait bound `&mut i32: Trait` is not satisfied
//  --> src/main.rs:9:9
//   |
// 3 | fn foo<X: Trait>(t: X) {}
//   |           ----- required by this bound in `foo`
// ...
// 9 |     foo(t);
//   |         ^ the trait `Trait` is not implemented for `&mut i32`
//   |
//   = help: the following implementations were found:
//             <&'a i32 as Trait>
//   = note: `Trait` is implemented for `&i32`, but not for `&mut i32`

use std::ops::{Deref, DerefMut};

impl<T> Deref for Selector<T> {
    type Target = T;
    fn deref(&self) -> &T { &self.elements[self.current] }
}

impl<T> DerefMut for Selector<T> {
    fn deref_mut(&mut self) -> &mut T { &mut self.elements[self.current] }
}

// OK: 函数传参时, Rust 会自动隐式解引用, &Selector -> &str
let s = Selector { elements: vec!["good", "bad", "ugly"], current: 2 };
fn show_it(thing: &str) { println!("{}", thing); }
show_it(&s);

// Error: 使用 Trait 作为泛型参数的限界时, Rust 不会自动解引用到 &str 类型来满足类型限界的要求
use std::fmt::Display;
fn show_it_generic<T: Display>(thing: T) { println!("{}", thing); }
show_it_generic(&s);

show_it_generic(&s as &str); // 使用 as 类型转换;
show_it_generic(&*s)         // 手动解引用 &*V 来得到 &str 类型

trait Person {
    fn name(&self) -> String;
}

// 等效于 trait Student where Self: Person
trait Student: Person {
    fn university(&self) -> String;
}

trait Programmer {
    fn fav_language(&self) -> String;
}

// 使用 + 运算符指定多个父 trait：
trait CompSciStudent: Programmer + Student {
    fn git_username(&self) -> String;
}

// 为父 trait 指定 lifetime 限界
trait Circle<'a> : Shape + 'a {
    fn radius(&self) -> f64;
}

// https://medium.com/software-design/understanding-rusts-trait-objects-224b1d8daede
pub trait Shape {
    type T;
    fn area(&self) -> Self::T;
}

pub trait Draw: Shape {
    fn draw(&self);
}

// The function operates with a trait object reference
pub fn draw_dynamic(a: &dyn Draw<T = f64>) {
    a.draw();
}

// Invokes the draw method and then the area method on the trait object
pub fn draw_and_report_area_dynamic(a: &dyn Draw<T = f64>) -> f64 {
    a.draw();
    a.area()
}

// 泛型类型
struct GenericVal<T>(T);

// 对于泛型类型，在 impl 时：
// 1. 如果指定了泛型参数类型，则不需要为 impl 指定泛型参数
impl GenericVal<f32> {}
// 2. 未指定具体类型时，必须在 impl<T> 中指定该泛型类型的所有泛型参数
impl<T> GenericVal<T> {}

fn main() {
    // 创建泛型类型的值时，可以不指定泛型参数 T，由编译器自动推导。
    let y = GenVal { gen_val: 3i32 };
    println!("{}, {}", x.value(), y.value());
}

struct Container(i32, i32);
trait Contains<A, B> {
    fn contains(&self, _: &A, _: &B) -> bool;
    fn first(&self) -> i32;
    fn last(&self) -> i32;
}
// 不需要使用 impl<i32, i32>
impl Contains<i32, i32> for Container {
    fn contains(&self, number_1: &i32, number_2: &i32) -> bool {
        (&self.0 == number_1) && (&self.1 == number_2)
    }
    fn first(&self) -> i32 { self.0 }
    fn last(&self) -> i32 { self.1 }
}

// 泛型 trait
trait DoubleDrop<T> {
    fn double_drop(self, _: T);
}

// 为 U 实现泛型 trait，U 本身也是泛型参数，所以相当于为所有 Sized 类型实现了 DoubleDrop trait。
impl<T, U> DoubleDrop<T> for U {
    fn double_drop(self, _: T) {}
}

// 为所有 &T 或 &mut T 实现 Deref<Target = T> trait：
// https://doc.rust-lang.org/src/core/ops/deref.rs.html#84
impl<T: ?Sized> Deref for &T {
    type Target = T;

    #[rustc_diagnostic_item = "noop_method_deref"]
    fn deref(&self) -> &T {
        *self
    }
}

impl<T: ?Sized> Deref for &mut T {
    type Target = T;

    fn deref(&self) -> &T {
        *self
    }
}

// write_all() 方法是 std::io::Write trait 定义的，调用它前需要引入 Write trait。
use std::io::Write
let mut buf: Vec<u8> = vec![];
buf.write_all(b"hello")?;

trait Pilot {
    fn fly(&self);
}

trait Wizard {
    fn fly(&self);
}

struct Human;

impl Pilot for Human {
    fn fly(&self) {
        println!("This is your captain speaking.");
    }
}

impl Wizard for Human {
    fn fly(&self) {
        println!("Up!");
    }
}

impl Human {
    fn fly(&self) {
        println!("*waving arms furiously*");
    }
}

fn main() {
    let person = Human;
    // 调用 Human 自身实现的 fly() 方法。
    person.fly();

    // 调用实现的 trait 的方法，这里为了避免歧义，使用的是 TraitName::method(object).
    Pilot::fly(&person); // 等效于完全限定方法调用：<Human as Pilot>::fly(&person) , Human as Pilot 表示 Human 类型实现了 Pilot trait
    Wizard::fly(&person);
}


`TraitName::method(object)` 调用方式只适合于 trait 中的方法而非关联函数：它们没有 self 参数，Rust 不能推导出调用哪一个类型实
现的该关联函数，这 时需要使用完全限定方法调用。

完全限定语法（`Fully Qualified Syntax`） 的几种格式：
1. `<Human as Pilot>::fly(&person)`：调用对象 person 对应的类型 Human 实现的 Pilot trait 的 fly 方法。
2. `<person as Pilot>::fly()`: 调用 person 对象类型实现的 Pilot trait 的 fly 方法；

如果类型实现的多个 trait 有同名方法而且这些 trait 都在作用域，则需要使用完全限定语法来指定要调用那个 trait 的方法实现，用于解决命名冲突或混淆的问题：

```rust
trait CalSum {
    fn sum(&self, a: i32) -> i32;
}

trait CalSumV2 {
    fn sum(&self, a: i32) -> i32;
}

#[derive(Clone, Copy, Debug)]
struct S1(i32);

impl CalSum for S1 {
    fn sum(&self, a: i32) -> i32 {
        self.0 + a
    }
}

impl CalSumV2 for S1 {
    fn sum(&self, a: i32) -> i32 {
        self.0 + a
    }
}

fn main() {
    let s1 = S1(0);

    // 调用指定 trait 的方法
    println!("Results: {}", CalSum::sum(&s1, 1));
    println!("Results: {}", CalSumV2::sum(&s1, 1));

    // ERROR: S1 同时实现了 CalSum 和 CalSumV2, 它们都提供了 sum() 方法, Rust 不确定该调用哪一个。
    //println!("Results: {}", s1.sum(1)); // Error:  multiple `sum` found

    // 使用完全限定方法调用：调用 s1 对象对应的 S1 类型实现的 CalSum trait 的 sum 方法或关联函数。
    println!("Results: {}", <S1 as CalSum>::sum(&s1, 1)); // OK
}

let i: i8 = Default::default(); // default() 为 Default trait 的关联函数
let (x, y): (Option<String>, f64) = Default::default();
let (a, b, (c, d)): (i32, u32, (bool, bool)) = Default::default();

#[derive(Default)]
struct SomeOptions {
    foo: i32,
    bar: f32,
}

fn main() {
    // 如果 SomeOptions 没有实现除 Default 外的其它 trait 的 default() 函数或方法, 则 <SomeOptions as
    // Default>::default() 可以简写为 Default::default()，这在 struct 类型赋值表达式中很常用。
    let options: SomeOptions = Default::default();
    let options = SomeOptions { foo: 42, ..Default::default() };
}

// https://eventhelix.com/rust/rust-to-assembly-static-vs-dynamic-dispatch/

// The Shape trait requires that the implementor have a method called `area`
// that returns the area as the associated type `Shape::T`.
pub trait Shape {
    type T;
    fn area(&self) -> Self::T;
}

// A generic Point for a specified type T.
pub struct Point<T> {
    x: T,
    y: T,
}

// A generic Rectangle for a specified type T.
pub struct Rectangle<T> {
    top_left: Point<T>,
    bottom_right: Point<T>,
}

// Implement the Shape trait for the Rectangle using a generic type T.
// The `T` is the return type of the `area` method. The where clause specifies
// that `T` must support subtraction, multiplication and the ability to copy.
impl<T> Shape for Rectangle<T>
where
    T: std::ops::Sub<Output = T> + std::ops::Mul<Output = T> + Copy,
{
    type T = T;
    fn area(&self) -> T {
        let width = self.bottom_right.x - self.top_left.x;
        let height = self.top_left.y - self.bottom_right.y;

        width * height
    }
}

// A function that calculates the area of two shapes and returns a tuple containing the areas.
// This function requires that the two shapes implement the Shape trait. The function will call
// the area function via a static dispatch. Code will be generated for the function only if concrete
// types are specified for `a` and `b`.
pub fn area_pair_static(a: impl Shape<T = f64>, b: impl Shape<T = f64>) -> (f64, f64) {
    (a.area(), b.area())
}

pub fn static_dispatch_pair(a: Rectangle<f64>, b: Rectangle<f64>) -> (f64, f64) {
    // The following line will generate code for the function as concrete types are specified for `a` and `b`.
    area_pair_static(a, b)
}

// This function performs the same function as `area_pair_static` but uses a dynamic dispatch. The compiler
// will generate code for this function. The calls to `area` are made through the `vtable`.
pub fn area_pair_dynamic(a: &dyn Shape<T = f64>, b: &dyn Shape<T = f64>) -> (f64, f64) {
    (a.area(), b.area())
}

struct VTable {
    fn_ptrs: [*const fn],   // 类型实现的 Trait 方法的函数指针
    drop_in_place: fn(*mut ()), // 类型对应的 Drop 析构函数
    size: usize,
    align: usize,
}

// https://zhuanlan.zhihu.com/p/407265957
use std::fmt::{Debug, Display};
use std::mem::transmute;


fn main() {
    let s1 = String::from("hello world!");
    let s2 = String::from("goodbye world!");
    // Display / Debug trait object for s
    let w1: &dyn Display = &s1;
    let w2: &dyn Debug = &s1;


    // Display / Debug trait object for s1
    let w3: &dyn Display = &s2;
    let w4: &dyn Debug = &s2;


    // 强行把 triat object 转换成两个地址 (usize, usize)
    // 这是不安全的，所以是 unsafe
    let (addr1, vtable1) = unsafe { transmute::<_, (usize, usize)>(w1 as *const dyn Display) };
    let (addr2, vtable2) = unsafe { transmute::<_, (usize, usize)>(w2 as *const dyn Debug) };
    let (addr3, vtable3) = unsafe { transmute::<_, (usize, usize)>(w3 as *const dyn Display) };
    let (addr4, vtable4) = unsafe { transmute::<_, (usize, usize)>(w4 as *const dyn Debug) };


    // s 和 s1 在栈上的地址，以及 main 在 TEXT 段的地址
    println!(
        "s1: {:p}, s2: {:p}, main(): {:p}",
        &s1, &s2, main as *const ()
    );
    // trait object(s / Display) 的 ptr 地址和 vtable 地址
    println!("addr1: 0x{:x}, vtable1: 0x{:x}", addr1, vtable1);
    // trait object(s / Debug) 的 ptr 地址和 vtable 地址
    println!("addr2: 0x{:x}, vtable2: 0x{:x}", addr2, vtable2);


    // trait object(s1 / Display) 的 ptr 地址和 vtable 地址
    println!("addr3: 0x{:x}, vtable3: 0x{:x}", addr3, vtable3);


    // trait object(s1 / Display) 的 ptr 地址和 vtable 地址
    println!("addr4: 0x{:x}, vtable4: 0x{:x}", addr4, vtable4);


    // 指向同一个数据的 trait object 其 ptr 地址相同
    assert_eq!(addr1, addr2);
    assert_eq!(addr3, addr4);


    // 指向同一种类型的同一个 trait 的 vtable 地址相同
    // 这里都是 String + Display
    assert_eq!(vtable1, vtable3);
    // 这里都是 String + Debug
    assert_eq!(vtable2, vtable4);
}