Rust: exploring GATs

gats.rs

use std::error::Error;

struct WindowsMut<'t, T> {
    slice: &'t mut [T],
    start: usize,
    window_size: usize,
}

trait LendingIterator {
    type Item<'a>
    where
        Self: 'a;

    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>>;
}

impl<'t, T> LendingIterator for WindowsMut<'t, T> {
    type Item<'a> = &'a mut [T] where Self: 'a;

    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>> {
        let retval = self.slice[self.start..].get_mut(..self.window_size)?;
        self.start += 1;
        Some(retval)
    }
}

fn main() -> Result<(), Box<dyn Error>> {
    let mut xs: [u8; 3] = [1, 2, 3];

    println!("xs = {xs:?}");

    let mut wm = WindowsMut {
        slice: &mut xs,
        start: 0,
        window_size: 2,
    };

    // while let Some(slice) = wm.next() {
    //    slice.iter_mut().for_each(|x| {
    //        *x += 1;
    //    });
    // }

    let slice1 = wm.next().unwrap();
    let slice2 = wm.next().unwrap(); // BOGUS
    slice1.iter_mut().for_each(|x| {
        slice2.into_iter().for_each(|y| {
            *y += *x;
        })
    });

    println!("xs = {xs:?}");

    Ok(())
}