Question

我试图在两种类型之间创建一个类型级别的地图，实现为一个关联列表，这样一个有效的地图实现了这个特征：

trait Key {
    const KEY: usize;
}

trait TypeLevelMap<K: Key, V> {
    fn convert(K) -> V;
}

零案例很简单：

struct TypeLevelMapNil<T>(PhantomData<T>);

impl<K: Key, V> TypeLevelMap<K, V> for TypeLevelMapNil<V> {
    fn convert(k: K) -> V {
        panic!("Unhandled case: {}", K::KEY);
    }
}

但是，我无法弄清楚这种情况：

struct TypeLevelMapCons<K, V, Tl, TlK, TlV>(PhantomData<(K, V, Tl, TlK, TlV)>);

impl<K, V, Tl, TlK, TlV> TypeLevelMap<K,V> for TypeLevelMapCons<K, V, Tl, TlK, TlV>
where
    K: Key,
    Tl: TypeLevelMap<TlK, TlV>,
    TlK: Key,
{
    fn convert(_k: K) -> V {
        unimplemented!()
    }
}

impl<K, V, Tl, TlK, TlV> TypeLevelMap<TlK, TlV> for TypeLevelMapCons<K, V, Tl, TlK, TlV>
where
    K: Key,
    Tl: TypeLevelMap<TlK, TlV>,
    TlK: Key,
{
    fn convert(k: TlK) -> TlV {
        Tl::convert(k)
    }
}

这当然会给类型TypeLevelMap<_, _>＆＃34;提供错误，特征TypeLevelMapCons<_, _, _, _, _>的冲突实施。我无法弄清楚如何告诉Rust更喜欢第一个;专业化没有帮助，并且没有!=在哪里有界限。

有没有办法消除它们的歧义，或者有其他方法来实现它，还是在（当前）Rust中无法实现？

Answer 1

如果我理解正确，您尝试使用不同的泛型类型参数组合TypeLevelMapCons<K, V, Tl, TlK, TlV>实施TypeLevelMap两次。这是不可能的（从Rust 1.23.0开始），因为有K == TlK或V == TlV的可能性。通过特化，其中一个impls必须严格比“默认”impl更具体，即它必须应用于“默认”impl适用的子集，而不再是。但是，此处K和TlK不相关（同样适用于V和TlV），因此两者都不具体。有一个名为intersection impls的提议功能，据我所知，它应该解决这个问题，因为它可以让你编写覆盖交叉点的impl来修复冲突的实现错误。

然而，是使用专业化的解决方案！第一步是将TypeLevelMap更改为不是通用本身;相反，我们将通过从那里的特征移动类型参数来使convert方法通用。通过这样做，我们可以删除TlK上的TlV和TypeLevelMapCons类型参数，这些参数没有用，因为它们只代表可能很多实现中的一个尾巴可能有的TypeLevelMap（事实上，我认为你现在的设计是不可行的）。

为TypeLevelMap实施TypeLevelMapNil很简单：我们只是忽略类型参数。 （注意：我已删除了TypeLevelMapNil上的类型参数，因为它是不必要的。）为TypeLevelMap实施TypeLevelMapCons有点棘手，因为这是我们的地方需要根据密钥的类型而有所不同。

专业化不允许我们在泛型方法上专门化特定的类型参数集，仅限于impls，那么我们如何实现TypeLevelMapCons？通过引入辅助通用特性！我们可以有一个处理递归情况的特征的默认实现，以及一个处理“找到”情况的专用实现。 （注意：这与标准库用于专门化<Vec<T> as Extend<T>>::extend<I>的技术相同。）

#![feature(specialization)]

use std::marker::PhantomData;

trait Key {
    const KEY: usize;
}

trait TypeLevelMap {
    fn convert<K: Key, V>(K) -> V;
}

trait TypeLevelMapConvert<LK, LV> {
    fn convert_impl(LK) -> LV;
}

struct TypeLevelMapNil;

impl TypeLevelMap for TypeLevelMapNil {
    fn convert<K: Key, V>(_k: K) -> V {
        panic!("Unhandled case: {}", K::KEY);
    }
}

struct TypeLevelMapCons<K, V, Tl>(PhantomData<(K, V, Tl)>);

impl<K, V, Tl> TypeLevelMap for TypeLevelMapCons<K, V, Tl>
where
    K: Key,
    Tl: TypeLevelMap,
{
    fn convert<LK: Key, LV>(k: LK) -> LV {
        <Self as TypeLevelMapConvert<LK, LV>>::convert_impl(k)
    }
}

impl<K, V, Tl, LK, LV> TypeLevelMapConvert<LK, LV> for TypeLevelMapCons<K, V, Tl>
where
    K: Key,
    Tl: TypeLevelMap,
    LK: Key,
{
    default fn convert_impl(k: LK) -> LV {
        Tl::convert(k)
    }
}

impl<K, V, Tl> TypeLevelMapConvert<K, V> for TypeLevelMapCons<K, V, Tl>
where
    K: Key,
    Tl: TypeLevelMap,
{
    fn convert_impl(_k: K) -> V {
        unimplemented!()
    }
}

// Sample usage

impl Key for i16 {
    const KEY: usize = 16;
}

impl Key for i32 {
    const KEY: usize = 32;
}

impl Key for i64 {
    const KEY: usize = 64;
}

fn main() {
    TypeLevelMapCons::<i16, i16, TypeLevelMapCons<i32, i32, TypeLevelMapCons<i64, i64, TypeLevelMapNil>>>::convert::<i64, i64>(0);
}

为什么这次专业化工作？首先，让我们看一下默认的impl：

impl<K, V, Tl, LK, LV> TypeLevelMapConvert<LK, LV> for TypeLevelMapCons<K, V, Tl>

此处，LK和LV分别独立于K和V。这意味着此impl将为特定TypeLevelMapCons<K, V, Tl>类型生成无限数量的具体特征实现。

现在，让我们看一下专门的impl：

impl<K, V, Tl> TypeLevelMapConvert<K, V> for TypeLevelMapCons<K, V, Tl>

以下是我们在特征和实施者类型上使用K和V。通过这样做，我们在K和V上引入了等式约束。这意味着此impl将仅为特定TypeLevelMapCons<K, V, Tl>类型生成单个特征实现。这显然是更具体的默认impl！

Rust中的类型级别映射

1 个答案: