Rust ~ Collect

背景

Transforms an iterator into a collection
将一个迭代器转换为一个集合
collect() 可以处理任何可迭代的对象，并将其转换为相关的集合

collect() 最基本模式是将一个集合转换为另一个集合：
先获取一个集合，对其调用 iter 方法，进行转换操作，最后调用 collect()

collect() 还可以创建非典型集合类型的实例。
可以从 char 构建一个 String
可以将由 Result<T, E> 元素组成的迭代器收集到 Result<Collection<T>, E> 中

collect() 的通用性很强，可能会导致类型推断出现问题，因此（As such），collect() 是少数几种会看到被称为“涡轮鱼”语法 ::<> 的情况之一
这有助于类型推断算法明确你要收集到的具体集合类型。
Because collect() is so general, it can cause problems with type inference. As such, collect() is one of the few times you’ll see（少数几种会看到的情况之一） the syntax affectionately known as the ‘turbofish’: ::<>. This helps the inference algorithm understand specifically which collection you’re trying to collect into.

定义

fn collect<B: FromIterator<Self::Item>>(self) -> B
where
    Self: Sized,
{
    FromIterator::from_iter(self)
}

示例

从 char 构建 String

fn main() {
    // 定义一个包含多个 char 元素的数组
    let chars = ['H', 'e', 'l', 'l', 'o'];

    // 使用 collect() 方法将字符数组转换为 String
    let hello_string: String = chars.iter().cloned().collect();

    // 输出结果
    println!("构建的字符串是: {}", hello_string);
}

将 Result<T, E> 元素组成的迭代器收集到 Result<Collection<T>, E> 中

use std::result::Result;

fn main() {
    // 定义一个包含多个 Result 元素的数组
    let results: [Result<i32, &str>; 3] = [Ok(1), Ok(2), Ok(3)];

    // 使用 collect() 方法将 Result 数组收集到一个新的 Result 中
    let collection_result: Result<Vec<i32>, &str> = results.iter().cloned().collect();

    match collection_result {
        Ok(values) => {
            println!("收集到的元素是: {:?}", values);
        }
        Err(error) => {
            println!("收集过程中出现错误: {}", error);
        }
    }

    // 包含错误元素的情况
    let error_results: [Result<i32, &str>; 3] = [Ok(1), Err("出错啦"), Ok(3)];
    let error_collection_result: Result<Vec<i32>, &str> = error_results.iter().cloned().collect();

    match error_collection_result {
        Ok(values) => {
            println!("收集到的元素是: {:?}", values);
        }
        Err(error) => {
            println!("收集过程中出现错误: {}", error);
        }
    }
}

源码中的示例

fn main() {
    let a = [1, 2, 3];
    let doubled: Vec<i32> = a.iter().map(|&x| x * 2).collect();
    assert_eq!(vec![2, 4, 6], doubled);

    use std::collections::VecDeque;
    let a = [1, 2, 3];
    let doubled: VecDeque<i32> = a.iter().map(|&x| x * 2).collect();
    assert_eq!(2, doubled[0]);
    assert_eq!(4, doubled[1]);
    assert_eq!(6, doubled[2]);


    let a = [1, 2, 3];
    let doubled = a.iter().map(|x| x * 2).collect::<Vec<i32>>();
    assert_eq!(vec![2, 4, 6], doubled);


    let a = [1, 2, 3];
    let doubled = a.iter().map(|x| x * 2).collect::<Vec<_>>();
    assert_eq!(vec![2, 4, 6], doubled);

    let chars = ['g', 'd', 'k', 'k', 'n'];
    let hello: String = chars.iter().map(|&x| x as u8).map(|x| (x + 1) as char).collect();
    assert_eq!("hello", hello);


    use std::result::Result;
    let results = [Ok(1), Err("nope"), Ok(3), Err("bad")];
    let result: Result<Vec<_>, &str> = results.iter().cloned().collect();
    // gives us the first error
    assert_eq!(Err("nope"), result);
    
    let results = [Ok(1), Ok(3)];
    let result: Result<Vec<_>, &str> = results.iter().cloned().collect();
    // gives us the list of answers
    assert_eq!(Ok(vec![1, 3]), result);
}

什么是 turbofish～涡轮鱼语法 ::<>

turbofish涡轮鱼语法 ::<> 是一种用于帮助编译器进行类型推断的语法糖，主要在泛型类型的上下文中使用，特别是在调用泛型函数或方法时，当编译器无法自动推断出具体的泛型参数类型时，就可以使用 “涡轮鱼” 语法来显式地指定泛型参数。

为什么需要 “涡轮鱼” 语法

Rust 编译器有强大的类型推断能力，很多时候可以自动推断出泛型参数的具体类型，但在某些复杂的场景下，编译器可能无法准确推断。例如，当调用一个泛型方法，该方法可以返回多种不同类型的结果时，编译器就需要额外的信息来确定具体的类型。这时，“涡轮鱼” 语法就派上用场了，它允许开发者显式地指定泛型参数，从而帮助编译器消除类型歧义。

“涡轮鱼” 语法的使用场景

collect 方法

collect 是 Rust 标准库中一个非常常用的方法，用于将一个迭代器转换为一个集合。由于 collect 方法可以返回多种不同类型的集合，编译器有时无法自动推断出具体的集合类型，这时就需要使用 “涡轮鱼” 语法来指定。

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    // 使用“涡轮鱼”语法显式指定泛型参数为 Vec<i32>
    let squared: Vec<i32> = numbers.iter().map(|x| x * x).collect::<Vec<i32>>();
    println!("{:?}", squared);
}

collect 方法可以将迭代器的元素收集到多种不同类型的集合中，如 Vec、HashSet 等。
通过使用 “涡轮鱼” 语法 ::<Vec<i32>>，明确告诉编译器要将元素收集到一个 Vec 类型的集合中

泛型函数调用

当调用泛型函数时，如果编译器无法推断出泛型参数的具体类型，也可以使用 “涡轮鱼” 语法来指定。

fn identity<T>(x: T) -> T {
    x
}

fn main() {
    // 使用“涡轮鱼”语法显式指定泛型参数为 i32
    let result = identity::<i32>(42);
    println!("{}", result);
}

identity 是一个泛型函数，它接受一个类型为 T 的参数并返回该参数。通过使用 “涡轮鱼” 语法 ::<i32>，明确告诉编译器 T 的具体类型是 i32。

部分类型提示与 “涡轮鱼” 语法

在某些情况下，可能只需要部分指定泛型参数的类型，这时可以使用 _ 作为占位符。

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    // 使用部分类型提示，让编译器推断元素类型
    let squared = numbers.iter().map(|x| x * x).collect::<Vec<_>>();
    println!("{:?}", squared);
}

collect::<Vec<_>> 表示要将元素收集到一个 Vec 类型的集合中，但具体的元素类型由编译器根据上下文自动推断。
综上所述，

总结

“涡轮鱼” 语法 ::<> 是 Rust 中一种用于显式指定泛型参数的有用工具，它可以帮助编译器消除类型歧义，使代码更加清晰和易于理解。