RUST 每日一省：泛型

泛型是指把类型抽象成一种“参数”，数据和算法都针对这种抽象的类型参数来实现，而不针对具体类型。当我们需要真正使用的时候，再具体化、实例化类型参数。使用泛型可以编写更为抽象的代码，减少工作量。

Rust中的泛型属于静多态，它是一种编译期多态。在编译期，不管是泛型枚举，还是泛型函数和泛型结构体，都会被单态化。单态化是编译器进行静态分发的一种策略。

使用不同类型参数将泛型类型单体化后，获得的是完全不同的具体类型。如Option<i32>和Option<i64>是完全不同的类型，不可通用，也不可相互转换。当编译器生成代码的时候，它会为每一个不同的泛型参数生成不同的代码。

泛型容器

最常见的泛型应用莫过于容器，Vec<T>、HashMap<K, V>都是泛型类型的应用。比如，Vec<T>在使用中可以指定T的类型为i32或String等——Vec<i32>或者Vec<String>。

fn main() {
  let mut vec_int: Vec<i32> = vec![10, 20];
  vec_int.push(30);
}

泛型枚举

泛型枚举是指枚举值类型是泛型类型。标准库提供的Option<T>就是一个应用广泛的泛型枚举。Option<T>表示可能有值，也可能无值这一抽象概念，Some(T)表示可能的值可以是任意类型T，None表示不存在。

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

fn output(age:i32) -> Option<i32>{
    if age > 18{
        return Some(age)
    }else{
        return None
    }
}

fn main() {
 let ret1 = output(19);
 println!("{:?}",ret1);
 let ret2 = output(13);
 println!("{:?}",ret2);

}

泛型结构体

泛型类型的结构体是指结构体的字段类型是泛型类型，它可以拥有一个或多个泛型类型。定义泛型结构体时，可以在结构体名称后面带上<T>或<T, U>等，在定义字段的类型时使用T或U。我们在定义Num<T, U>时仅使用了两个个泛型，T和U可以相同也可以不同。如果是Nu<T>这个定义表明Nu<T>结构体对某个类型T是通用的。字段data与num都同时属于这个类型。假如我们像下边注释掉的代码一样使用不同的值类型来创建Nu<T>实例，那么代码是无法通过编译的。

#[derive(Debug)]
struct Num<T,U> {
    data: Option<T>,
    num: U
}
#[derive(Debug)]
struct Nu<T> {
    data: Option<T>,
    num: T
}
fn main() {
 let ret = Num{data:Some(1), num:"hello"};
 println!("{:?}",ret);
 //let ret = Nu{data:Some(1), num:"hello"};
 //println!("{:?}",ret);
}

泛型函数

函数的参数和返回值都可以是泛型类型，带有泛型类型的参数或返回值的函数叫作泛型函数。泛型函数不要求所有参数都是泛型，可以只是某个参数是泛型。在定义泛型函数时可以在函数名称后面带上<T>，在定义参数或返回值的类型时使用T。

编译之后的foo(5)和foo("hello".to_string())，分别生成对应的foo函数，fn foo(x:i32)->i32和fn foo(x: String)->String。

fn foo<T>(x: T) -> T {
 return x;
}


fn main() {
 println!("{}", foo(5));
 println!("{}", foo("hello".to_string()));
}

//fn foo(x: i32) -> i32 {
// return x;
//}

//fn foo<T>(x: String) -> String {
// return x;
//}

泛型impl

impl的时候也可以使用泛型。在impl<Trait>for<Type>{}这个语法结构中，泛型类型既可以出现在<Trait>位置，也可以出现在<Type>位置。与其他地方的泛型一样， impl块中的泛型也是先声明再使用。在impl块中出现的泛型参数，需要在impl关键字后面用尖括号声明。

#[derive(Debug)]
struct Container<T> {
    item: T
}

impl<T> Container<T> {
   fn new(item: T) -> Self {
        Container { item }
   }
}
fn main() {
    let c = Container::new(9);
    println!("{:?}",c);
}