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())
}

[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
书中的例子。
哪位大佬可以解读此代码吗？真心不明白为什么这样古怪的代码

[ghost]

这一段其实就相当于下面代码的内部实现

    for i in values.into_iter() {
        println!("{}", i);
    }

IntoIterator::into_iter(values) 返回的是 IntoIter<i32>，等同于 values.into_iter()。匹配之后，进入循环，然后依次调用迭代器中每一个值的 next 方法，进而判断是否循环到最后一个值，即匹配 None 从而跳出循环，在此间也在每一个循环里打印出了 x。

[1393275769]

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

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

[0xDamn]

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

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

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

[IceOfSummer]

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

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

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

[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)
        })
    }