mod array {
    use std::marker::PhantomData;

    #[derive(Clone, Copy, Debug, Default)]
    pub struct InvariantLifetime<'id>(PhantomData<*mut &'id ()>);

    #[derive(Debug)]
    pub struct Wrapper<'id, T: 'id> {
        array: &'id mut Vec<T>,
        marker: InvariantLifetime<'id>,
    }

    #[derive(Clone, Copy, Debug)]
    pub struct Index<'id> {
        at: usize,
        _marker: InvariantLifetime<'id>,
    }

    impl<'id, T: 'id> Wrapper<'id, T> {
        pub fn find(&self, index: usize) -> Option<Index<'id>> {
            if index >= self.array.len() {
                None
            } else {
                Some(Index { at: index, _marker: Default::default(), })
            }
        }

        pub fn get(&self, index: Index<'id>) -> &T {
            unsafe { self.array.get_unchecked(index.at) }
        }
    }

    pub fn of<T, F: for<'id> FnOnce(Wrapper<'id, T>)>(array: &mut Vec<T>, f: F) {
        f(Wrapper { array, marker: InvariantLifetime::default(), })
    }
}

fn main() {
    let mut xs = vec![0, 1, 2, 3, 4];
    let mut ys = vec![21, 22, 23, 24, 25, 26, 27, 28, 29, 30];

    array::of(&mut xs, |wrapper| {
        // xs.push(5);
        let i = wrapper.find(3).unwrap();
        println!("found it in xs! value @ {:?}: {}", i, wrapper.get(i));
        // xs.clear();
        // println!("still have it! value @ {:?}: {}", i, wrapper.get(i));
        array::of(&mut ys, |other| {
            let j = other.find(8).unwrap();
            println!("found it in ys! value @ {:?}: {}", j, other.get(j));
            // println!("found it in xs! value @ {:?}: {}", j, wrapper.get(j));
        });
    });
}