Added array_permutations (attempt 2)

src/combinations.rs

@@ -2,7 +2,7 @@ use core::array;
 use std::fmt;
 use std::iter::FusedIterator;
 
-use super::lazy_buffer::{LazyBuffer, PoolIndex};
+use super::lazy_buffer::{LazyBuffer, ArrayOrVecHelper};
 use alloc::vec::Vec;
 
 use crate::adaptors::checked_binomial;
@@ -57,7 +57,7 @@ where
     debug_fmt_fields!(Combinations, indices, pool, first);
 }
 
-impl<I: Iterator, Idx: PoolIndex> CombinationsGeneric<I, Idx> {
+impl<I: Iterator, Idx: ArrayOrVecHelper> CombinationsGeneric<I, Idx> {
     /// Constructor with arguments the inner iterator and the initial state for the indices.
     fn new(iter: I, indices: Idx) -> Self {
         Self {
@@ -174,7 +174,7 @@ impl<I, Idx> Iterator for CombinationsGeneric<I, Idx>
 where
     I: Iterator,
     I::Item: Clone,
-    Idx: PoolIndex,
+    Idx: ArrayOrVecHelper,
 {
     type Item = Idx::Item<I::Item>;
     fn next(&mut self) -> Option<Self::Item> {
@@ -212,7 +212,7 @@ impl<I, Idx> FusedIterator for CombinationsGeneric<I, Idx>
 where
     I: Iterator,
     I::Item: Clone,
-    Idx: PoolIndex,
+    Idx: ArrayOrVecHelper,
 {
 }
 

src/lazy_buffer.rs

@@ -100,7 +100,7 @@ impl MaybeConstUsize for usize {
 
 /// A type holding indices of elements in a pool or buffer of items from an inner iterator
 /// and used to pick out different combinations in a generic way.
-pub trait PoolIndex: BorrowMut<[usize]> {
+pub trait ArrayOrVecHelper: BorrowMut<[usize]> {
     type Item<T>;
     type Length: MaybeConstUsize;
 
@@ -113,7 +113,7 @@ pub trait PoolIndex: BorrowMut<[usize]> {
     fn len(&self) -> Self::Length;
 }
 
-impl PoolIndex for Vec<usize> {
+impl ArrayOrVecHelper for Vec<usize> {
     type Item<T> = Vec<T>;
     type Length = usize;
 
@@ -133,7 +133,7 @@ impl PoolIndex for Vec<usize> {
     }
 }
 
-impl<const K: usize> PoolIndex for [usize; K] {
+impl<const K: usize> ArrayOrVecHelper for [usize; K] {
     type Item<T> = [T; K];
     type Length = ConstUsize<K>;
 

src/permutations.rs

@@ -3,11 +3,11 @@ use alloc::vec::Vec;
 use std::fmt;
 use std::iter::FusedIterator;
 
-use super::lazy_buffer::{LazyBuffer, MaybeConstUsize as _, PoolIndex};
+use super::lazy_buffer::{ArrayOrVecHelper, LazyBuffer, MaybeConstUsize as _};
 use crate::size_hint::{self, SizeHint};
 
 #[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-pub struct PermutationsGeneric<I: Iterator, Idx: PoolIndex> {
+pub struct PermutationsGeneric<I: Iterator, Idx: ArrayOrVecHelper> {
     vals: LazyBuffer<I>,
     state: PermutationState<Idx>,
 }
@@ -23,13 +23,13 @@ impl<I, Idx> Clone for PermutationsGeneric<I, Idx>
 where
     I: Clone + Iterator,
     I::Item: Clone,
-    Idx: Clone + PoolIndex,
+    Idx: Clone + ArrayOrVecHelper,
 {
     clone_fields!(vals, state);
 }
 
 #[derive(Clone, Debug)]
-enum PermutationState<Idx: PoolIndex> {
+enum PermutationState<Idx: ArrayOrVecHelper> {
     /// No permutation generated yet.
     Start { k: Idx::Length },
     /// Values from the iterator are not fully loaded yet so `n` is still unknown.
@@ -44,7 +44,7 @@ enum PermutationState<Idx: PoolIndex> {
     End,
 }
 
-impl<I, Idx: PoolIndex> fmt::Debug for PermutationsGeneric<I, Idx>
+impl<I, Idx: ArrayOrVecHelper> fmt::Debug for PermutationsGeneric<I, Idx>
 where
     I: Iterator + fmt::Debug,
     I::Item: fmt::Debug,
@@ -60,7 +60,7 @@ pub fn permutations<I: Iterator>(iter: I, k: usize) -> Permutations<I> {
     }
 }
 
-impl<I, Idx: PoolIndex> Iterator for PermutationsGeneric<I, Idx>
+impl<I, Idx: ArrayOrVecHelper> Iterator for PermutationsGeneric<I, Idx>
 where
     I: Iterator,
     I::Item: Clone,
@@ -140,7 +140,7 @@ where
     }
 }
 
-impl<I, Idx: PoolIndex> FusedIterator for PermutationsGeneric<I, Idx>
+impl<I, Idx: ArrayOrVecHelper> FusedIterator for PermutationsGeneric<I, Idx>
 where
     I: Iterator,
     I::Item: Clone,
@@ -165,7 +165,7 @@ fn advance(indices: &mut [usize], cycles: &mut [usize]) -> bool {
     true
 }
 
-impl<Idx: PoolIndex> PermutationState<Idx> {
+impl<Idx: ArrayOrVecHelper> PermutationState<Idx> {
     fn size_hint_for(&self, n: usize) -> SizeHint {
         // At the beginning, there are `n!/(n-k)!` items to come.
         let at_start = |n, k: Idx::Length| {