| Crates.io | alternating-iter |
| lib.rs | alternating-iter |
| version | 0.3.1 |
| created_at | 2023-06-07 08:37:16.023938+00 |
| updated_at | 2024-06-26 20:41:28.809196+00 |
| description | Provide an iterator adaptor which alternate between two iterators. |
| homepage | |
| repository | https://github.com/Mainzu/alternating-iter |
| max_upload_size | |
| id | 884582 |
| size | 38,122 |
This crate aims to provide a convenient way to alternate between the items of two iterators. It allows you to iterate over two iterators in an alternating fashion, combining their elements into a single sequence.
For the easiest usage of this crate, bring the AlternatingExt trait into scope
use alternating_iter::AlternatingExt;
and use the alternate_with_all method to create new alternating iterators.
use alternating_iter::AlternatingExt;
let a = [1, 2];
let b = [3, 4, 5];
let mut iter = a.iter().alternate_with_all(b.iter());
assert_eq!(iter.next(), Some(&1)); // `a` first
assert_eq!(iter.next(), Some(&3)); // `b`
assert_eq!(iter.next(), Some(&2)); // `a`
assert_eq!(iter.next(), Some(&4)); // `b`
assert_eq!(iter.next(), Some(&5)); // also `b`
assert_eq!(iter.next(), None);
By default, the alternate_with_all method creates an iterator that returns an element from a first, followed by an element from b, and so on until both are exhausted.
If, however, you want the iteration to stop once either of the iterators is exhausted, you can use the alternate_with_no_remainder method, also provided by the AlternatingExt trait. This method returns an iterator that stops as soon as it needs to return more than one item consecutively from a single iterator.
use alternating_iter::AlternatingExt;
let a = [1, 2];
let b = [3, 4, 5];
let mut iter = a.iter().alternate_with_no_remainder(b.iter());
assert_eq!(iter.next(), Some(&1)); // `a` first
assert_eq!(iter.next(), Some(&3)); // `b`
assert_eq!(iter.next(), Some(&2)); // `a`
assert_eq!(iter.next(), Some(&4)); // `b`
assert_eq!(iter.next(), None); // remaining items from `b` are not returned
The iteration stops after the fourth element because returning the fifth element from b would break the alternating pattern.
If the alternate_with_all behavior is not desirable and you want to continue alternation even after an iterator is exhausted, use alternate_with, the simplest iterator of the three.
use alternating_iter::AlternatingExt;
let a = [1, 2];
let b = [3, 4, 5];
let mut iter = a.iter().alternate_with(b.iter());
assert_eq!(iter.next(), Some(&1)); // `a` first
assert_eq!(iter.next(), Some(&3)); // `b`
assert_eq!(iter.next(), Some(&2)); // `a`
assert_eq!(iter.next(), Some(&4)); // `b`
assert_eq!(iter.next(), None); // `a` exhausted
assert_eq!(iter.next(), Some(&5)); // `b`
assert_eq!(iter.next(), None); // `b` exhausted
The iterator will simply keep alternating blindly, so Some can appear between None if one of the input iterators is larger than the other.
FusedIterator implementationFixedSizedIterator implementations