如何让Rust编译器认定两个GAT为同一类型？

问题场景 #

实现带自定义比较器的归并排序时，为了复用impl FnMut类型的比较器，常规操作是传递&mut impl FnMut，但碰到零尺寸类型（ZST）的比较器时，真实引用会拖慢编译器优化。于是我用specialization和generic_const_exprs特性实现了EfficientZstRep trait：

• 对ZST生成轻量引用结构体
• 对非ZST使用普通引用

共享引用场景功能正常，但可变引用里，为支持重借用写的Reborrow trait，编译器死活认不出reborrow返回的类型和MutRef类型是一回事。试了显式标类型、加where约束都没用，要么类型不匹配，要么推导溢出。

问题根源 #

本质是Reborrow trait的关联类型推导卡壳了：结合specialization和泛型常量表达式时，编译器没法把reborrow的返回类型和trait里定义的MutRef关联类型划等号，类型系统的推导能力跟不上，就出了问题。

解决思路 #

1. 硬绑定关联类型与返回类型 #

在Reborrow trait里给reborrow加明确的where约束，强制返回类型等于MutRef：

trait Reborrow {
    type MutRef<'a> where Self: 'a;
    fn reborrow(&mut self) -> Self::MutRef<'_>;
}

// ZST的实现
impl<T: FnMut(...) + Sized> Reborrow for EfficientZstRep<T>
where
    T: ZST, // 假设ZST是判断零尺寸的trait
    <EfficientZstRep<T> as Reborrow>::MutRef<'_>: /* 必要约束 */,
{
    type MutRef<'a> = LightweightRef<'a, T> where Self: 'a;
    fn reborrow(&mut self) -> Self::MutRef<'_> {
        LightweightRef::new(/* 构造逻辑 */)
    }
}

// 非ZST的实现
impl<T: FnMut(...) + Sized> Reborrow for EfficientZstRep<T>
where
    T: !ZST,
    <EfficientZstRep<T> as Reborrow>::MutRef<'_> = &'_ mut T,
{
    type MutRef<'a> = &'a mut T where Self: 'a;
    fn reborrow(&mut self) -> Self::MutRef<'_> {
        &mut self.inner // 假设inner是存储的引用
    }
}

2. 用类型别名简化推导 #

给MutRef关联类型定义别名，实现里直接用别名，减少编译器的推导压力：

type ZstMutRef<'a, T> = LightweightRef<'a, T>;
type NonZstMutRef<'a, T> = &'a mut T;

trait Reborrow {
    type MutRef<'a> where Self: 'a;
    fn reborrow(&mut self) -> Self::MutRef<'_>;
}

impl<T: FnMut(...) + ZST> Reborrow for EfficientZstRep<T> {
    type MutRef<'a> = ZstMutRef<'a, T> where Self: 'a;
    fn reborrow(&mut self) -> ZstMutRef<'_, T> {
        // 构造逻辑
    }
}

impl<T: FnMut(...) + !ZST> Reborrow for EfficientZstRep<T> {
    type MutRef<'a> = NonZstMutRef<'a, T> where Self: 'a;
    fn reborrow(&mut self) -> NonZstMutRef<'_, T> {
        &mut self.inner
    }
}

3. 调整specialization的优先级 #

确保specialization的实现有明确优先级，别让编译器推导时犯迷糊：

// 先写非ZST的基础实现
default impl<T: FnMut(...) + Sized> Reborrow for EfficientZstRep<T> {
    type MutRef<'a> = &'a mut T where Self: 'a;
    fn reborrow(&mut self) -> &'_ mut T {
        &mut self.inner
    }
}

// 再写ZST的特化实现，约束更严格
impl<T: FnMut(...) + ZST> Reborrow for EfficientZstRep<T> {
    type MutRef<'a> = LightweightRef<'a, T> where Self: 'a;
    fn reborrow(&mut self) -> LightweightRef<'_, T> {
        LightweightRef::new()
    }
}

4. 简化泛型常量表达式逻辑 #

如果generic_const_exprs是推导溢出的元凶，把常量判断移到trait的关联常量里，别直接在泛型参数里用：

trait IsZst {
    const IS_ZST: bool = std::mem::size_of::<Self>() == 0;
}

impl<T> IsZst for T {}

struct EfficientZstRep<T>(T);

// 注意：当前Rust不支持关联类型里用if表达式，需结合specialization实现
impl<T: FnMut(...) + IsZst> Reborrow for EfficientZstRep<T>
where
    Self: Sized,
{
    type MutRef<'a> = /* 用specialization分情况定义 */ where Self: 'a;
    fn reborrow(&mut self) -> Self::MutRef<'_> {
        // 对应逻辑
    }
}

要点提醒 #

• 所有trait实现的关联类型和方法返回类型必须完全一致，别搞隐式转换
• 用where约束把类型关系写死，减少编译器的推导工作量
• 用specialization时，特化实现的约束一定要比基础实现更严格，避免歧义
• 用generic_const_exprs时，尽量简化表达式，别搞复杂条件让编译器卡壳

内容的提问来源于stack exchange，提问作者Chayim Friedman