Rust Specialising Range or overloading ".."

不，你不能.

根据orphan rules人的定义:

给定impl<P1..=Pn> Trait<T1..=Tn> for T0，impl仅在以下至少一项为真时有效:

• trait 是local trait分
• 全部

只有uncovered个类型参数的外观受到限制.注意，为了连贯性，fundamental types是特殊的.T-in-Box不被认为是覆盖的，而Box被认为是局部的.

地方特色

当前 crate 中定义的trait.特征定义是局部的，或者与应用的类型参数无关.给定trait Foo<T, U>，Foo总是本地的，不管T和U的类型是什么.

本地类型

当前 crate 中定义的struct、enum或union.这不受应用类型参数的影响.struct Foo被认为是本地的，但Vec<Foo>不是.LocalType<ForeignType>是本地的.类型别名不影响位置.

因为Index、Range和Vec都不是本地类型，Range也不是基本类型，所以你不能用impl<T> Index<Range<...>> for Vec<T>来代替....

这些规则的原因是没有任何东西阻止Range或Vec实现impl<T, Idx> Index<Range<Idx>> for Vec<T>.这样的impl不存在，可能永远也不会存在，但规则在所有类型中都是相同的，在一般情况下，这肯定会发生.

您也不能重载range操作符——它总是创建一个Range(或RangeInclusive、RangeFull等).

我能想到的唯一解决方案是按照 comments 中的建议，为Vec创建一个新的类型包装器.

如果希望向量返回一个已包装的切片，可以使用一些不安全的代码:

use std::ops::{Index, IndexMut, Range, Deref, DerefMut};

#[repr(transparent)] // Because of this we can soundly cast `&{mut }[T]` to `&{mut }MySlice<T>`.
pub struct MySlice<T>([T]);

impl<'a, T> From<&'a [T]> for &'a MySlice<T> {
    fn from(v: &'a [T]) -> &'a MySlice<T> {
        unsafe { &*(v as *const [T] as *const MySlice<T>) }
    }
}
impl<'a, T> From<&'a mut [T]> for &'a mut MySlice<T> {
    fn from(v: &'a mut [T]) -> &'a mut MySlice<T> {
        unsafe { &mut *(v as *mut [T] as *mut MySlice<T>) }
    }
}

impl<T> Index<usize> for MySlice<T> {
    type Output = T;
    fn index(&self, idx: usize) -> &Self::Output { &self.0[idx] }
}
impl<T> IndexMut<usize> for MySlice<T> {
    fn index_mut(&mut self, idx: usize) -> &mut Self::Output { &mut self.0[idx] }
}

impl<T> Index<Range<usize>> for MySlice<T> {
    type Output = MySlice<T>;
    fn index(&self, idx: Range<usize>) -> &Self::Output { self.0[idx].into() }
}
impl<T> IndexMut<Range<usize>> for MySlice<T> {
    fn index_mut(&mut self, idx: Range<usize>) -> &mut Self::Output { (&mut self.0[idx]).into() }
}
// And so on, for all range types...

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

impl<T> Deref for MyVec<T> {
    type Target = MySlice<T>;
    fn deref(&self) -> &Self::Target { self.0.as_slice().into() }
}
impl<T> DerefMut for MyVec<T> {
    fn deref_mut(&mut self) -> &mut Self::Target { self.0.as_mut_slice().into() }
}