How can I make an indexable wrapper for both `Vec` and `&[i8]`?

Question

Consider the following code:

use std::ops;

struct Wrap<T>(T);

impl<T> Wrap<T> {
    fn new(element: T) -> Self {
        Wrap(element)
    }
}

// implementation of other methods that makes the wrapper necessary ;-)

impl ops::Index<ops::Range<usize>> for Wrap<Vec<i8>> {
    type Output = Wrap<&[i8]>;

    fn index(&self, range: ops::Range<usize>) -> &Self::Output {
        &Wrap::<&[i8]>::new(&self.0[range])
    }
}

impl ops::Index<ops::Range<usize>> for Wrap<&[i8]> {
    type Output = Wrap<&[i8]>;

    fn index(&self, range: ops::Range<usize>) -> &Self::Output {
        &Wrap::<&[i8]>::new(&self.0[range])
    }
}

playground

The compiler states:

error[E0106]: missing lifetime specifier
  --> src/lib.rs:14:24
   |
14 |     type Output = Wrap<&[i8]>;
   |                        ^ expected lifetime parameter

error[E0106]: missing lifetime specifier
  --> src/lib.rs:21:45
   |
21 | impl ops::Index<ops::Range<usize>> for Wrap<&[i8]> {
   |                                             ^ expected lifetime parameter

error[E0106]: missing lifetime specifier
  --> src/lib.rs:22:24
   |
22 |     type Output = Wrap<&[i8]>;
   |                        ^ expected lifetime parameter

How should I set the lifetimes here? I want Wrap to work for owned Vecs as well as borrowed slices. What would be the best solution?

Answer 1

That original design is not possible. Index expects the index method to return a reference to the value of type Self::Output:

fn index<'a>(&'a self, index: Idx) -> &'a Self::Output;

I expanded the lifetime above to emphasize that the returned value must live for as long as self itself. This is achievable when the referenced value is contained in the callee, but this is not the case for a wrapped value. In one of your attempts:

fn index<'a>(&'a self, range: ops::Range<usize>) -> &'a Self::Output {
    &Wrap::<&[i8]>::new(&self.0[range])
}

This creates a reference to a Wrap object that only lives locally (and so does not outlive 'a). This case would call for a different trait, such as WrapIndex, which would, regretfully, not feature the same syntactic sugar. It also cannot be generalized much without generic associated types (GATs).

pub trait WrapIndex<Idx> where
    Idx: ?Sized, {
    type Output: ?Sized;
    fn wrap_index(&self, index: Idx) -> Wrap<&Self::Output>;
}

If you don't mind exposing all methods from a slice type into Wrap, you can also implement Deref for that wrapper, thus obtaining indexing and slicing for free.

impl<T> Deref for Wrap<T>
where T: Deref
{
    type Target = <T as Deref>::Target;

    fn deref(&self) -> &Self::Target {
        self.0.deref()
    }
}

Answer 2

Cow<[T]> is probably what you are after:

it can enclose and provide immutable access to borrowed data, and clone the data lazily when mutation or ownership is required

use std::borrow::Cow;

fn main() {
    let w1: Cow<[i8]> = vec![1i8, 2, 3].into();
    let w2: Cow<[i8]> = (&[1i8, 2, 3][..]).into();

    println!("{:?}", &w1[1..2]);
    println!("{:?}", &w2[1..2]);
}

This provides a wrapper applicable to both owned vectors and borrowed slices without the need to reinvent the wheel :).