#![no_std]
#![cfg_attr(feature = "nightly", feature(const_destruct, const_trait_impl))]
use core::{fmt, iter::FusedIterator, marker::PhantomData, mem};
#[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
};
}
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>> {
state: State<T, R>,
_marker: PhantomData<Args>,
}
impl<Args, T, R: Replicator<Args, T>> RepMove<Args, 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,
},
_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]
{
match self.state {
State::Active { source, .. } => Some(source),
State::Done => 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> {
match &mut self.state {
State::Done => return None,
State::Active {
source,
remaining,
rep_fn,
} => {
if let Some(next) = remaining.checked_sub(1) {
let item = rep_fn.replicate(source, *remaining);
*remaining = next;
return Some(item);
}
}
}
Some(self.state.take_source())
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
let len = self.len();
(len, Some(len))
}
}
impl<Args, T, R: Replicator<Args, T>> ExactSizeIterator for RepMove<Args, T, R> {
#[inline]
fn len(&self) -> usize {
match self.state {
State::Active { remaining, .. } => remaining + 1,
State::Done => 0,
}
}
}
impl<Args, T, R: Replicator<Args, T>> FusedIterator for RepMove<Args, T, R> {}
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.state {
State::Active {
source, remaining, ..
} => f
.debug_struct("RepMove")
.field("source", source)
.field("items_left", &(*remaining + 1))
.finish_non_exhaustive(),
State::Done => 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,
{
state: State<(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]
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<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> {
match &mut self.state {
State::Done => return None,
State::Active {
source,
remaining,
rep_fn,
} => {
if let Some(next) = remaining.checked_sub(1) {
let item = rep_fn.replicate(&source.0, *remaining);
*remaining = next;
return Some(item);
}
}
}
let (source, fin_fn) = self.state.take_source();
Some(fin_fn(source))
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
let len = self.len();
(len, Some(len))
}
}
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 {
match self.state {
State::Active { remaining, .. } => remaining + 1,
State::Done => 0,
}
}
}
impl<Args, T, U, R, F> FusedIterator for RepMap<Args, T, U, R, F>
where
R: Replicator<Args, T, U>,
F: FnOnce(T) -> U,
{
}
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.state {
State::Active {
source, remaining, ..
} => f
.debug_struct("RepMap")
.field("source", &source.0)
.field("items_left", &(*remaining + 1))
.finish_non_exhaustive(),
State::Done => 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: 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: 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,
};
#[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() {
#[allow(clippy::trivially_copy_pass_by_ref)]
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)");
}
}