Unleash the power of nightly Rust to write code that's generic over mutation!

use mutation::prelude::*;

struct MyVec<T>(Vec<T>);

impl<T> MyVec<T> {
    /// This function 'glues' our generic-over-mutation API to the underlying
    /// non-generic API of `Vec`.
    pub fn get<'a, R: Ref<'a, Self>>(self: R, idx: usize) -> Option<RefMap<'a, R, T>> {
        /// The underlying `Vec` is not generic over mutation, so here we
        /// specialize our function with the corresponding function of `Vec`.
        self.map::<Option<GenRef<T>>, _, _>(
            |this: &Self| this.0.get(idx),
            |this: &mut Self| this.0.get_mut(idx),
        )
    }

    /// This function 'glues' our generic-over-mutation API to the underlying
    /// non-generic API of `Vec`.
    pub fn iter<'a, R: Ref<'a, Self>>(self: R) -> impl Iterator<Item = RefMap<'a, R, T>> where T: 'a {
        /// The underlying `Vec` is not generic over mutation, so here we
        /// specialize our function with the corresponding function of `Vec`.
        self.map::<SliceIter<T>, _, _>(
            |this: &Self| this.0.iter(),
            |this: &mut Self| this.0.iter_mut(),
        )
    }

    /// And now for some functions that are truly generic over mutation using
    /// the API above...

    /// This function works for both mutable and immutable references!
    pub fn get_expect<'a, R: Ref<'a, Self>>(self: R, idx: usize) -> RefMap<'a, R, T> {
        self.get(idx).unwrap()
    }

    /// This function works for both mutable and immutable references!
    pub fn iter_positive<'a, R: Ref<'a, Self>>(self: R) -> impl Iterator<Item = RefMap<'a, R, T>>
        where T: PartialOrd<i32> + 'a
    {
        self.iter().filter(|x| **x >= 0)
    }
}

/// Example usage

let mut my_vec = MyVec(vec![1, 2, 3]);

assert_eq!((&my_vec).iter().copied().sum::<i32>(), 8);

// Iterate elements immutably
assert_eq!((&my_vec).iter_positive().copied().sum::<i32>(), 9);

// Mutate the second element
*(&mut my_vec).get_expect(1) = 4;

// Immutably access the second element
assert_eq!(my_vec.get_expect(1), Some(&4));

// Iterate elements mutably, giving each a value of 1
(&mut my_vec).iter_positive().for_each(|x| *x = 1);

assert_eq!(my_vec.0, vec![-1, 1, 1, 1]);