听GPT 讲Rust源代码--library/core/src(2)-CSDN博客

题图来自 5 Ways Rust Programming Language Is Used^[1]

File: rust/library/core/src/iter/adapters/by_ref_sized.rs

在Rust的源代码中rust/library/core/src/iter/adapters/by_ref_sized.rs 文件实现了 ByRefSized 适配器该适配器用于创建一个可以以引用的方式访问可迭代对象的迭代器。通过这个适配器可以在不转移可迭代对象的所有权的情况下对其进行迭代和使用。

该文件中定义的几个 struct 分别是 ByRefSizedEnumerateFilter 和 Skip。

1. ByRefSized<'a, I: 'a>这是 ByRefSized 的主要结构体包含了一个可迭代对象 iter 和一个生命周期 'a用于指定引用的有效期。它实现了一些对可迭代对象的引用迭代方法如 next, size_hint, count 等。

2. Enumerate<I>这是一个用于将可迭代对象的元素和其索引一起返回的适配器。它包含了一个 ByRefSized 类型的 iter 和一个计数器 count用于追踪当前元素的索引。通过 Enumerate 适配器可以在迭代过程中同时获得元素和对应的索引。

3. Filter<I, P>这是一个用于根据特定条件过滤可迭代对象的适配器。它包含了一个 ByRefSized 类型的 iter 和一个谓词 P用于确定哪些元素符合条件。通过 Filter 适配器可以对可迭代对象进行筛选只保留满足条件的元素。

4. Skip<I>这是一个用于跳过可迭代对象前 n 个元素的适配器。它包含了一个 ByRefSized 类型的 iter 和一个计数器 n用于记录已经跳过的元素数量。通过 Skip 适配器可以在迭代过程中跳过指定数量的元素。

总体而言rust/library/core/src/iter/adapters/by_ref_sized.rs 文件中的这些结构体为可迭代对象提供了一些常用的适配器操作例如引用迭代、索引元素和过滤元素等。它们可以方便地组合使用使得对可迭代对象的操作更加灵活和高效。

File: rust/library/core/src/iter/adapters/map.rs

rust/library/core/src/iter/adapters/map.rs文件是Rust中的一个适配器adapter用于对迭代器进行映射操作。

该文件主要定义了一个名为Map的结构体和相关的trait实现用以生成一个新的迭代器通过对原始迭代器的元素进行映射操作来产生新的元素。

在map.rs文件中Map结构体作为一个迭代器适配器实现了Iterator trait在迭代过程中将迭代器的元素进行映射操作并生成新的元素。

Map结构体的定义如下

pub struct Map<I, F> { ... }

其中I表示原始迭代器的类型F表示映射操作的闭包或者函数指针。Map结构体具有以下重要的方法和特征

• fn new(iter: I, f: F) -> Map<I, F>构造函数用于创建一个Map结构体的实例。
• fn iter(&mut self) -> &mut I返回可变借用的原始迭代器可以通过该方法修改迭代器的状态。
• fn into_inner(self) -> I将Map结构体消耗并返回原始迭代器这在需要获取原始迭代器的所有权时非常有用。
• impl<I, F, B> Iterator for Map<I, F> where I: Iterator, F: FnMut(I::Item) -> B实现Iterator trait使得Map结构体可以被直接用于for循环或其他支持迭代器的方法。

此外在map.rs文件中还定义了一些辅助结构体和trait实现用于支持映射操作的处理流程。这些结构体和trait的作用包括

• MapOp表示映射操作。它具有一个名为 call的方法用于执行映射操作。
• MapCollect表示映射操作的消费consume版本。它具有一个名为 call的方法用于执行映射操作并返回新的集合。
• MapWith表示映射操作以及附加状态。它具有一个名为 call的方法用于执行映射操作并获取和修改状态。
• MapFuse表示映射操作的延迟执行版本。它具有一个名为 call的方法用于执行映射操作并返回一个延迟执行的结果。

总结而言rust/library/core/src/iter/adapters/map.rs文件定义了Map结构体和相关的trait实现用于生成一个新的迭代器通过对原始迭代器的元素进行映射操作来产生新的元素。这样可以在迭代过程中对元素进行更加灵活的处理满足各种复杂的需求。

File: rust/library/core/src/iter/adapters/cloned.rs

在Rust的标准库中cloned.rs文件定义了一系列适配器adapters用于克隆clone迭代器中的元素。迭代器是Rust中非常重要的一个概念它用于遍历各种集合像数组、矢量或哈希集等。克隆迭代器适配器允许消费原始迭代器并以克隆的方式生成一个新的迭代器。

具体来说cloned.rs文件中主要定义了一个名为Cloned<I>的结构体该结构体实现了迭代器Iterator特性并封装了一个原始迭代器I。它的作用是克隆原始迭代器中的元素并生成一个产生克隆副本的新迭代器。

在Rust中某些类型比如引用类型不具备Copy特性意味着它们在拷贝时会转移所有权。使用Cloned适配器可以避免转移所有权的问题因为它会克隆每个元素而不是简单地拷贝。这在某些场景下非常有用比如希望对原始集合进行遍历但不想修改它们的值。

Cloned<I>结构体还包含了一些方法用于实现迭代器特性中的相关函数。例如next()方法用于获取下一个克隆的元素size_hint()方法用于提供迭代器的大小估计等。这些方法允许对克隆迭代器进行遍历和操作。

总结起来cloned.rs文件中的Cloned<I>结构体及其相关方法定义了一个适配器用于生成一个产生克隆副本的新迭代器。这有助于在使用不具备Copy特性的类型时对原始集合进行遍历和操作而不会转移所有权。

File: rust/library/core/src/iter/adapters/rev.rs

在Rust源代码中rev.rs文件位于rust/library/core/src/iter/adapters/目录下它实现了反转迭代器的逻辑。

反转迭代器是一个适配器它的作用是将原始迭代器中的元素按照相反的顺序进行迭代。在rev.rs文件中定义了Rev<T>结构体其中的T是原始迭代器的类型。

Rev<T>结构体实现了Iterator trait因此可以调用迭代器相关的方法例如next、nth、for_each等。它存储了一个原始迭代器对象并提供了一个反转的迭代器。

在Rev<T>结构体中实现了迭代器的相关方法。这些方法与原始迭代器类似但元素的顺序是相反的。例如next方法返回下一个元素但是从原始迭代器的末尾开始返回nth方法返回第n个元素但是从原始迭代器的末尾开始计数for_each方法对每个元素执行给定的闭包函数但是从原始迭代器的末尾开始执行。

此外Rev<T>还提供了其他一些方法用于操作反转迭代器。例如size_hint方法返回反转迭代器的长度范围rev方法返回一个新的反转迭代器by_ref方法返回一个可变引用的迭代器等。

总的来说Rev<T>结构体在Rust中实现了反转迭代器的逻辑用于对原始迭代器进行反转迭代操作提供了一系列的方法来处理元素的顺序。

File: rust/library/core/src/iter/adapters/step_by.rs

在Rust源代码中step_by.rs文件是位于core库中的iter/adapters目录下的一个文件。它实现了迭代器适配器StepBy该适配器可以按照指定的步长对一个迭代器进行分割。

在详细介绍之前先了解一下几个关键概念

• 迭代器IteratorRust中的一种抽象用于表示一系列可以逐个访问的元素。
• 适配器AdapterRust中的迭代器的一种操作可以对原始迭代器进行变换或者过滤等操作返回一个新的迭代器。
• 步长Step指定每次跳过多少个元素进行分割的参数。

StepBy适配器的作用是按照指定的步长对一个迭代器进行分割。这样做可以使得我们只获取每个分段的第一个元素。例如如果我们有一个包含10个元素的迭代器并且指定步长为3那么StepBy适配器将把这个迭代器分成3个片段分别是包含第0、3和6个元素的迭代器。

下面详细介绍一下StepBy<I>相关的几个结构体和trait

1. SpecRangeSetup<T>这是一个用于构建StepBy适配器的辅助结构体。通过指定起始值start、结束值end和步长step它可以生成一个SpecRange<T>结构体。

2. StepByImpl<I>这是实现StepBy适配器的结构体。它包含一个iter字段代表待分割的原始迭代器。StepByImpl<I>实现了Iterator trait可以被迭代并返回每个分段的第一个元素。

   • new()该方法用于创建一个新的 StepByImpl<I>结构体实例。它接收一个原始迭代器并将其存储在 iter字段中。
   • next()该方法用于获取下一个分段的第一个元素并返回一个 Option用于表示是否还有元素可迭代。

3. StepByBackImpl<I>这是StepBy适配器的反向实现。它继承自StepByImpl结构体并在next_back()方法中反向迭代并返回每个分段的第一个元素。

总而言之step_by.rs文件中的结构体和trait实现了用于按照指定步长分割迭代器的适配器并提供了正向和反向迭代的方式。这个适配器可以在处理大型数据集合时优化性能只处理必要的分段数据而非全部数据。

File: rust/library/core/src/iter/adapters/zip.rs

在Rust的标准库中"rust/library/core/src/iter/adapters/zip.rs" 文件的作用是实现了用于将两个迭代器进行压缩的适配器。

首先让我们来了解一下在这个文件中定义的一些结构体和 trait。

1. Zip<A, B> 结构体这是压缩迭代器适配器的主要结构体用于在两个迭代器上创建一个新的迭代器。它包含了两个迭代器 A 和 B。

2. ZipImpl<A, B> 结构体这是 Zip 结构体的实现。它定义了迭代器的功能包括 next、size_hint 等。它将两个迭代器的元素进行压缩并在需要时返回元素对。

3. ZipFmt<A, B> 结构体这个结构体是用于格式化的传递器。它实现了 std::fmt::Debug、std::fmt::Display 和其他格式化相关的 trait。它可用于在调试时打印出压缩迭代器的内容。

接下来让我们来了解几个与 ZipImpl<A, B> 相关的 trait

1. TrustedRandomAccess trait此 trait 定义了支持拥有索引和随机访问的压缩迭代器的功能。实现了该 trait 的迭代器可以使用索引访问元素以及快速地获取迭代器长度。

2. TrustedRandomAccessNoCoerce trait这个 trait 是 TrustedRandomAccess 的一个变种它的实现不会对 index 方法的返回类型进行强制类型转换。

3. SpecTrustedRandomAccess trait这个 trait 是 TrustedRandomAccess 的另一个变种。它为特定元素类型的压缩迭代器提供了额外的功能以提高性能和效率。

通过使用 Zip 结构体以及相关的结构体和 trait你可以在 Rust 中创建压缩迭代器。这些压缩迭代器可以同时遍历两个迭代器并将它们的元素压缩在一起返回。这在需要同时处理多个相关联的数据源时非常有用。

File: rust/library/core/src/iter/adapters/skip_while.rs

在Rust的标准库中rust/library/core/src/iter/adapters/skip_while.rs 文件定义了 SkipWhile 结构体它是一个迭代器适配器用于跳过满足某个条件的元素之前的所有元素并返回剩下的元素。

SkipWhile 结构体有三个泛型参数I、P 和 Item。其中I 是要被跳过元素的迭代器类型P 是一个闭包类型用于判断哪些元素要被跳过Item 是迭代器产生的元素类型。

结构体 SkipWhile 实现了 Iterator trait因此它可以被用作一个迭代器。它有以下主要方法

• fn new(iter: I, pred: P) -> SkipWhile<I, P>创建一个新的 SkipWhile 迭代器传入要被跳过元素的迭代器 iter 和判断条件的闭包函数 pred。

• fn next(&mut self) -> Option<Self::Item>获取下一个元素并返回一个 Option 类型的值表示如果还有元素则返回 Some(item)否则返回 None。

• fn count(self) -> usize返回剩下的元素的数量该方法会迭代整个迭代器来计算数量。

• fn nth(&mut self, n: usize) -> Option<Self::Item>跳过迭代器中的指定数量 n 的元素并返回下一个元素。

SkipWhile 结构体的核心功能在 Iterator trait 的实现中它重写了 next 方法来实现跳过满足条件的元素。具体实现是通过调用介于迭代器和过滤器之间的 Skip 结构体的 find() 方法来找到第一个不再满足条件的元素然后返回剩下的元素。同时SkipWhile 结构体还实现了其他一些 Iterator trait 的方法以方便对剩下的元素进行操作。

总之SkipWhile 结构体是一个有用的迭代器适配器可以帮助我们跳过满足某个条件的前缀元素并返回剩下的元素。

File: rust/library/core/src/iter/adapters/take.rs

在Rust源代码中rust/library/core/src/iter/adapters/take.rs文件包含了关于“take”适配器的实现。这个适配器可以在一个迭代器中至多获取指定数量的元素然后停止迭代。

文件中的主要结构是Take<I>它是一个带有类型参数I的结构体。Take<I>实现了迭代器接口Iterator trait以及其他相关的特性。它被用来包装其他迭代器I然后根据需要从中取出元素。

Take<I>结构体有以下几个主要角色和作用

1. 将其他迭代器包装起来以便在需要时控制元素的数量。
2. 跟踪已经遍历过的元素数量以便在达到指定数量后停止迭代。
3. 当迭代器的元素数量不足指定数量时只取出已有的元素并使用预设的默认值填充剩余的位置。
4. 提供可变借用方法以便在迭代过程中改变指定数量的元素。

此外文件中的SpecTake是一个特质trait定义了不同类型的Take适配器的行为。这个特质定义了一些方法如count, try_fold, fold, all, any等。这些方法提供了不同的迭代行为例如计数、遍历规约、折叠等。

总的来说rust/library/core/src/iter/adapters/take.rs文件的作用是提供了一个“take”适配器允许用户从一个迭代器中取出指定数量的元素。这个适配器可以为迭代器提供一些额外的功能如计数、折叠等操作。

File: rust/library/core/src/iter/adapters/map_windows.rs

在Rust源代码中rust/library/core/src/iter/adapters/map_windows.rs 这个文件的作用是实现了 Iterator trait 的 map_windows() 函数该函数提供了对迭代器进行窗口映射的能力。

详细介绍如下

1. map_windows.rs 文件首先定义了一个 MapWindows<I> 结构体其中 I 是一个实现了 Iterator trait 的类型。该结构体代表了一个对原始迭代器进行窗口映射的适配器。

2. MapWindows<I> 结构体实现了 Iterator trait因此可以调用 Iterator trait 中定义的方法如 next()、size_hint() 等。

3. MapWindows<I> 结构体还包含一个 inner 字段类型为 MapWindowsInner<I, Buffer<T>>该字段负责实际的窗口映射逻辑。

4. MapWindowsInner<I, Buffer<T>> 结构体定义了一个实现窗口映射逻辑的迭代器。其中 I 是原始迭代器的类型Buffer<T> 是一个用于存储窗口元素的缓冲区类型。

5. MapWindowsInner<I, Buffer<T>> 结构体实现了 Iterator trait因此可以调用 Iterator trait 中定义的方法如 next()、size_hint() 等。它使用 Buffer<T> 来缓存窗口元素当需要获取下一个窗口时通过对原始迭代器的迭代和更新缓冲区来实现。

总结起来rust/library/core/src/iter/adapters/map_windows.rs 文件中的结构体 MapWindows<I> 和 MapWindowsInner<I, Buffer<T>> 提供了对原始迭代器进行窗口映射的功能。其中 MapWindows<I> 是对外的适配器MapWindowsInner<I, Buffer<T>> 是实际实现窗口映射的迭代器。通过使用这两个结构体可以在Rust代码中方便地对迭代器进行窗口映射操作。

File: rust/library/core/src/iter/adapters/filter_map.rs

在Rust的标准库中的iter/adapters/filter_map.rs文件包含了FilterMap适配器。

FilterMap适配器可以应用一个函数到一个迭代器的元素上然后使用该函数的返回值创建一个新的迭代器。该适配器将过滤掉函数返回的None值并只保留返回的Some值。

在该文件中有以下几个结构体

1. FilterMap<I, F>这是一个实现了Iterator trait的结构体。它持有一个初始迭代器 I并且应用了一个函数 F 到迭代器中的每个元素上。这个函数根据需要返回一个Option类型的值。FilterMap结构体通过迭代器的next方法将元素应用到函数上并过滤掉None值。

2. FilterMap<I, F>::Item这是迭代器返回的项类型。它是应用函数后所得到的Some值的类型。

3. Guard<'a>这是一个帮助结构体用于处理迭代器中的生命周期问题。它确保持有的引用在生命周期 'a 内有效。

FilterMap适配器可以使用filter_map方法调用例如

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

let filtered_numbers = numbers
    .into_iter()
    .filter_map(|x| {
        if x % 2 == 0 {
            Some(x * 2)
        } else {
            None
        }
    })
    .collect::<Vec<i32>>();

println!("{:?}", filtered_numbers);  // 输出 [4, 8]

在上面的例子中filter_map适配器将初始的迭代器numbers中的每个元素取出并将其传递给闭包函数。如果元素是偶数则该函数返回它的两倍包装在Some中否则返回None。最终filter_map产生一个新的迭代器仅包含函数返回Some的元素并且通过collect方法将这些元素收集到一个新的Vec中。最后的输出将是[4, 8]。

File: rust/library/core/src/iter/adapters/chain.rs

在Rust的标准库中rust/library/core/src/iter/adapters/chain.rs文件是链式适配器chaining adapters的实现。链式适配器用于连接两个迭代器iterators使它们在一起工作。

该文件中定义了一个名为Chain的结构体它是一个迭代器适配器。Chain结构体有两个类型参数A和B分别代表两个要连接的迭代器的类型。该结构体实现了Iterator trait需要实现next方法来生成迭代器的下一个元素。

Chain结构体的主要作用是将两个迭代器连接在一起形成一个新的迭代器。连接后的迭代器会首先迭代第一个迭代器的元素然后再继续迭代第二个迭代器的元素直到两个迭代器都遍历完毕。

在Chain结构体中还定义了一些其他的结构体它们分别是Iter、InitIter、FinIter和from。这些结构体在实现Iterator trait时起到辅助的作用。

• Iter结构体实现了 Iterator trait并负责迭代第一个迭代器的元素。
• InitIter结构体用于在一个新的 Chain迭代器中保存第一个迭代器以便在需要时轻松重新生成它。
• FinIter结构体用于在一个新的 Chain迭代器中保存第一个迭代器已经迭代完的状态以便在需要时跳过它。
• from方法用于创建一个新的 Chain迭代器。

通过这些结构体的协作Chain迭代器能够正确地连接两个迭代器并按照预期的顺序返回元素。

总之rust/library/core/src/iter/adapters/chain.rs文件中的Chain结构体及其相关辅助结构体的作用是将两个迭代器连接在一起形成一个新的迭代器以便对它们进行连续的迭代操作。

File: rust/library/core/src/iter/adapters/peekable.rs

在Rust的标准库中peekable.rs文件包含了Peekable适配器的实现。Peekable适配器可以用于在迭代器上进行"窥视peek"操作即查看迭代器中下一个元素而不移除它。

具体来说Peekable适配器有以下作用

1. 提供了对迭代器的一个包裹它允许我们在不改变迭代器的情况下访问下一个元素。
2. 提供了一个 peek方法返回迭代器中的下一个元素的一个引用但不消费该元素。
3. 能够根据需要消费下一个元素继续迭代。

Peekable适配器是通过Iter结构实现的它是一个泛型结构体其中的Peekable<I>类型参数表示被包裹的迭代器的类型。Iter结构体实现了迭代器特质Iterator因此它可以被用作迭代器。

除了Iter结构体Peekable适配器还定义了其他几个相关的结构体

• PeekingNext<I>是一个迭代器适配器用于在 Peekable实例中保留下一个元素和迭代器本身。它与 Iter结构体一起被用于保存迭代器的状态。
• PeekingNextState是一个枚举类型表示 PeekingNext结构体可能处于的几种不同的状态如等待迭代器产生下一个值、缓存下一个值等。
• Peek<T>是一个迭代器适配器用于在 Peekable实例中保存下一个元素的缓存。

这些结构体的组合允许我们在迭代过程中检查迭代器中的下一个元素而不改变迭代器移动到下一个元素的位置。

总结起来peekable.rs文件的作用是实现了Peekable适配器该适配器允许我们在Rust程序中对迭代器进行窥视操作以便在需要时查看下一个元素。

File: rust/library/core/src/iter/adapters/mod.rs

在Rust源代码中rust/library/core/src/iter/adapters/mod.rs是一个文件它位于Rust的核心库中的iter模块中的adapters子模块下。该文件的作用是定义一系列适配器adapters这些适配器用于对迭代器进行转换、过滤、映射等操作从而提供更丰富的迭代器功能。

具体来说该文件中定义了多个结构体struct和特性trait下面对其中的一些进行介绍

1. GenericShunt<'a, A, B>这是一个结构体用于创建一个迭代器适配器将一个迭代器转换为另一个具有不同元素类型的迭代器。它接受两个类型参数A和B分别表示输入和输出的元素类型。

2. SourceIter这是一个特性trait它定义了一系列方法用于对迭代器进行各种操作。其包括

   • iter() -> Self返回一个迭代器本身。
   • size_hint(&self) -> (usize, Option<usize>)返回一个元组表示迭代器的最小和最大元素数量的估计。
   • next(&mut self) -> Option<Self::Item>从迭代器中获取下一个元素并返回如果迭代器已经遍历完毕则返回 None。
   • advance_by(&mut self, n: usize) -> Result<(), usize>从迭代器中跳过指定数量的元素。
   • nth(&mut self, n: usize) -> Option<Self::Item>获取迭代器中的第 n个元素。
   • for_each<F>(&mut self, f: F) where F: FnMut(Self::Item)对迭代器中的每个元素执行给定的闭包函数。

总而言之adapters/mod.rs文件提供了一系列的迭代器适配器以及操作迭代器的方法使编程者可以方便地对迭代器进行各种转换和操作。这些适配器和特性可以用于编写更简洁、可读性更高的代码提高代码的可维护性和可重用性。

File: rust/library/core/src/iter/adapters/fuse.rs

在Rust源代码中fuse.rs文件位于rust/library/core/src/iter/adapters/路径下它定义了Fuse结构体和相关的FuseImpl特性。

Fuse结构体是一个迭代器适配器用于限制包装的迭代器只能迭代一次。它的定义如下

pub struct Fuse<I> {
    iter: I,
    done: bool,
}

Fuse结构体包含两个字段iter和done。iter是被包装的迭代器done表示迭代是否已完成。

Fuse结构体实现了Iterator特性因此可以调用Iterator特性中定义的方法如next()、for_each()等。但是当被包装的迭代器完成一次迭代后Fuse迭代器将变为不可用状态即调用它的方法将不会产生任何结果。

FuseImpl特性是通过Fuse结构体实现的内部特性。该特性定义了Fuse结构体内部方法的约束和默认实现。它包含了以下几个方法

• iter(&mut self) -> &mut I返回对被包装迭代器的可变引用。
• iter_and()将 Fuse结构体连同其内部的被包装迭代器一起返回。这在编写泛型算法时很有用。
• iter_set()将 Fuse结构体的 done字段设置为指定的值。这在迭代器需要被重新初始化时使用。
• is_done()检查 Fuse结构体的 done字段是否为 true。

总而言之Fuse结构体和FuseImpl特性的作用是创建一个迭代器适配器用于限制包装的迭代器只能迭代一次并提供了相关的方法来操作和检查迭代器的状态。这有助于确保迭代器的一致性和可预测性提高代码的可读性和可维护性。

File: rust/library/core/src/iter/sources/repeat.rs

在Rust源代码中rust/library/core/src/iter/sources/repeat.rs文件的作用是定义了一个可以无限重复特定值的迭代器。

首先这个文件定义了一个名为Repeat<A>的结构体它代表一个可以无限重复值A的迭代器。该结构体实现了Iterator trait使它可以通过迭代器的方式进行遍历。

Repeat<A>结构体的定义如下

pub struct Repeat<A> {
    element: A,
}

Repeat<A>结构体有一个类型参数A它代表了重复的值的类型。结构体内部有一个字段element用于存储重复的值。

Repeat<A>结构体还实现了Iterator trait其中定义了next方法用于获取下一个重复的值。具体代码如下

impl<A> Iterator for Repeat<A> {
    type Item = A;

    fn next(&mut self) -> Option<Self::Item> {
        Some(self.element)
    }
}

next方法总是返回Some(self.element)表示下一个迭代器的元素是重复的值。由于Repeat<A>是无限重复的迭代器因此其next方法不会返回None。

这样通过使用Repeat<A>结构体的实例就可以无限重复特定值进行迭代操作。这对于需要在某些特定情况下无限制地重复一个值的操作非常有用。

File: rust/library/core/src/iter/sources/repeat_n.rs

在Rust源代码中rust/library/core/src/iter/sources/repeat_n.rs文件的作用是定义了一个用于生成重复序列的迭代器。该文件实现了名为RepeatN的struct。

RepeatN结构表示一个迭代器它将元素A重复N次。它有以下主要成员函数和特性

pub struct FromFn<F>(F);

impl<I, F> FromIterator<I> for FromFn<F>
    where F: FnMut() -> Option<I>

impl<I, F> Iterator for FromFn<F>
    where F: FnMut() -> Option<I>