Is it possible to implement an iter for slices that could perform bubble-sort?

In some algorithm, we may want to index a single vector twice (e.g., bubble-sort)

for i in 0..vec.len() {
    for j in 0..i {
        if vec[i]>vec[j] {

is it possible to provide some api that could index the same vector twice or even more?

 // yields [&slice[i],&slice[j],&slice[k],...] where i<j<k<...
fn iter_ascend<T,const N:usize>(&[T])->impl Iterator<Item=[&T;N]> {...}
fn iter_ascend_mut<T,const N:usize>(&mut [T])->impl Iterator<Item=[&mut T;N]> {...}
 // yields [&slice[i],&slice[j],&slice[k],...] where i>j>k>...
fn iter_descend<T,const N:usize>(&[T])->impl Iterator<Item=[&T;N]> {...}
fn iter_descend_mut<T,const N:usize>(&mut [T])->impl Iterator<Item=[&mut T;N]> {...}
 // yields [&slice[i],&slice[j],&slice[k],...] for all valid i,j,k,...
fn iter<T,const N:usize>(&[T])->impl Iterator<Item=[&T;N]> {...}
// iter_mut is not possible to make such modification here.

Is it worth to wrote such a crate or just open an RFC?

This is probably not common enough to go into std.

1 Like

Itertools::combinations exists.


Mutable access versions won't be possible with a normal Iterator because multiple items cannot be (or contain) mutable references to the same thing.


for creating an iterator, that's ok.

But if we want to modify the slice itself, a _mut suffix is needed.

What's more, combinations() need a Clone mark, which limits the usage of this function.

note: required by a bound in `combinations`
    --> /home/neutron/.cargo/registry/src/
1485 |               Self::Item: Clone
     |                           ^^^^^ required by this bound in `Itertools::combinations`

Shared references are Clone. The &mut case isn't possible. But Cell can get you part way there.


But that's not an ad-hoc constraint. How do you expect the iterator to return the same item multiple times if it can't be duplicated somehow?

This topic was automatically closed 90 days after the last reply. We invite you to open a new topic if you have further questions or comments.