#![feature(generators, generator_trait)]

fn main() {
    let mut data = vec![3,2,1];

    for state in bubble_sort(&mut data) {
        dbg!(state);
    }
}

fn bubble_sort<T>(items: &mut Vec<T>) -> impl Iterator<Item = Vec<T>>  + '_
where
    T: PartialOrd + Clone,
{
    IterGen(move || {
        loop {
            let mut swapped = false;

            for i in 1..items.len() {
                if items[i-1] > items[i] {
                    items.swap(i-1, i);
                    swapped = true;
                    yield items.clone();
                }
            }

            if !swapped { break }
        }
    })
}

// ==== Generator -> Iterator boilerplate

use std::ops::{Generator, GeneratorState};
use std::pin::Pin;

pub struct IterGen<G: Generator>(pub G);

impl<G> Iterator for IterGen<G>
where
    G: Generator<Return = ()> + Unpin,
{
    type Item = G::Yield;

    fn next(&mut self) -> Option<Self::Item> {
        match { Pin::new(&mut self.0).resume() } {
            GeneratorState::Yielded(element) => Some(element),
            _ => None,
        }
    }
}