let numbers = vec![1, 2, 3];

// 這里的 `numbers.iter()` 就創(chuàng)建了一個迭代器
for num in numbers.iter() {
    println!("Got: {}", num);
}

pub trait Iterator {
    // 1. 關(guān)聯(lián)類型：告訴 Rust 你迭代的“東西”是什么類型
    type Item; 

    // 2. 核心方法：獲取下一個元素
    // 這是你唯一必須實現(xiàn)的方法！
    fn next(&mut self) -> Option<Self::Item>;

    // --- 下面還有很多其他方法 (map, filter, sum...) ---
    // 但它們都有默認(rèn)實現(xiàn)，你暫時不用管！
}

// 我們的計數(shù)器結(jié)構(gòu)體
struct Counter {
    current: u32,
    max: u32,
}

// 順便給它一個 "構(gòu)造函數(shù)" (new)
impl Counter {
    fn new(max: u32) -> Counter {
        Counter { current: 1, max } // 我們從 1 開始數(shù)
    }
}

impl Iterator for Counter {
    // 1. 告訴 Rust 我們迭代的是 u32
    type Item = u32;

    // 2. 實現(xiàn)核心邏輯！
    fn next(&mut self) -> Option<Self::Item> {
        if self.current <= self.max {
            // 只要當(dāng)前值 <= 5
            
            // 準(zhǔn)備好要返回的當(dāng)前值
            let val_to_return = self.current; 
            
            // 更新狀態(tài)：讓 current + 1，為下一次做準(zhǔn)備
            self.current += 1; 

            // 把值用 Some() 包裹起來返回
            Some(val_to_return)
        } else {
            // 如果 current 已經(jīng) > max (比如到了 6)
            // 迭代結(jié)束！返回 None
            None
        }
    }
}

fn main() {
    let counter = Counter::new(5); // 創(chuàng)建一個 1 到 5 的計數(shù)器

    // `for` 循環(huán)現(xiàn)在可以識別我們的 Counter 了！
    println!("Running for loop:");
    for number in counter {
        println!("{}", number);
    }
    
    // 注意：`for` 循環(huán)會“消耗掉”迭代器。
    // 如果想再用一次，需要重新創(chuàng)建：
    let counter2 = Counter::new(3);
    
    // 你也可以手動調(diào)用 next() 看看發(fā)生了什么
    println!("\nManual next() calls:");
    let mut counter3 = Counter::new(2); // 必須是 mut，因為 next() 需要 &mut self
    println!("{:?}", counter3.next()); // Some(1)
    println!("{:?}", counter3.next()); // Some(2)
    println!("{:?}", counter3.next()); // None (迭代結(jié)束)
    println!("{:?}", counter3.next()); // None (之后永遠(yuǎn)是 None)
}

Running for loop:
1
2
3
4
5

Manual next() calls:
Some(1)
Some(2)
None
None

let my_list = MyList::new();
for item in &my_list { // 注意這里是 &my_list
    // ...
}

// 我們的集合
struct MyList {
    items: Vec<String>,
}

impl MyList {
    fn new() -> Self {
        Self {
            items: vec![
                "Rust".to_string(),
                "is".to_string(),
                "Awesome".to_string(),
            ],
        }
    }
}

// ------------------------------------
// 專門為 MyList 服務(wù)的迭代器結(jié)構(gòu)體
// 它需要“借用” MyList 的數(shù)據(jù)
// 'a 是生命周期，表示它借用的數(shù)據(jù)至少和 'a 活得一樣久
struct MyListIter<'a> {
    list: &'a MyList, // 持有對 MyList 的引用
    index: usize,    // 跟蹤迭代到第幾個了
}

// 'a 也要在這里聲明
impl<'a> Iterator for MyListIter<'a> {
    // 這一次，我們迭代的是對 String 的引用
    type Item = &'a String;

    fn next(&mut self) -> Option<Self::Item> {
        if self.index < self.list.items.len() {
            // 還有元素
            let item = &self.list.items[self.index];
            self.index += 1;
            Some(item)
        } else {
            // 沒元素了
            None
        }
    }
}

// 為 &MyList (對 MyList 的不可變引用) 實現(xiàn) IntoIterator
impl<'a> IntoIterator for &'a MyList {
    // 迭代項還是 &String
    type Item = &'a String; 
    
    // 告訴 for 循環(huán)：你調(diào)用 into_iter() 時，
    // 我會返回一個 MyListIter<'a> 實例
    type IntoIter = MyListIter<'a>; 

    // `for` 循環(huán)會自動調(diào)用這個方法！
    // 這里的 self 就是 &'a MyList
    fn into_iter(self) -> Self::IntoIter {
        // 創(chuàng)建我們剛才定義的迭代器實例
        MyListIter {
            list: self, // self 就是 &MyList
            index: 0,   // 從 0 開始
        }
    }
}

fn main() {
    let my_list = MyList::new();
    
    // 感謝 IntoIterator，這行代碼現(xiàn)在可以完美工作了！
    // 1. `for` 循環(huán)看到 &my_list
    // 2. 它調(diào)用 (&my_list).into_iter()
    // 3. 我們的代碼返回了一個 MyListIter
    // 4. `for` 循環(huán)不斷調(diào)用 MyListIter.next()
    for item in &my_list {
        println!("Item: {}", item);
    }
}

let sum: u32 = Counter::new(5)     // 我們的迭代器 (1, 2, 3, 4, 5)
    .zip(Counter::new(5).skip(1)) // ( (1,2), (2,3), (3,4), (4,5) )
    .map(|(a, b)| a * b)          // ( 2, 6, 12, 20 )
    .filter(|x| *x > 10)         // ( 12, 20 )
    .sum();                      // 12 + 20 = 32

println!("The complex sum is: {}", sum); // 32