#![no_std]
#![cfg_attr(
feature = "nightly",
feature(const_destruct, const_trait_impl, iter_advance_by, trusted_len)
)]
#[cfg(feature = "nightly")]
use core::iter::TrustedLen;
use core::{fmt, iter::FusedIterator, marker::PhantomData, mem, num::NonZero};
#[cfg(feature = "nightly")]
macro_rules! if_nightly {
({ $($nightly:tt)* } else { $($stable:tt)* }) => { $($nightly)* };
}
#[cfg(not(feature = "nightly"))]
macro_rules! if_nightly {
({ $($nightly:tt)* } else { $($stable:tt)* }) => { $($stable)* };
}
#[cfg(feature = "nightly")]
macro_rules! maybe_const_trait {
($(#[$meta:meta])* $vis:vis trait $($rest:tt)*) => {
$(#[$meta])* $vis const trait $($rest)*
};
}
#[cfg(not(feature = "nightly"))]
macro_rules! maybe_const_trait {
($($item:tt)*) => { $($item)* };
}
#[cfg(feature = "nightly")]
macro_rules! const_fn {
(
$(#[$meta:meta])*
$vis:vis fn $name:ident($($params:tt)*) -> $ret:ty
where const [$($ty:ident),+ $(,)?]
$body:block
) => {
$(#[$meta])*
$vis const fn $name($($params)*) -> $ret
where
$($ty: [const] core::marker::Destruct,)+
$body
};
}
#[cfg(not(feature = "nightly"))]
macro_rules! const_fn {
(
$(#[$meta:meta])*
$vis:vis fn $name:ident($($params:tt)*) -> $ret:ty
where const [$($ty:ident),+ $(,)?]
$body:block
) => {
$(#[$meta])*
$vis fn $name($($params)*) -> $ret
$body
};
}
#[derive(Clone)]
struct Active<T, R> {
source: T,
count: NonZero<usize>,
rep_fn: R,
}
#[derive(Clone)]
enum State<T, R> {
Active {
source: T,
remaining: usize,
rep_fn: R,
},
Done,
}
impl<T, R> State<T, R> {
#[inline]
fn take_source(&mut self) -> T {
let Self::Active { source, .. } = mem::replace(self, Self::Done) else {
unreachable!()
};
source
}
}
maybe_const_trait! {
pub trait Replicator<Args, T, U = T> {
fn replicate(&mut self, source: &T, remaining: usize) -> U;
}
}
if_nightly! {
{
const impl<T, U, F> Replicator<(&T,), T, U> for F
where
F: [const] FnMut(&T) -> U,
{
#[inline]
fn replicate(&mut self, source: &T, _remaining: usize) -> U {
self(source)
}
}
const impl<T, U, F> Replicator<(&T, usize), T, U> for F
where
F: [const] FnMut(&T, usize) -> U,
{
#[inline]
fn replicate(&mut self, source: &T, remaining: usize) -> U {
self(source, remaining)
}
}
} else {
impl<T, U, F> Replicator<(&T,), T, U> for F
where
F: FnMut(&T) -> U,
{
#[inline]
fn replicate(&mut self, source: &T, _remaining: usize) -> U {
self(source)
}
}
impl<T, U, F> Replicator<(&T, usize), T, U> for F
where
F: FnMut(&T, usize) -> U,
{
#[inline]
fn replicate(&mut self, source: &T, remaining: usize) -> U {
self(source, remaining)
}
}
}
}
#[must_use = "iterators do nothing unless consumed"]
pub struct RepMove<Args, T, R: Replicator<Args, T>> {
inner: Option<Active<T, R>>,
_marker: PhantomData<Args>,
}
impl<Args, T, R: Replicator<Args, T>> RepMove<Args, T, R> {
const_fn! {
#[inline]
#[allow(
clippy::option_if_let_else,
reason = "`allow` not `expect`: the lint skips `const fn`, so it only fires in the stable build"
)]
pub fn new(source: T, rep_fn: R, count: usize) -> Self
where const [T, R]
{
match NonZero::new(count) {
Some(count) => Self {
inner: Some(Active {
source,
count,
rep_fn,
}),
_marker: PhantomData,
},
None => Self::empty(),
}
}
}
#[inline]
pub const fn empty() -> Self {
Self {
inner: None,
_marker: PhantomData,
}
}
const_fn! {
#[inline]
pub fn into_inner(self) -> Option<T>
where const [T, R]
{
match self.inner {
Some(active) => Some(active.source),
None => None,
}
}
}
}
impl<Args, T, R: Replicator<Args, T>> Iterator for RepMove<Args, T, R> {
type Item = T;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
let active = self.inner.as_mut()?;
match NonZero::new(active.count.get() - 1) {
Some(rest) => {
let item = active.rep_fn.replicate(&active.source, rest.get());
active.count = rest;
Some(item)
}
None => self.inner.take().map(|active| active.source),
}
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
let len = self.len();
(len, Some(len))
}
#[inline]
fn last(self) -> Option<T> {
self.into_inner()
}
#[inline]
fn count(self) -> usize {
self.len()
}
#[inline]
fn nth(&mut self, n: usize) -> Option<T> {
let active = self.inner.as_mut()?;
let len = active.count.get();
if n >= len {
self.inner = None;
return None;
}
match NonZero::new(len - n - 1) {
Some(rest) => {
let item = active.rep_fn.replicate(&active.source, rest.get());
active.count = rest;
Some(item)
}
None => self.inner.take().map(|active| active.source),
}
}
#[cfg(feature = "nightly")]
#[inline]
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
let len = self.len();
if let Some(rest) = NonZero::new(len.saturating_sub(n)) {
if let Some(active) = self.inner.as_mut() {
active.count = rest;
}
Ok(())
} else {
self.inner = None;
NonZero::new(n - len).map_or(Ok(()), Err)
}
}
}
impl<Args, T, R: Replicator<Args, T>> ExactSizeIterator for RepMove<Args, T, R> {
#[inline]
fn len(&self) -> usize {
self.inner.as_ref().map_or(0, |active| active.count.get())
}
}
impl<Args, T, R: Replicator<Args, T>> FusedIterator for RepMove<Args, T, R> {}
#[cfg(feature = "nightly")]
unsafe impl<Args, T, R: Replicator<Args, T>> TrustedLen for RepMove<Args, T, R> {}
impl<Args, T, R> Clone for RepMove<Args, T, R>
where
T: Clone,
R: Replicator<Args, T> + Clone,
{
#[inline]
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
_marker: PhantomData,
}
}
}
impl<Args, T, R: Replicator<Args, T>> Default for RepMove<Args, T, R> {
#[inline]
fn default() -> Self {
Self::empty()
}
}
impl<Args, T: fmt::Debug, R: Replicator<Args, T>> fmt::Debug for RepMove<Args, T, R> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.inner {
Some(active) => f
.debug_struct("RepMove")
.field("source", &active.source)
.field("items_left", &active.count.get())
.finish_non_exhaustive(),
None => f
.debug_tuple("RepMove")
.field(&format_args!("exhausted"))
.finish(),
}
}
}
#[must_use = "iterators do nothing unless consumed"]
pub struct RepMap<Args, T, U, R, F>
where
R: Replicator<Args, T, U>,
F: FnOnce(T) -> U,
{
inner: Option<Active<(T, F), R>>,
_marker: PhantomData<(Args, fn() -> U)>,
}
impl<Args, T, U, R, F> RepMap<Args, T, U, R, F>
where
R: Replicator<Args, T, U>,
F: FnOnce(T) -> U,
{
const_fn! {
#[inline]
#[allow(
clippy::option_if_let_else,
reason = "`allow` not `expect`: the lint skips `const fn`, so it only fires in the stable build"
)]
pub fn new(source: T, rep_fn: R, fin_fn: F, count: usize) -> Self
where const [T, R, F]
{
match NonZero::new(count) {
Some(count) => Self {
inner: Some(Active {
source: (source, fin_fn),
count,
rep_fn,
}),
_marker: PhantomData,
},
None => Self::empty(),
}
}
}
#[inline]
pub const fn empty() -> Self {
Self {
inner: None,
_marker: PhantomData,
}
}
const_fn! {
#[inline]
pub fn into_inner(self) -> Option<T>
where const [T, R, F]
{
match self.inner {
Some(active) => Some(active.source.0),
None => None,
}
}
}
}
impl<Args, T, U, R, F> Iterator for RepMap<Args, T, U, R, F>
where
R: Replicator<Args, T, U>,
F: FnOnce(T) -> U,
{
type Item = U;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
let active = self.inner.as_mut()?;
match NonZero::new(active.count.get() - 1) {
Some(rest) => {
let item = active.rep_fn.replicate(&active.source.0, rest.get());
active.count = rest;
Some(item)
}
None => self.inner.take().map(|active| {
let (source, fin_fn) = active.source;
fin_fn(source)
}),
}
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
let len = self.len();
(len, Some(len))
}
#[inline]
fn last(self) -> Option<U> {
self.inner.map(|active| {
let (source, fin_fn) = active.source;
fin_fn(source)
})
}
#[inline]
fn count(self) -> usize {
self.len()
}
#[inline]
fn nth(&mut self, n: usize) -> Option<U> {
let active = self.inner.as_mut()?;
let len = active.count.get();
if n >= len {
self.inner = None;
return None;
}
match NonZero::new(len - n - 1) {
Some(rest) => {
let item = active.rep_fn.replicate(&active.source.0, rest.get());
active.count = rest;
Some(item)
}
None => self.inner.take().map(|active| {
let (source, fin_fn) = active.source;
fin_fn(source)
}),
}
}
#[cfg(feature = "nightly")]
#[inline]
fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
let len = self.len();
if let Some(rest) = NonZero::new(len.saturating_sub(n)) {
if let Some(active) = self.inner.as_mut() {
active.count = rest;
}
Ok(())
} else {
self.inner = None;
NonZero::new(n - len).map_or(Ok(()), Err)
}
}
}
impl<Args, T, U, R, F> ExactSizeIterator for RepMap<Args, T, U, R, F>
where
R: Replicator<Args, T, U>,
F: FnOnce(T) -> U,
{
#[inline]
fn len(&self) -> usize {
self.inner.as_ref().map_or(0, |active| active.count.get())
}
}
impl<Args, T, U, R, F> FusedIterator for RepMap<Args, T, U, R, F>
where
R: Replicator<Args, T, U>,
F: FnOnce(T) -> U,
{
}
#[cfg(feature = "nightly")]
unsafe impl<Args, T, U, R, F> TrustedLen for RepMap<Args, T, U, R, F>
where
R: Replicator<Args, T, U>,
F: FnOnce(T) -> U,
{
}
impl<Args, T, U, R, F> Clone for RepMap<Args, T, U, R, F>
where
T: Clone,
R: Replicator<Args, T, U> + Clone,
F: FnOnce(T) -> U + Clone,
{
#[inline]
fn clone(&self) -> Self {
Self {
inner: self.inner.clone(),
_marker: PhantomData,
}
}
}
impl<Args, T, U, R, F> Default for RepMap<Args, T, U, R, F>
where
R: Replicator<Args, T, U>,
F: FnOnce(T) -> U,
{
#[inline]
fn default() -> Self {
Self::empty()
}
}
impl<Args, T: fmt::Debug, U, R, F> fmt::Debug for RepMap<Args, T, U, R, F>
where
R: Replicator<Args, T, U>,
F: FnOnce(T) -> U,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.inner {
Some(active) => f
.debug_struct("RepMap")
.field("source", &active.source.0)
.field("items_left", &active.count.get())
.finish_non_exhaustive(),
None => f
.debug_tuple("RepMap")
.field(&format_args!("exhausted"))
.finish(),
}
}
}
#[must_use = "iterators do nothing unless consumed"]
pub struct DynamicRepMove<T, R> {
state: State<T, R>,
}
impl<T, R: FnMut(&T, &mut usize) -> T> DynamicRepMove<T, R> {
const_fn! {
#[inline]
pub fn new(source: T, rep_fn: R, count: usize) -> Self
where const [T, R]
{
if count == 0 {
return Self::empty();
}
Self {
state: State::Active {
source,
remaining: count - 1,
rep_fn,
},
}
}
}
#[inline]
pub const fn empty() -> Self {
Self { state: State::Done }
}
const_fn! {
#[inline]
pub fn into_inner(self) -> Option<T>
where const [T, R]
{
match self.state {
State::Active { source, .. } => Some(source),
State::Done => None,
}
}
}
}
impl<T, R: FnMut(&T, &mut usize) -> T> Iterator for DynamicRepMove<T, R> {
type Item = T;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
match &mut self.state {
State::Done => return None,
State::Active {
source,
remaining,
rep_fn,
} => {
if *remaining > 0 {
return Some(rep_fn(source, remaining));
}
}
}
Some(self.state.take_source())
}
}
impl<T, R: FnMut(&T, &mut usize) -> T> FusedIterator for DynamicRepMove<T, R> {}
impl<T: Clone, R: Clone> Clone for DynamicRepMove<T, R> {
#[inline]
fn clone(&self) -> Self {
Self {
state: self.state.clone(),
}
}
}
impl<T, R: FnMut(&T, &mut usize) -> T> Default for DynamicRepMove<T, R> {
#[inline]
fn default() -> Self {
Self::empty()
}
}
impl<T: fmt::Debug, R> fmt::Debug for DynamicRepMove<T, R> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.state {
State::Active {
source, remaining, ..
} => f
.debug_struct("DynamicRepMove")
.field("source", source)
.field("remaining", remaining)
.finish_non_exhaustive(),
State::Done => f
.debug_tuple("DynamicRepMove")
.field(&format_args!("exhausted"))
.finish(),
}
}
}
#[must_use = "iterators do nothing unless consumed"]
pub struct DynamicRepMap<T, U, R, F> {
state: State<(T, F), R>,
_marker: PhantomData<fn() -> U>,
}
impl<T, U, R, F> DynamicRepMap<T, U, R, F>
where
R: FnMut(&T, &mut usize) -> U,
F: FnOnce(T) -> U,
{
const_fn! {
#[inline]
pub fn new(source: T, rep_fn: R, fin_fn: F, count: usize) -> Self
where const [T, R, F]
{
if count == 0 {
return Self::empty();
}
Self {
state: State::Active {
source: (source, fin_fn),
remaining: count - 1,
rep_fn,
},
_marker: PhantomData,
}
}
}
#[inline]
pub const fn empty() -> Self {
Self {
state: State::Done,
_marker: PhantomData,
}
}
const_fn! {
#[inline]
pub fn into_inner(self) -> Option<T>
where const [T, R, F]
{
match self.state {
State::Active { source: (source, _), .. } => Some(source),
State::Done => None,
}
}
}
}
impl<T, U, R, F> Iterator for DynamicRepMap<T, U, R, F>
where
R: FnMut(&T, &mut usize) -> U,
F: FnOnce(T) -> U,
{
type Item = U;
#[inline]
fn next(&mut self) -> Option<Self::Item> {
match &mut self.state {
State::Done => return None,
State::Active {
source,
remaining,
rep_fn,
} => {
if *remaining > 0 {
return Some(rep_fn(&source.0, remaining));
}
}
}
let (source, fin_fn) = self.state.take_source();
Some(fin_fn(source))
}
}
impl<T, U, R, F> FusedIterator for DynamicRepMap<T, U, R, F>
where
R: FnMut(&T, &mut usize) -> U,
F: FnOnce(T) -> U,
{
}
impl<T: Clone, U, R: Clone, F: Clone> Clone for DynamicRepMap<T, U, R, F> {
#[inline]
fn clone(&self) -> Self {
Self {
state: self.state.clone(),
_marker: PhantomData,
}
}
}
impl<T, U, R, F> Default for DynamicRepMap<T, U, R, F>
where
R: FnMut(&T, &mut usize) -> U,
F: FnOnce(T) -> U,
{
#[inline]
fn default() -> Self {
Self::empty()
}
}
impl<T: fmt::Debug, U, R, F> fmt::Debug for DynamicRepMap<T, U, R, F> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match &self.state {
State::Active {
source, remaining, ..
} => f
.debug_struct("DynamicRepMap")
.field("source", &source.0)
.field("remaining", remaining)
.finish_non_exhaustive(),
State::Done => f
.debug_tuple("DynamicRepMap")
.field(&format_args!("exhausted"))
.finish(),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
extern crate alloc;
use alloc::{
boxed::Box,
format,
string::{String, ToString as _},
vec,
vec::Vec,
};
use core::cell::Cell;
struct Counted<'a>(&'a Cell<usize>);
impl Clone for Counted<'_> {
fn clone(&self) -> Self {
self.0.set(self.0.get() + 1);
Self(self.0)
}
}
#[test]
fn clone_three_times() {
let v = vec![1, 2, 3];
let mut iter = RepMove::new(v, Vec::clone, 3);
assert_eq!(iter.len(), 3);
assert_eq!(iter.next(), Some(vec![1, 2, 3]));
assert_eq!(iter.len(), 2);
assert_eq!(iter.next(), Some(vec![1, 2, 3]));
assert_eq!(iter.len(), 1);
assert_eq!(iter.next(), Some(vec![1, 2, 3])); assert_eq!(iter.len(), 0);
assert_eq!(iter.next(), None);
}
#[test]
fn remaining_aware_closure() {
let s = String::from("test");
let mut iter = RepMove::new(s, |s: &String, n: usize| format!("{s}-{n}"), 2);
assert_eq!(iter.next(), Some("test-1".to_string()));
assert_eq!(iter.next(), Some("test".to_string())); assert_eq!(iter.next(), None);
}
#[test]
fn zero_count_drops_source() {
let v = vec![1, 2, 3];
let mut iter = RepMove::new(v, Vec::clone, 0);
assert_eq!(iter.len(), 0);
assert_eq!(iter.next(), None);
}
#[test]
fn single_item_is_moved_not_cloned() {
let v = vec![42];
let mut iter = RepMove::new(v, Vec::clone, 1);
assert_eq!(iter.len(), 1);
assert_eq!(iter.next(), Some(vec![42]));
assert_eq!(iter.next(), None);
}
#[test]
fn empty_yields_nothing() {
let iter = RepMove::<_, i32, fn(&i32) -> i32>::empty();
assert_eq!(iter.len(), 0);
assert_eq!(iter.into_inner(), None);
}
#[test]
fn into_inner_recovers_source() {
let v = vec![1, 2, 3];
let iter = RepMove::new(v, Vec::clone, 5);
assert_eq!(iter.into_inner(), Some(vec![1, 2, 3]));
}
#[test]
fn into_inner_after_exhaust() {
let mut iter = RepMove::new(42i32, |x: &i32| *x, 1);
iter.next();
assert_eq!(iter.into_inner(), None);
}
#[test]
fn fused_after_exhaustion() {
let mut iter = RepMove::new(42i32, |x: &i32| *x, 2);
assert_eq!(iter.next(), Some(42));
assert_eq!(iter.next(), Some(42));
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
}
#[test]
fn size_hint_always_exact() {
let mut iter = RepMove::new(0u8, |x: &u8| *x, 3);
assert_eq!(iter.size_hint(), (3, Some(3)));
iter.next();
assert_eq!(iter.size_hint(), (2, Some(2)));
iter.next();
assert_eq!(iter.size_hint(), (1, Some(1)));
iter.next();
assert_eq!(iter.size_hint(), (0, Some(0)));
}
#[test]
fn debug_active_and_exhausted() {
let iter = RepMove::new(vec![1, 2], Vec::clone, 2);
let dbg = format!("{iter:?}");
assert!(dbg.contains("RepMove"));
assert!(dbg.contains("[1, 2]"));
let iter = RepMove::new(0u8, |x: &u8| *x, 0);
let dbg = format!("{iter:?}");
assert_eq!(dbg, "RepMove(exhausted)");
}
#[test]
fn rep_map_converts_type() {
let v = vec![1, 2, 3];
let boxes: Vec<Box<[i32]>> = RepMap::new(
v,
|v: &Vec<i32>| v.clone().into_boxed_slice(),
Vec::into_boxed_slice,
3,
)
.collect();
assert_eq!(boxes.len(), 3);
assert!(boxes.iter().all(|b| **b == [1, 2, 3]));
}
#[test]
fn rep_map_remaining_aware() {
let s = String::from("x");
let out: Vec<String> =
RepMap::new(s, |s: &String, n: usize| format!("{s}{n}"), |s| s, 3).collect();
assert_eq!(out, ["x2", "x1", "x"]);
}
#[test]
fn rep_map_len_and_size_hint() {
let mut iter = RepMap::new(0u8, |x: &u8| u16::from(*x), u16::from, 3);
assert_eq!(iter.len(), 3);
assert_eq!(iter.size_hint(), (3, Some(3)));
iter.next();
iter.next();
assert_eq!(iter.len(), 1);
iter.next();
assert_eq!(iter.len(), 0);
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None); }
#[test]
fn rep_map_zero_count_and_into_inner() {
let mut iter = RepMap::new(vec![7], |v: &Vec<i32>| v.len(), |v| v.len(), 0);
assert_eq!(iter.len(), 0);
assert_eq!(iter.next(), None);
let iter = RepMap::new(vec![7], |v: &Vec<i32>| v.len(), |v| v.len(), 5);
assert_eq!(iter.into_inner(), Some(vec![7]));
}
#[test]
fn rep_map_debug() {
let iter = RepMap::new(vec![1, 2], |v: &Vec<i32>| v.len(), |v| v.len(), 2);
let dbg = format!("{iter:?}");
assert!(dbg.contains("RepMap"));
assert!(dbg.contains("[1, 2]"));
let iter = RepMap::new(0u8, |x: &u8| u16::from(*x), u16::from, 0);
assert_eq!(format!("{iter:?}"), "RepMap(exhausted)");
}
#[test]
fn dynamic_early_stop() {
let v = vec![1, 2, 3];
let mut iter = DynamicRepMove::new(
v,
|v: &Vec<i32>, remaining: &mut usize| {
*remaining = 0; v.clone()
},
5,
);
assert_eq!(iter.next(), Some(vec![1, 2, 3])); assert_eq!(iter.next(), Some(vec![1, 2, 3])); assert_eq!(iter.next(), None);
}
#[test]
fn dynamic_gradual_countdown() {
let v = vec![1, 2, 3];
let mut iter = DynamicRepMove::new(
v,
|v: &Vec<i32>, remaining: &mut usize| {
*remaining -= 1;
v.clone()
},
4,
);
assert_eq!(iter.next(), Some(vec![1, 2, 3]));
assert_eq!(iter.next(), Some(vec![1, 2, 3]));
assert_eq!(iter.next(), Some(vec![1, 2, 3]));
assert_eq!(iter.next(), Some(vec![1, 2, 3])); assert_eq!(iter.next(), None);
}
#[test]
fn dynamic_can_extend() {
let mut calls = 0u32;
let iter = DynamicRepMove::new(
1u8,
move |x: &u8, remaining: &mut usize| {
calls += 1;
if calls == 1 {
*remaining = 3; } else {
*remaining -= 1;
}
*x
},
2, );
assert_eq!(iter.count(), 5);
}
#[test]
fn dynamic_size_hint_is_default() {
let iter = DynamicRepMove::new(0u8, |x: &u8, _: &mut usize| *x, 3);
assert_eq!(iter.size_hint(), (0, None));
}
#[test]
fn dynamic_empty() {
let iter = DynamicRepMove::<i32, fn(&i32, &mut usize) -> i32>::empty();
assert_eq!(iter.into_inner(), None);
}
#[test]
fn dynamic_rep_map_early_stop() {
let v = vec![1, 2, 3];
let mut iter = DynamicRepMap::new(
v,
|v: &Vec<i32>, remaining: &mut usize| {
*remaining = 0;
v.len()
},
|v| v.len() + 10, 100,
);
assert_eq!(iter.next(), Some(3));
assert_eq!(iter.next(), Some(13));
assert_eq!(iter.next(), None);
}
#[test]
fn dynamic_rep_map_countdown_and_into_inner() {
let v = vec![1, 2];
let out = DynamicRepMap::new(
v,
|v: &Vec<i32>, remaining: &mut usize| {
*remaining -= 1;
v.clone().into_boxed_slice()
},
Vec::into_boxed_slice,
3,
);
assert_eq!(out.count(), 3);
let iter = DynamicRepMap::new(
vec![9],
|v: &Vec<i32>, _: &mut usize| v.len(),
|v| v.len(),
4,
);
assert_eq!(iter.into_inner(), Some(vec![9]));
}
#[cfg(feature = "nightly")]
#[test]
fn const_construction() {
#[expect(
clippy::trivially_copy_pass_by_ref,
reason = "the reference is dictated by the `FnMut(&T, &mut usize)` shape"
)]
fn dec(x: &u8, n: &mut usize) -> u8 {
*n -= 1;
*x
}
const IT: DynamicRepMove<u8, fn(&u8, &mut usize) -> u8> =
DynamicRepMove::new(7, dec as fn(&u8, &mut usize) -> u8, 3);
const BACK: Option<u8> =
DynamicRepMove::new(9u8, dec as fn(&u8, &mut usize) -> u8, 5).into_inner();
assert_eq!(IT.count(), 3);
assert_eq!(BACK, Some(9));
}
#[test]
fn dynamic_rep_map_debug() {
let iter = DynamicRepMap::<i32, i32, fn(&i32, &mut usize) -> i32, fn(i32) -> i32>::empty();
assert_eq!(format!("{iter:?}"), "DynamicRepMap(exhausted)");
}
#[test]
fn last_moves_source_without_cloning() {
let clones = Cell::new(0);
let last = RepMove::new(Counted(&clones), Counted::clone, 100).last();
assert!(last.is_some());
assert_eq!(clones.get(), 0);
let iter = RepMove::new(String::from("x"), |s: &String, n: usize| format!("{s}-{n}"), 5);
assert_eq!(iter.last(), Some("x".to_string()));
}
#[test]
fn count_does_not_clone() {
let clones = Cell::new(0);
assert_eq!(RepMove::new(Counted(&clones), Counted::clone, 100).count(), 100);
assert_eq!(clones.get(), 0);
}
#[test]
fn nth_clones_at_most_once() {
let clones = Cell::new(0);
let mut iter = RepMove::new(Counted(&clones), Counted::clone, 100);
assert!(iter.nth(50).is_some());
assert_eq!(clones.get(), 1);
assert_eq!(iter.len(), 49);
let clones = Cell::new(0);
let mut iter = RepMove::new(Counted(&clones), Counted::clone, 5);
assert!(iter.nth(4).is_some());
assert_eq!(clones.get(), 0);
assert!(iter.next().is_none());
}
#[test]
fn nth_past_end_exhausts() {
let mut iter = RepMove::new(vec![1], Vec::clone, 3);
assert_eq!(iter.nth(7), None);
assert_eq!(iter.len(), 0);
assert_eq!(iter.next(), None);
}
#[test]
fn nth_matches_naive_iteration() {
let make = || RepMove::new(String::from("x"), |s: &String, n: usize| format!("{s}-{n}"), 5);
let naive: Vec<String> = make().collect();
assert_eq!(naive, ["x-4", "x-3", "x-2", "x-1", "x"]);
for (i, expected) in naive.iter().enumerate() {
assert_eq!(make().nth(i).as_ref(), Some(expected));
}
assert_eq!(make().nth(5), None);
}
#[test]
fn rep_map_last_uses_fin_fn_without_cloning() {
let clones = Cell::new(0);
let last = RepMap::new(Counted(&clones), Counted::clone, |c| c, 100).last();
assert!(last.is_some());
assert_eq!(clones.get(), 0);
let iter = RepMap::new(String::from("x"), |s: &String| s.clone(), |s| s + "!", 3);
assert_eq!(iter.last(), Some("x!".to_string()));
}
#[test]
fn rep_map_count_and_nth_skip_replication() {
let clones = Cell::new(0);
let iter = RepMap::new(Counted(&clones), Counted::clone, |c| c, 10);
assert_eq!(iter.count(), 10);
assert_eq!(clones.get(), 0);
let make = || {
RepMap::new(
String::from("x"),
|s: &String, n: usize| format!("{s}{n}"),
|s| s,
3,
)
};
let mut iter = make();
assert_eq!(iter.nth(2), Some("x".to_string())); assert_eq!(iter.next(), None);
let mut iter = make();
assert_eq!(iter.nth(1), Some("x1".to_string()));
assert_eq!(iter.next(), Some("x".to_string()));
}
#[test]
fn iterator_clone_is_independent() {
let mut a = RepMove::new(vec![1, 2], Vec::clone, 3);
assert!(a.next().is_some());
let b = a.clone();
let from_a: Vec<_> = a.collect();
let from_b: Vec<_> = b.collect();
assert_eq!(from_a, from_b);
assert_eq!(from_a.len(), 2);
let a = RepMap::new(vec![1], |v: &Vec<i32>| v.len(), |v: Vec<i32>| v.len(), 2);
assert_eq!(a.clone().count(), 2);
assert_eq!(a.count(), 2);
let a = DynamicRepMove::new(
vec![1],
|v: &Vec<i32>, n: &mut usize| {
*n -= 1;
v.clone()
},
3,
);
let b = a.clone();
assert_eq!(a.count(), 3);
assert_eq!(b.count(), 3);
let a = DynamicRepMap::new(
vec![1],
|v: &Vec<i32>, n: &mut usize| {
*n -= 1;
v.len()
},
|v| v.len(),
2,
);
assert_eq!(a.clone().count(), 2);
assert_eq!(a.count(), 2);
}
#[test]
#[expect(
clippy::type_complexity,
reason = "spelling out the full iterator types is the point of this test"
)]
fn default_is_empty() {
let iter: RepMove<_, i32, fn(&i32) -> i32> = RepMove::default();
assert_eq!(iter.len(), 0);
let iter: RepMap<_, i32, u16, fn(&i32) -> u16, fn(i32) -> u16> = RepMap::default();
assert_eq!(iter.len(), 0);
let iter: DynamicRepMove<i32, fn(&i32, &mut usize) -> i32> = DynamicRepMove::default();
assert_eq!(iter.into_inner(), None);
let iter: DynamicRepMap<i32, i32, fn(&i32, &mut usize) -> i32, fn(i32) -> i32> =
DynamicRepMap::default();
assert_eq!(iter.into_inner(), None);
}
#[test]
fn niche_layout_matches_repeat_n() {
let ours = RepMove::new(0u64, |x: &u64| *x, 3);
let std_one = core::iter::repeat_n(0u64, 3);
assert_eq!(
core::mem::size_of_val(&ours),
core::mem::size_of_val(&std_one)
);
}
#[cfg(feature = "nightly")]
#[test]
fn advance_by_skips_without_cloning() {
let clones = Cell::new(0);
let mut iter = RepMove::new(Counted(&clones), Counted::clone, 100);
assert_eq!(iter.advance_by(98), Ok(()));
assert_eq!(clones.get(), 0);
assert_eq!(iter.len(), 2);
assert!(iter.next().is_some()); assert!(iter.next().is_some()); assert_eq!(clones.get(), 1);
assert!(iter.next().is_none());
}
#[cfg(feature = "nightly")]
#[test]
fn advance_by_boundaries() {
let mut iter = RepMove::new(vec![1], Vec::clone, 3);
assert_eq!(iter.advance_by(0), Ok(()));
assert_eq!(iter.len(), 3);
assert_eq!(iter.advance_by(3), Ok(())); assert_eq!(iter.len(), 0);
assert_eq!(iter.advance_by(0), Ok(()));
assert_eq!(iter.advance_by(2), Err(NonZero::new(2).unwrap()));
let mut iter = RepMove::new(vec![1], Vec::clone, 3);
assert_eq!(iter.advance_by(5), Err(NonZero::new(2).unwrap()));
assert_eq!(iter.next(), None);
let mut iter = RepMap::new(
String::from("x"),
|s: &String, n: usize| format!("{s}{n}"),
|s| s,
4,
);
assert_eq!(iter.advance_by(3), Ok(()));
assert_eq!(iter.next(), Some("x".to_string()));
assert_eq!(iter.next(), None);
}
#[cfg(feature = "nightly")]
#[test]
fn trusted_len_is_implemented() {
fn assert_trusted<I: TrustedLen>(_: &I) {}
assert_trusted(&RepMove::new(vec![1], Vec::clone, 3));
assert_trusted(&RepMap::new(
vec![1],
|v: &Vec<i32>| v.len(),
|v: Vec<i32>| v.len(),
3,
));
}
}