advance/functional-programing/iterator

[giscus[bot]]

advance/functional-programing/iterator

https://course.rs/advance/functional-programing/iterator.html

[ho-229]

萌新可以提个小建议吗？
在介绍 next 方法那里能不能不以 IntoIterator::next() 作为例子。
首先是上面介绍的是 Iterator::next()，其次是 IntoIterator::next() 会转移元素所有权，而 Iterator::next() 是返回借用。

[sunface]

~~感谢反馈，我记录下，然后回头看看哈～

[dev4mobile]

https://course.rs/advance/functional-programing/iterator.html#:~:text=%E6%B4%BB%E5%AD%A6%E6%B4%BB%E7%94%A8%EF%BC%8C-,%E5%9B%A0%E6%AD%A4%E5%A4%9A%E5%A4%9A%E7%9C%8B%E7%9C%8B%E6%A0%87%E5%87%86%E5%BA%93%E6%98%AF%E6%9C%89%E5%A5%BD%E5%A4%84,-%E7%9A%84%EF%BC%8C%E5%8F%AA%E6%9C%89%E7%9F%A5%E9%81%93

typo 问题： 多了多

[zhangdekui]

↑

[dwpeng]

into_iter不是会夺走所有权吗？为什么下面的代码不会报错？

use std::collections::HashMap;
fn main() {
    let names = ["sunface", "sunfei"];
    let ages = [18, 18];
    let folks: HashMap<_, _> = names.into_iter().zip(ages.into_iter()).collect();
    println!("{:#?}", names);
    println!("{:#?}", ages);
    println!("{:#?}", folks);
}

[dwpeng]

探究了一下：

names类型为 [&str, 2]
ages类型为 [&str, 2]

我是这样理解的，names和ages都存储在栈上，且里面的类型也都存储在栈上，所以默认实现了Copy特征，所以在调用into_iter时没有发生所有权变更，而是进行了Copy

let s1: &str = "abc";
let s2: &str = s1;  // 这里可以看作对`"abc"`的引用
println!("{s1}");  

[DefectingCat]

因为你的例子里用的是数组，且是在编译时已知长度，所以可以实现在栈上，同时也有 Copy 特征。而 Vec 则都是存储在堆上的。

fn main() {
    let names = vec!["sunface", "sunfei"];
    let ages = [18, 18];
    // 两个 names 的地址都一样，指向同一个引用。
    println!("{:?} {:?}", names.as_ptr(), ages.as_ptr());
    // 在这里 names 会发生 move
    let names2 = names;
    let ages2 = ages;
    // println!("{:?} {:?}", names.as_ptr(), ages.as_ptr());
    // 两个 ages 的地址不一样，为 copy
    println!("{:?} {:?}", names2.as_ptr(), ages2.as_ptr())
}

[bqdove]

因为names内部不涉及所有权的转移，所有上述代码可以编译通过。

把这个代码 let names = ["sunface", "sunfei"]; 替换成let names = ["sunface".to_string(), "sunfei".to_string()];立马会报错，不信试试！

[godsoul]

vec里面只有1,2,3 为什么sum是6

[TommyLike]

因为1+2+3等于6?

[godsoul]

是的，想错了，想成count了

[csx12588]

高阶内容学习老费劲了，每一个板块都要一两天

[showyou2023]

let result = match IntoIterator::into_iter(values) {
mut iter => loop { match iter.next() { Some(x) => { println!("{}", x); }, None => break, }
},
};
result
书中的例子。
哪位大佬可以解读此代码吗？真心不明白为什么这样古怪的代码

[1393275769]

 match IntoIterator::into_iter(values) {
        mut iter => loop {...}
}

这里的match模式匹配感觉好费解，这个iter？

[0xDamn]

我理解这里的模式匹配就是一次变量绑定， mut iter可以匹配任何值, 相当于：

let mut iter = IntoIterator::into_iter(values); // 话说回来，let语句就是模式匹配的一种类型
loop {..}

只不过原文中的写法更有rust风格吧：）

[vudsen]

我自己去试了一下，下面的代码可以跑：

let val = 3;
match val {
    any_key => {
        println!("{}", any_key);
    }
}

作者这么写应该是为了看起来更像一个整体吧。。

[ShyunnY]

你看看我这个例子，其实match就是做了一个模式匹配：

// 那么我们也可以模拟一个迭代器来实现遍历获取元素
    {
        let arr = vec![999, 888, 777];

        // 这里进行了一个模式匹配, match匹配了一个变量值并将其绑定到 iter 上
        let ret = match arr.into_iter() {
            mut iter => loop {
                // 通过 loop 循环不断消耗迭代器中的元素, 直到用完
                match iter.next() {
                    Some(val) => println!("arr: {val}"),
                    None => break,
                }
            },
        };
        ret
    }
    {
        // 这个例子解释了上面的语法
        fn add() -> i32 {
            1
        }
        match add() {
            result => {
                println!("{}", result);
            }
        }
    }

[X1r0z]

这里作者 match 的写法感觉太怪了, 换一种方式可能好理解一些?

fn main() {
    let values = vec![1, 2, 3];
    let mut iter = values.into_iter();

    while let Some(i) = iter.next() {
        println!("{i}");
    }
}

[tiantian1645]

struct Counter {
    count: u32,
}

impl Counter {
    fn new() -> Counter {
        Counter { count: 0 }
    }
}

impl Iterator for Counter {
    type Item = u32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.count < 5 {
            self.count += 1;
            dbg!(self.count);
            Some(self.count)
        } else {
            None
        }
    }
}

    let c: Counter = Counter::new();
    println!("cnt: {}", c.count);
    let c_iter = c.into_iter();
    for i in c_iter {
        println!("Got: {}", i);
    }

为什么 c 是不可变的变量 但在for循环中 c.count 可以发生改变

[WayneWu98]

let c_iter = c.into_iter();
// .....
for i in c_iter {
    println!("Got: {}", i);
}

这几行，into_iter 导致所有权移动，而 for i in c_iter 使得 c_iter.into_iter()，c_iter 的所有权再次被移动，循环里的 Counter 已经不是 let c_iter = c.into_iter() 这里的 c_iter 了

[showyou2023]

迭代器是惰性的，只赋值时什么也不会发生。

[daoyee]

其实的疑惑很容易解释，

let c: Counter = Counter::new();  // c 是不可变的
c.count  = 100; // 报错

但是，在Counter 结构体内，通过关联方法，是可以改变count属性值的，
循环里的改变，其是在next方法实现对属性进行改变的。

[JackySu]

这边提一下最后提及的循环展开（Loop Unrolling）和向量化是什么意思，首先阐明概念，循环展开是向量化的一种，向量化还包括有用SSE指令集这里不赘述
上C语言代码举例

#include <stdio.h>
#include <windows.h>
#pragma comment(lib, "Winmm.lib") // for timeGetTime()

#define N 1000000000

int main() {
    DWORD start, end;
    start = timeGetTime();
    int *a = (int *)malloc(N * sizeof(int));

    // conventional loop
    for (int i = 0; i < N; i++) {
        a[i] = i;
    }

    end = timeGetTime();
    printf("Conventional loop time: %d ms\n", end - start);

    start = timeGetTime();
    // unrolled loop
    for (int i = 0; i < N; i += 4) {
        a[i] = i;
        a[i + 1] = i + 1;
        a[i + 2] = i + 2;
        a[i + 3] = i + 3;
    }

    end = timeGetTime();
    printf("Unrolled loop time: %d ms\n", end - start);

    return 0;
}

第二段unrolled loop耗时约为第一段未展开的1/4左右，因为循环中4个语句之间互不影响，所以编译器优化让他们同步执行

[zy010101]

Iterator 和 IntoIterator 的区别

这两个其实还蛮容易搞混的，但我们只需要记住，Iterator 就是迭代器特征，只有实现了它才能称为迭代器，才能调用 next。

而 IntoIterator 强调的是某一个类型如果实现了该特征，它可以通过 into_iter，iter 等方法变成一个迭代器。

可以把这两个Iterator和IntoIterator分别翻译为迭代器和可迭代对象。

[duanyuluo]

不理解为什么用“变成”这个词，难道不是“生成“迭代器么？

[emmettng]

"而 IntoIterator 强调的是某一个类型如果实现了该特征，它可以通过 into_iter，iter 等方法变成一个迭代器。"
这句话表达的确实比较模糊，impl Intoiterator的类型本身，在大多数情况下其实就是一个Wrapper， 这个 Wrapper内含这一个已经实现了Iterator的Type， 而我们想要的就是这个蕴含在其中的Type的 Iterator或者是后接这若干其他迭代器的一个iterator。

[kunlongxu]

fn sum_iter(x: &[f64]) -> f64 {
    x.iter().sum::<f64>()
}

这里的sum::<f64>()是新语法吗? 为什么这写

[XieZongChen]

chatGPT:

在 Rust 中，sum::() 是泛型方法调用的一种语法形式，用于对实现了 Iterator trait 的迭代器进行求和操作。这里的 是用来指定泛型类型参数 T，表示希望将迭代器的元素累加成 T 类型的值。

在这个例子中，sum::() 是对 Iterator trait 的 sum 方法进行泛型调用。这个方法是标准库中 Iterator trait 的方法，用于对迭代器中的元素进行累加，并返回累加的结果。因为迭代器的元素类型是 f64，所以在调用 sum 方法时，我们需要显式指定泛型类型参数 T 为 f64，表示希望将迭代器中的 f64 类型的元素累加成一个 f64 类型的值。

这个语法是在 Rust 1.51 版本中引入的一个新特性，称为「完全限定语法（Fully Qualified Syntax）」。它允许我们在使用泛型方法时显式指定泛型类型参数，使代码更加明确和类型安全。在这之前，类似的效果可以通过类型推导来实现，但在某些情况下可能会出现类型不明确的问题。有了完全限定语法，我们可以直接指定泛型类型参数，避免类型推导的问题。

在旧的语法中，我们可以省略泛型类型参数，因为 Rust 编译器能够根据上下文自动推导出正确的类型。例如，在这个例子中，我们也可以简写成 x.iter().sum()，因为 Rust 编译器可以根据 sum 方法的实现和迭代器中元素的类型 f64 推导出正确的返回类型。但是使用完全限定语法可以明确指定泛型类型参数，让代码更加明确和可读。

[Endermanbugzjfc]

这个不是完全限定
这个应该是 turbo fish 语法

[OC0311]

学到这里 写GO 的又流下了眼泪

[q269384828]

虽然 但是, js里 for ... of 才是针对可迭代对象的语法

[Nakiamii]

想了解Vec怎么变成迭代器，可以参考以下：
1、https://doc.rust-lang.org/std/iter/trait.IntoIterator.html
2、https://doc.rust-lang.org/std/vec/struct.IntoIter.html
3、https://rustwiki.org/zh-CN/src/alloc/vec/into_iter.rs.html#184

[Wyatex]

感觉拿js的for of对比更像一点

[shouriken]

转移所有权

let values = vec![1, 2, 3];
    for v in values.into_iter() {
        println!("{}", v)
    }
    // 下面的代码将报错，因为 values 的所有权在上面 `for` 循环中已经被转移走
    // println!("{:?}",values);

    let values = vec![1, 2, 3];
    for v in values {
        println!("{}", v)
    }
    // 下面的代码将报错，因为 values 的所有权在上面 `for` 循环中已经被转移走
    // println!("{:?}", values);

借用

let values = vec![1, 2, 3];
    for v in values.iter() {
        println!("{}", v)
    }
    // 不会报错，因为 values_iter 只是借用了 values 中的元素
    println!("{:?}", values);

    let values = vec![1, 2, 3];
    for v in &values {
        println!("{}", v)
    }
    // 不会报错，因为 values_iter 只是借用了 values 中的元素
    println!("{:?}", values);

可变借用

let mut values = vec![1, 2, 3];
    // 对 values 中的元素进行可变借用
    for v in values.iter_mut() {
        *v = *v + 1;
    }
    // 输出[2, 3, 4]
    println!("{:?}", values);

    for v in &mut values {
        *v = *v - 1;
    }
    // 输出[1, 2, 3]
    println!("{:?}", values);

[lgln0]

看了Iterator的源码，所有权和生命周期应该是编译器里的概念吧，实际在物理内存上并没有相应的变量，源码中用了各种底层的方法，像unsafe和unchecked。所以迭代器里面有很多概念不好理解，因为没有对应的底层实现，要死记硬背概念。下面简单举两个所有权和生命周期的例子（希望我的语言表述没问题）。

像数组的into_iter(self)方法，是标记了拿走数组所有权，实际上应该是每次调用next()时才具体的拿走每个元素的所有权，离开作用域才一个个元素去drop()。在for循环里，数组不能使用因为其所有权已经被拿走了，哪怕某些元素其实还没有被drop。
同样像数组的iter_mut()方法，是直接进行一段生命周期的可变借用。理论上当next返回了第一个元素的可变借用时，第二个元素仍然可以被借用，但由于数组整体已经有个可变借用，所以在for循环里不能借用第二个元素。解决方法在智能指针章节的Cell/RefCell里，利用内部可变性。

举例：如下代码无法编译，因为在for里面已经标记了数组整体的可变借用

fn main() {
    let mut s = vec!["1".to_owned(), "2".to_string(), "3".to_string()];
    for (i, st) in s.iter_mut().enumerate() {
        if i == 2 {break};
        st.push('a');
        println!("{:?}, {:?}", st, s[2]);
    }
}

[NickNYU]

这两个bench mark test不是很严谨，其中产生随机数的代码，可能会导致计算结果的变动：

fn rand_array(cnt: u32) -> Vec<f64> {
        let mut rng = thread_rng();
        (0..cnt).map(|_| rng.gen::<f64>()).collect()
    }

    #[bench]
    fn bench_for(b: &mut Bencher) {
        let samples = rand_array(LEN as u32);
        b.iter(|| {
            sum_for(&samples)
        })
    }

    #[bench]
    fn bench_iter(b: &mut Bencher) {
        let samples = rand_array(LEN as u32);
        b.iter(|| {
            sum_iter(&samples)
        })
    }

[skb666]

实际在我电脑上跑多次的结果确实不稳定

running 2 tests
test bench::bench_for  ... bench:   1,078,410.00 ns/iter (+/- 49,314.25)
test bench::bench_iter ... bench:   1,084,358.75 ns/iter (+/- 96,045.24)

running 2 tests
test bench::bench_for  ... bench:   1,089,197.50 ns/iter (+/- 93,660.75)
test bench::bench_iter ... bench:   1,090,872.50 ns/iter (+/- 62,411.25)

running 2 tests
test bench::bench_for  ... bench:   1,097,516.25 ns/iter (+/- 78,559.88)
test bench::bench_iter ... bench:   1,077,560.02 ns/iter (+/- 48,337.12)

想知道怎样改代码才能稳定跑出结果

[AllenWu233]

习题在英文版：https://practice.course.rs/functional-programing/iterator.html
答案：https://github.com/sunface/rust-by-practice/blob/master/solutions/functional-programing/iterator.md

[FlandreLiao]

差点以为没有习题

[justin-z0]

names.into_iter().zip(ages.into_iter()).collect();
这种用法显得过于啰嗦了，没有 python 的 zip 来得干脆明了。

[juilletVent]

好家伙，生命周期、迭代器两个小节学了两天...这难度噶一下就上来了...

对于文章里面说的：Iterator 和 IntoIterator 的区别 这一小节：前者是迭代器，可以调用Next方法进行迭代，而后者是可以调用 into_iter 方法产出迭代器（是否会消耗掉调用者，取决于调用方法），区别就这么点儿。

推荐大家边看边写，边验证，手动实现一下三种类型的迭代器，应该会比单纯的看要理解的深刻一些，比如像下面就是我“理解”之后，为的自定义类型实现的三个迭代器（为了学习，没有简洁实用Vec自带的迭代器，如果是项目考虑，肯定是直接用Vec的就可以了）：

// lib.rs
pub mod net_lib {
    #[derive(Debug)]
    pub struct NetState {
        pub is_connected: bool,
        pub link_address: Vec<String>,
    }

    impl NetState {
        // 获取：不可变借用迭代器
        pub fn iter(&self) -> NetIter {
            self.into_iter()
        }

        // 获取：可变借用迭代器
        pub fn iter_mut(&mut self) -> NetMutIter {
            self.into_iter()
        }

        // 获取：消耗迭代器
        // into_iter 方法使用 IntoIterator Trait 实现，因此可以实现消耗迭代器
        // fn into_iter(self) -> IntoNetIter;
    }

    //  ======================================= 消耗迭代器 =======================================
    pub struct IntoNetIter {
        pub remaining: Vec<String>,
    }

    // 实现迭代器 Trait
    impl Iterator for IntoNetIter {
        type Item = String;

        fn next(&mut self) -> Option<Self::Item> {
            self.remaining.pop()
        }
    }
    // 实现 IntoIterator 接口，适配 for 语法糖
    impl IntoIterator for NetState {
        type Item = String;
        type IntoIter = IntoNetIter;
        // 此处 self 类型是 NetState，因此调用into_iter时会出现所有权转移（消耗掉上下文对象）
        fn into_iter(self) -> Self::IntoIter {
            IntoNetIter {
                remaining: self.link_address.into_iter().rev().collect(),
            }
        }
    }

    //  ======================================= 可变借用迭代器 =======================================
    pub struct NetMutIter<'a> {
        pub remaining: &'a mut [String],
    }
    // 实现迭代器 Trait
    impl<'a> Iterator for NetMutIter<'a> {
        type Item = &'a mut String;
        fn next(&mut self) -> Option<Self::Item> {
            if self.remaining.is_empty() {
                None
            } else {
                let all_slice = std::mem::take(&mut self.remaining);
                let (first, rest) = all_slice.split_first_mut()?;
                self.remaining = rest;
                Some(first)
            }
        }
    }
    // 使用IntoIterator 接口，适配 for 语法糖
    impl<'a> IntoIterator for &'a mut NetState {
        type Item = &'a mut String;
        type IntoIter = NetMutIter<'a>;
        // 此处 self 类型是 &'a mut NetState，因此调用into_iter时不会出现所有权转移（不消耗掉上下文对象）
        fn into_iter(self) -> Self::IntoIter {
            NetMutIter {
                remaining: &mut self.link_address[..],
            }
        }
    }

    //  ======================================= 借用迭代器 =======================================
    pub struct NetIter<'a> {
        pub remaining: &'a [String],
    }
    // 实现迭代器
    impl<'a> Iterator for NetIter<'a> {
        type Item = &'a String;

        fn next(&mut self) -> Option<Self::Item> {
            if self.remaining.is_empty() {
                None
            } else {
                let all_slice = std::mem::take(&mut self.remaining);
                let (first, rest) = all_slice.split_first()?;
                self.remaining = rest;
                Some(first)
            }
        }
    }
    // 实现IntoIterator接口，适配for语法糖
    impl<'a> IntoIterator for &'a NetState {
        type Item = &'a String;
        type IntoIter = NetIter<'a>;

        fn into_iter(self) -> Self::IntoIter {
            NetIter {
                remaining: &self.link_address[..],
            }
        }
    }
}

// main.rs
use test_base_1::net_lib;

fn main() {
    let mut connect_info = net_lib::NetState {
        is_connected: true,
        link_address: vec!["192.168.1.1".to_string(), "192.168.1.2".to_string()],
    };

    for addr in connect_info.iter() {
        println!("不可变借用迭代 -> {addr}");
    }

    for addr in connect_info.iter_mut() {
        *addr = format!("{addr} modified");
        println!("可变借用迭代 -> {addr}");
    }

    println!("{connect_info:#?}");

    for addr in connect_info.into_iter() {
        println!("消耗迭代 -> {addr}");
    }

    // 编译错误，因为 connect_info 的所有权已经被消耗掉了
    // println!("{connect_info:#?}");
}

加油兄弟萌，后面还有更难的 🤣🤣