Question

鉴于以下特征和实施：

trait Wrapper<Type> {
    type Inner : Wrapped<Type>;
    fn bind<B, F>(self, f: F) -> <B as Wrapped<Type>>::Outer
        where B: Wrapped<Type>, F: Fn(Self::Inner) -> <B as Wrapped<Type>>::Outer;
}

trait Wrapped<Type> {
    type Outer : Wrapper<Type>;
}

struct Opt;

impl<T> Wrapped<Opt> for T {
    type Outer = Option<T>;
}

impl<T> Wrapper<Opt> for Option<T> {
    type Inner = T;
    fn bind<B, F>(self, f: F) -> <B as Wrapped<Opt>>::Outer
        where B: Wrapped<Opt>, F: Fn(Self::Inner) -> <B as Wrapped<Opt>>::Outer {
        match self {
            Some(a) => f(a),
            None => None,  // *** fails to compile
        }
    }
}

对于人类而言，<B as Wrapped<Opt>>::Outer类型必须始终为Option<B>，但rustc无法理解这一点，这一点很明显：

src/main.rs:47:21: 47:25 error: mismatched types:
 expected `<B as Wrapped<Opt>>::Outer`,
    found `core::option::Option<_>`
(expected associated type,
    found enum `core::option::Option`) [E0308]
src/main.rs:47             None => None,
                                   ^~~~

有没有办法说服它这是安全的？我甚至满足于unsafe解决方案，但mem::transmute也是不允许的，因为它不能证明类型大小相同且对齐（即使只涉及一个真实类型而不是甚至任何可能搞乱对齐的新型包装器。）

Answer 1

这很可能是一个错误（this one或that one，我不确定）。在它修复之前，我只能想到做一些自定义的不安全技巧。这是一个transmute函数，它在运行时进行大小相等检查。

unsafe fn runtime_transmute<T, U>(t: T) -> U {
    assert_eq!(std::mem::size_of::<T>(), std::mem::size_of::<U>());
    std::ptr::read(&t as *const _ as *const _)
}

现在您可以用

替换None值

unsafe { runtime_transmute(None::<T>) }

有没有办法说服Rust特定的关联类型与具体类型相同？

1 个答案: