/**
 * 泛型代码的性能
 * 泛型并不会使程序比具体类型运行得慢
 * Rust通过在编译时进行泛型代码的单态化(monomorphization)来保证效率，单态化是一个
 * 通过填充编译时使用的具体类型，将通用代码转化为特定代码的过程。
 * 这个过程中，编译器所做的的工作正好与我们创建泛型函数的步骤相反，编译器寻找所有
 * 泛型代码被调用的位置并使用泛型代码针对具体类型生成代码。
 */
fn main() {
    let mut number_list = vec![23, 43, 9978, 100, 89];

    number_list.push(1000);

    let largest_number = largest(&number_list);
    println!("The largest number is {}", largest_number);

    let char_list = vec!['a', 'd', 'c', 'g'];

    let largest_char = largest(&char_list);
    println!("The largest char is {}", largest_char);

    let integer = Point {
        x: 1.0f32,
        y: 1.0f32,
    };

    println!("x: {}, y: {}", integer.x, integer.y);
    println!("y: {}", integer.print_y());
    println!("{}", integer.distance_from_origin());
    println!("x: {}", Point::print_x(integer));

    let p1 = Point { x: 4, y: 10.8 };
    let p2 = Point { x: "Hello", y: 'c' };

    let p3 = p1.mixup(p2);

    println!("p3.x = {}, p3.y = {}", p3.x, p3.y);
}

fn largest<T: std::cmp::PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }

    largest
}

/**
 * 泛型类型参数太多的话代码将难以理解，当你发现代码中需要很多泛型的
 * 时候，这可能表明你的代码需要重构分解成更小的结构了。
 */
struct Point<T, U> {
    x: T,
    y: U,
}

impl<T, U> Point<T, U> {
    fn print_x(point: Point<T, U>) -> T {
        point.x
    }

    fn print_y(&self) -> &U {
        &self.y
    }
}

/**
 * 这个例子的目的是展示一些泛型通过impl声明而另一些同通过方法定义声明的情况。
 * 这里泛型参数X1和Y声明于impl周，因为他们与结构体定义相对应。
 * 而泛型参数X2和Y2声明于fn mixup之后，因为他们只是相对于方法本身的。
 */
impl<X1, Y1> Point<X1, Y1> {
    fn mixup<X2, Y2>(self, other: Point<X2, Y2>) -> Point<X1, Y2> {
        Point {
            x: self.x,
            y: other.y,
        }
    }
}

impl Point<f32, f32> {
    fn distance_from_origin(&self) -> f32 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}