深入了解Rust中泛型的使用

// 这种定义方式是错误的，因为 T 不在作用域中
// 我们要将其放在签名里面
fn func(arg: T) -> T {
    arg 
}

// 这样做是正确的
fn func<T>(arg: T) -> T {
    arg
}

fn func(arg: &str) -> &str {
    arg
}

// 如果有多个泛型，那么在 <> 里面通过逗号分隔
// 然后要保证函数签名 <> 里面声明的泛型，
// 都要在函数参数中出现，也就是要将定义的泛型全用上
fn func<A, B, C>(
    arg1: A, arg2: B, arg3: C
) -> (C, A) {
    (arg3, arg1)
}

fn main() {
    // 函数 func 定义了三个泛型，然后返回的类型是 (C, A)
    // 这里传递三个参数，显然当调用时，Rust 会确定泛型代表的类型
    // A 是 i32，B 是 f64，C 是 &str
    let x = func(123, 3.14, "你好");

    // 泛型可以接收任何类型，那么当调用时
    // A 是 Vec<i32>，B 是 [i32;2]，C 是 (i32, i32)
    let y = func(vec![1, 2], [1, 2], (3, 4));
}

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

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

fn main() {
    let p1 = Point{x: 11, y: 22};
    let p2 = Point{x: 11.1, y: 22.2};
}

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

fn main() {
    // x 和 y 的类型可以相同，也可以不同
    // 因为它们都可以接收任意类型
    let p1 = Point{x: 11, y: 22};
    let p2 = Point{x: 11.1, y: 22.2};
    let p3 = Point{x: "11.1", y: String::from("satori")};
    let p3 = Point{x: vec![1, 2, 3], y: (1, 2, 3)};
}

enum Option<T> {
    Some(T),
    None
}

// 签名中的泛型参数必须都要使用
// 比如函数签名的泛型，要全部体现在参数中
// 枚举和结构体签名的泛型，要全部体现在成员中
enum MyOption<A, B, C> {
    // 这里 A、B、C 都是我们随便定义的，可以代指任意类型
    // 具体是哪种类型，则看我们传递了什么
    Some1(A),
    Some2(B),
    Some3(C),
}

fn main() {
    // 泛型不影响效率，是因为 Rust 要进行单态化
    // 所以泛型究竟代表哪一种类型要提前确定好
    // 这里必须要显式指定 x 的类型。枚举和结构体不同
    // 结构体每个成员都要赋值，所以 Rust 能够基于赋的值推断出所有的泛型
    // 但枚举的话，每次只会用到里面的一个成员
    // 如果还有其它泛型，那么 Rust 就无法推断了
    // 比如这里只能推断出泛型 C 代表的类型，而 A 和 B 就无法推断了
    // 因此每个泛型代表什么类型，需要我们手动指定好
    let x: MyOption<i32, f64, u8> = MyOption::Some3(123);
    match x {
        MyOption::Some1(v) => println!("我是 i32"),
        MyOption::Some2(v) => println!("我是 f64"),
        MyOption::Some3(v) => println!("我是 u8"),
    }

    // 泛型可以代表任意类型，指定啥都是可以的
    let y: MyOption<u8, i32, String> =
        MyOption::Some3(String::from("xxx"));
    match y {
        MyOption::Some1(v) => println!("我是 u8"),
        MyOption::Some2(v) => println!("我是 i32"),
        MyOption::Some3(v) => println!("我是 String"),
    }
    
    /*
    我是 u8
    我是 String
    */
}

enum MyOption<T> {
    MySome1(T),
    MySome2(i32),
    MySome3(T),
    MyNone
}

fn main() {
    // 这里我们没有指定 x 的类型
    // 这是因为 MyOption 只有一个泛型
    // 通过给 MySome1 传递的值，可以推断出 T 的类型
    let x = MyOption::MySome1(123);

    // 同样的道理，Rust 可以自动推断，得出 T 是 &str
    let x = MyOption::MySome3("123");

    // 但此处就无法自动推断了，因为赋值的是 MySome2 成员
    // 此时 Rust 获取不到任何有关 T 的信息，无法执行推断
    // 因此我们需要手动指定类型，但仔细观察一下声明
    // 首先，如果没有泛型的话，那么直接 let x: MyOption = ... 即可
    // 但里面有泛型，所以此时除了类型之外，还要连同泛型一起指定
    // 也就是 MyOption<f64>
    let x: MyOption<f64> = MyOption::MySome2(123);

    // 当然泛型可以代表任意类型，此时的 T 则是一个 Vec<i32> 类型
    let x: MyOption<Vec<i32>> = MyOption::MySome2(123);
}

struct Girl1 {
    field: i32,
}

struct Girl2<T> {
    field: T,
}

fn main() {
    // 下面两个语句类似，只是第二次声明 g1 的时候多指定了类型
    let g1 = Girl1 { field: 123 };
    let g1: Girl1 = Girl1 { field: 123 };

    // 下面两条语句也是类似的，第二次声明 g2 的时候多指定了类型
    // 但此时的类型有些不一样，Girl2 的结尾多了一个 <i32>
    // 原因很简单，因为 Girl2 里面有泛型
    // 所以在显式指定类型的时候，还要将泛型代表的类型一块指定，否则报错
    let g2 = Girl2 { field: 123 };
    let g2: Girl2<i32> = Girl2 { field: 123 };
}

struct Girl<E, T, W> {
    field1: String,
    field2: T,
    field3: W,
    field4: E,
    field5: i32,
}

fn main() {
    // 这里可以不指定类型，因为 Rust 可以推断出来
    // 不过这里我们就显式指定。而虽然 Girl 有 5 个成员
    // 但泛型的数量是三个，因此声明变量的时候也要指定三个
    // 由于定义结构体的时候，泛型顺序是 E T W
    // 所以这里的 f64 就是 E，u8 就是 T，Vec<i32> 就是 W
    let g: Girl<f64, u8, Vec<i32>> = Girl {
        field1: String::from("hello"),
        field2: 123u8,
        field3: vec![1, 2, 3],
        field4: 3.14,
        field5: 666,
    };
}

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

// 针对 i32、f64 实现的方法
// 只有传递的 T、U 对应 i32、f64 才可以调用
impl Point<i32, f64> {
    fn m1(&self) {
        println!("我是 m1 方法")
    }
}

fn main() {
    let p1 = Point{x: 123, y: 3.14};
    p1.m1();  // 我是 m1 方法

    let p2 = Point{x: 3.14, y: 123};
    //p2.m1();
    //调用失败，因为 T 和 U 不是 i32、f64，而是 f64、i32
    //所以 p2 无法调用 m1 方法
}

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

// 针对 K、f64 实现的方法，由于 K 是一个泛型
// 所以它可以代表任何类型（泛型只是一个符号）
// 因此不管 T 最终是什么类型，i32 也好、&str 也罢
// K 都可以接收，只要 U 是 f64 即可
// 然后注意：如果声明方法时结构体后面指定了泛型
// 那么必须将使用的泛型在 impl 后面声明
impl <K> Point<K, f64> {
    fn m1(&self) {
        println!("我是 m1 方法")
    }
}

// 此时 K 和 S 都是泛型，那么此时对结构体就没有要求了
// 因为不管 T 和 W 代表什么，K 和 S 都能表示，因为它们都是泛型
impl <K, S> Point<K, S> {
    fn m2(&self) {
        println!("我是 m2 方法")
    }
}

// 这里我们没有使用泛型，所以也就无需在 impl 后面声明
// 但很明显，此时结构体实例如果想调用 m3 方法
// 那么必须满足 T 是 u8，W 是 f64
impl Point<u8, f64> {
    fn m3(&self) {
        println!("我是 m3 方法")
    }
}

fn main() {
    // 显然 p1 可以同时调用 m1 和 m2 方法，但 m3 不行
    // 因为 m3 要求 T 是一个 u8，而当前是 &str
    let p1 = Point{x: "hello", y: 3.14};
    p1.m1();  // 我是 m1 方法
    p1.m2();  // 我是 m2 方法

    // 显然 p2 可以同时调用 m1、m2、m3
    // 另外这里的 x 可以直接写成 123，无需在结尾加上 u8
    // 因为 Rust 看到我们调用了 m3 方法，会自动推断为 u8
    let p2 = Point{x: 123u8, y: 3.14};
    p2.m1();  // 我是 m1 方法
    p2.m2();  // 我是 m2 方法
    p2.m3();  // 我是 m3 方法

    // 显然 p3 只能调用 m2 方法，因为 m2 对 T 和 W 没有要求
    // 但是像 m3 就不能调用，因为它是为 <u8, f64> 实现的方法
    // 只有当 T、W 为 u8、f64 时才可以调用
    // 显然此时是不满足的，因为都是 &str，至于 m1 方法也是同理
    // 所以 p3 只能调用 m2，这个方法是为 <K, S> 实现的
    // 而 K 和 S 也是泛型，可以代表任意类型，因此没问题
    let p3 = Point{x: "3.14", y: "123"};
    p3.m2();  // 我是 m2 方法
}

#[derive(Debug)]
struct Point<T, U> {
    x: T,
    y: U,
}

// 使用 impl 时 Point 后面的泛型名称可以任意
// 比如我们之前起名为 K 和 S，但这样容易乱，因为字母太多了
// 所以建议：使用 impl 时的泛型和定义结构体时的泛型保持一致即可
impl<T, U> Point<T, U> {
    // 方法类似于函数，它是一个独立的个体，可以有自己独立的泛型
    // 然后返回值，因为 Point 里面是泛型，可以代表任意类型
    // 那么自然也可以是其它的泛型
    fn m1<V, W>(self, a: V, b: W) -> Point<U, W> {
        // 所以返回值的成员 x 的类型是 U，那么它应该来自于 self.y
        // 成员 y 的类型是 W，它来自于参数 b
        Point { x: self.y, y: b }
    }
}

fn main() {
    // T 是 i32，U 是 f64
    let p1 = Point { x: 123, y: 3.14 };
    // V 是 &str，W 是 (i32, i32, i32)
    println!("{:?}", p1.m1("xx", (1, 2, 3)))
    // Point { x: 3.14, y: (1, 2, 3) }
}