[英]How to implement an infinite integer iterator?
我创建了一个迭代器来生成从 0 开始的无限整数列表,如下所示。
struct Infinite {
current: i64,
}
impl Infinite {
fn new() -> Infinite {
Infinite { current: -1 }
}
}
impl Iterator for Infinite {
type Item = i64;
fn next(&mut self) -> Option<Self::Item> {
self.current += 1;
Some(self.current)
}
}
我希望使用不同的命令来操作这个整数列表,例如乘法(将每个 integer 乘以一个数字 n)或减法(从每个整数中减去 n)。 因此,我创建了一个 Multiply 结构并为它实现了一个迭代器,如下所示。
struct Multiply {
n: i64,
inner: Box<dyn Iterator<Item = i64>>,
}
impl Multiply {
fn new(inner: Box<dyn Iterator<Item = i64>>, n: i64) -> Multiply {
Multiply { n, inner }
}
}
impl Iterator for Multiply {
type Item = i64;
fn next(&mut self) -> Option<Self::Item> {
Some(self.inner.next().unwrap() * self.n)
}
}
但是,我不确定如何在主 function 中实现这一点。 我应该以这种方式定义一个新的iter
器 object 开始吗?
let mut iter = Infinite::new();
iter.next();
那么,我应该如何将 Multiply 迭代器实现到iter
?
fn main() {
let mut iter = Multiply::new(Box::new(Infinite::new()), 2);
println!("{}", iter.next().unwrap());
println!("{}", iter.next().unwrap());
println!("{}", iter.next().unwrap());
}
0
2
4
也就是说,迭代器携带Box
object 是很不寻常的。 它通常使用泛型完成。 (另外,从一个迭代器映射到另一个迭代器时不要使用.unwrap()
,而是使用Option::map()
来保留迭代器的结尾)
struct Infinite {
current: i64,
}
impl Infinite {
fn new() -> Infinite {
Infinite { current: -1 }
}
}
impl Iterator for Infinite {
type Item = i64;
fn next(&mut self) -> Option<Self::Item> {
self.current += 1;
Some(self.current)
}
}
struct Multiply<I> {
n: i64,
inner: I,
}
impl<I> Multiply<I> {
fn new(inner: I, n: i64) -> Multiply<I> {
Multiply { n, inner }
}
}
impl<I> Iterator for Multiply<I>
where
I: Iterator<Item = i64>,
{
type Item = i64;
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(|n| n * self.n)
}
}
fn main() {
let mut iter = Multiply::new(Infinite::new(), 2);
println!("{}", iter.next().unwrap());
println!("{}", iter.next().unwrap());
println!("{}", iter.next().unwrap());
}
0
2
4
此外,这通常是通过Iterator
的扩展特征来完成的,因此您可以将其链接起来。 这也是整个itertools
crate 的工作方式。
struct Infinite {
current: i64,
}
impl Infinite {
fn new() -> Infinite {
Infinite { current: -1 }
}
}
impl Iterator for Infinite {
type Item = i64;
fn next(&mut self) -> Option<Self::Item> {
self.current += 1;
Some(self.current)
}
}
struct Multiply<I>
where
I: Iterator<Item = i64>,
{
n: i64,
inner: I,
}
impl<I> Iterator for Multiply<I>
where
I: Iterator<Item = i64>,
{
type Item = i64;
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(|n| n * self.n)
}
}
trait MultiplyExt
where
Self: Iterator + Sized,
{
fn multiply_with(self, n: i64) -> Multiply<Self>
where
Self: Iterator<Item = i64>,
{
Multiply { n, inner: self }
}
}
impl<T: Iterator> MultiplyExt for T {}
fn main() {
let mut iter = Infinite::new().multiply_with(2);
println!("{}", iter.next().unwrap());
println!("{}", iter.next().unwrap());
println!("{}", iter.next().unwrap());
}
0
2
4
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.