I have this Rust code:

```
pub trait ValueModel<T> {
    /// Value of the element at the given index.
    fn data(&self, index: usize) -> T;
}

// Generic implementation for types implementing std::ops::Index
impl<T, C> ValueModel<T> for C
where
    T: Clone,
    C: std::ops::Index<usize, Output = T> + ?Sized,
{
    fn data(&self, index: usize) -> T {
        self[index].clone()
    }
}

// Generic implementation for slices
impl<T> ValueModel<T> for &[T]
where
    T: Clone,
{
    fn data(&self, index: usize) -> T {
        (*self)[index].clone()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::collections::VecDeque;

    #[test]
    fn with_array() {
        let sequence = [11, 22, 33];
        assert_eq!(sequence.data(1), 22);

        let model = &sequence as &dyn ValueModel<i32>;
        assert_eq!(model.data(1), 22);
    }

    #[test]
    fn with_vec() {
        let sequence = vec![11, 22, 33];
        assert_eq!(sequence.data(1), 22);

        let model = &sequence as &dyn ValueModel<i32>;
        assert_eq!(model.data(1), 22);
    }

    #[test]
    fn with_vec_deque() {
        let sequence = VecDeque::from([11, 22, 33]);
        assert_eq!(sequence.data(1), 22);

        let model = &sequence as &dyn ValueModel<i32>;
        assert_eq!(model.data(1), 22);
    }

    #[test]
    fn with_slice() {
        let sequence = [11, 22, 33];
        let slice = sequence.as_slice();
        assert_eq!(slice.data(1), 22);

        // This won't compile:
        // let model = slice as &dyn ValueModel<i32>;
        //
        // It will produce this error
        // error[E0277]: the size for values of type `[i32]` cannot be known at compilation time
        //     |
        // 178 |             let model = slice as &dyn ValueModel<i32>;
        //     |                         ^^^^^ doesn't have a size known at compile-time
        //     |
        //     = help: the trait `Sized` is not implemented for `[i32]`
        //     = note: required for the cast from `&[i32]` to `&dyn t2::ValueModel<i32>`

        let model = &slice as &dyn ValueModel<i32>;
        assert_eq!(model.data(1), 22);
    }
}
```

It doesn't compile and I get this error:

```
error[E0119]: conflicting implementations of trait `ValueModel<_>` for type `&[_]`
    |
117 | /     impl<T, C> ValueModel<T> for C
118 | |     where
119 | |         T: Clone,
120 | |         C: std::ops::Index<usize, Output = T> + Sized,
    | |______________________________________________________- first implementation here
...
128 | /     impl<T> ValueModel<T> for &[T]
129 | |     where
130 | |         T: Clone,
    | |_________________^ conflicting implementation for `&[_]`
    |
    = note: upstream crates may add a new impl of trait `std::ops::Index<usize>` for type `&[_]` in future versions
```

So I can't have both implementations at the same time.
Notice that the second implementation is not redundant, because std::ops::Index is implemented for `[T]`, but not for `&[T]`.
In fact, if I have only the first implementation, the tests `with_array`, `with_vec` and `with_vec_deque` compile, but there's an error in `with_slice`.
If I have only the second implementation, only the test `with_slice` compiles.
Is there a workaround for this?