Rust 的impl trait语法详解

struct Point {
    x: f64,
    y: f64,
}
impl Point {
    // 关联函数（没有 self，类似其他语言的静态方法）
    fn new(x: f64, y: f64) -> Self {
        Point { x, y }
    }
    // 方法（有 self 参数）
    fn distance_to(&self, other: &Point) -> f64 {
        ((self.x - other.x).powi(2) + (self.y - other.y).powi(2)).sqrt()
    }
    // 可变方法
    fn translate(&mut self, dx: f64, dy: f64) {
        self.x += dx;
        self.y += dy;
    }
    // 消费 self 的方法
    fn into_tuple(self) -> (f64, f64) {
        (self.x, self.y)
    }
}

trait Area {
    fn area(&self) -> f64;
    // 提供默认实现
    fn describe(&self) -> String {
        format!("面积是 {:.2}", self.area())
    }
}
impl Area for Point {
    fn area(&self) -> f64 {
        0.0 // 点没有面积，示例而已
    }
}
struct Circle { r: f64 }
impl Area for Circle {
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.r * self.r
    }
    // describe() 使用默认实现
}

struct Wrapper<T> {
    value: T,
}
impl<T> Wrapper<T> {
    fn new(value: T) -> Self {
        Wrapper { value }
    }
}

use std::fmt::Display;
impl<T: Display> Wrapper<T> {
    fn show(&self) {
        println!("value = {}", self.value);
    }
}

impl<T> Wrapper<T>
where
    T: Display + Clone,
{
    fn show_cloned(&self) -> String {
        format!("{}", self.value.clone())
    }
}

trait MyInto<T> {
    fn my_into(self) -> T;
}
impl MyInto<String> for i32 {
    fn my_into(self) -> String {
        self.to_string()
    }
}

trait Container {
    type Item;                      // 关联类型
    const CAPACITY: usize = 10;     // 关联常量（可带默认值）
    fn first(&self) -> Option<&Self::Item>;
}
struct MyVec<T> { data: Vec<T> }
impl<T> Container for MyVec<T> {
    type Item = T;
    const CAPACITY: usize = 100;
    fn first(&self) -> Option<&T> {
        self.data.first()
    }
}

// 为引用实现
impl Area for &Circle {
    fn area(&self) -> f64 { (*self).area() }
}
// 为元组实现（二元组是本地的，所以可以）
impl Area for (f64, f64) {
    fn area(&self) -> f64 { self.0 * self.1 }
}

trait Printable {
    fn print(&self);
}
impl<T: std::fmt::Display> Printable for T {
    fn print(&self) {
        println!("{}", self);
    }
}

// 参数位置：接受任意实现 Iterator 的类型（语法糖，等价于泛型）
fn sum(it: impl Iterator<Item = i32>) -> i32 {
    it.sum()
}
// 返回位置：返回某个实现 Iterator 的匿名类型
fn evens() -> impl Iterator<Item = i32> {
    (0..).filter(|x| x % 2 == 0)
}