是否有等價於slice :: chunks/windows迭代器來循環對，三元組等？

Question

一次迭代多個變量可能很有用，重疊（slice::windows），或不是（slice::chunks）。

這隻適用於切片;有沒有可能爲迭代器做到這一點，爲了方便使用元組？

像下面這樣可以寫成：

for (prev, next) in some_iter.windows(2) { 
    ... 
} 

如果沒有，可以把它作爲對現有迭代器特性來實現？

Answer 1

TL; DR：有chunks和windows上的任意迭代器/收集最好的辦法是先collect它變成一個Vec和迭代該。

---

請求的確切語法在Rust中是不可能的。

的問題是，在防鏽，一個函數的簽名取決於類型，不值，雖然依賴打字存在，也有實現它的（很難）幾種語言。

這就是爲什麼chunks和windows順便返回一個子片; &[T]中的元素數量不是該類型的一部分，因此可以在運行時決定。

---

讓我們假裝你問：for slice in some_iter.windows(2)而不是。

這個切片的存儲位置在哪裏？

它不能住：

• 原來的集合中，因爲一個LinkedList沒有一個連續的存儲，因爲Iterator::Item定義的迭代器
• ，沒有使用壽命可

因此，不幸的是，切片只能在後備存儲是切片時使用。

---

如果動態分配被接受，則有可能使用Vec<Iterator::Item>作爲分塊的迭代器的Item。

struct Chunks<I: Iterator> { 
    elements: Vec<<I as Iterator>::Item>, 
    underlying: I, 
} 

impl<I: Iterator> Chunks<I> { 
    fn new(iterator: I, size: usize) -> Chunks<I> { 
     assert!(size > 0); 

     let mut result = Chunks { 
      underlying: iterator, elements: Vec::with_capacity(size) 
     }; 
     result.refill(size); 
     result 
    } 

    fn refill(&mut self, size: usize) { 
     assert!(self.elements.is_empty()); 

     for _ in 0..size { 
      match self.underlying.next() { 
       Some(item) => self.elements.push(item), 
       None => break, 
      } 
     } 
    } 
} 

impl<I: Iterator> Iterator for Chunks<I> { 
    type Item = Vec<<I as Iterator>::Item>; 

    fn next(&mut self) -> Option<Self::Item> { 
     if self.elements.is_empty() { 
      return None; 
     } 

     let new_elements = Vec::with_capacity(self.elements.len()); 
     let result = std::mem::replace(&mut self.elements, new_elements); 

     self.refill(result.len()); 

     Some(result) 
    } 
} 

fn main() { 
    let v = vec!(1, 2, 3, 4, 5); 

    for slice in Chunks::new(v.iter(), 2) { 
     println!("{:?}", slice); 
    } 
} 

返回結果：

[1, 2] 
[3, 4] 
[5] 

---

這個精明的讀者會發現，我偷偷從windows切換到chunks。

windows更困難，因爲它多次返回相同的元素，要求元素爲Clone。此外，由於每次需要返回完整Vec，因此需要在內部保留Vec<Vec<Iterator::Item>>。

這是作爲練習留給讀者。

---

最後，性能一張紙條：所有分配是會受到傷害（尤其是在windows的情況下）。

最好的分配策略通常是分配一塊內存，然後靠它（除非數量真的很大，在這種情況下需要流式傳輸）。

它在Rust中被稱爲collect::<Vec<_>>()。

而且由於Vec有chunks和windows方法（由於實施Deref<Target=[T]>的），你就可以使用，而不是：

for slice in v.iter().collect::<Vec<_>>().chunks(2) { 
    println!("{:?}", slice); 
} 

for slice in v.iter().collect::<Vec<_>>().windows(2) { 
    println!("{:?}", slice); 
} 

有時候最好的解決方案是最簡單的。

Answer 2

這是可能的使用Itertools::tuples，由4元組取一個迭代的塊：

extern crate itertools;  

use itertools::Itertools; 

fn main() { 
    let some_iter = vec![1, 2, 3, 4, 5, 6].into_iter(); 

    for (prev, next) in some_iter.tuples() { 
     println!("{}--{}", prev, next); 
    } 
} 

（playground）

1--2 
3--4 
5--6 

除了最多4元組的窗口與Itertools::tuple_windows ：

extern crate itertools; 

use itertools::Itertools; 

fn main() { 
    let some_iter = vec![1, 2, 3, 4, 5, 6].into_iter(); 

    for (prev, next) in some_iter.tuple_windows() { 
     println!("{}--{}", prev, next); 
    } 
} 

（playground）

1--2 
2--3 
3--4 
4--5 
5--6