如何编写一个方法来包装我的类型中的任何值，可以多次调用而不需要类型注释？

Question

我写了一个类型Wrapper<T>，其中包含T的值：

struct Wrapper<T>(T);

我想要一个方法to_wrap，这将允许我编写这样的代码，其中b是Wrapper<i32>和c是Wrapper<i32>：

let a = 12i32;
let b = a.to_wrap();
let c = b.to_wrap();

我希望v.to_wrap()总能产生一个Wrapper<T>，其中T不是Wrapper。如果v是Wrapper<T>，v.to_wrap()也将是具有相同价值的Wrapper<T>。

我写的最接近我的想法的代码是：

#![feature(specialization)]

#[derive(Debug)]
struct Wrapper<T>(T);

trait ToWrapper<W> {
    fn to_wrap(self) -> W;
}

impl<T> ToWrapper<Wrapper<T>> for T {
    default fn to_wrap(self) -> Wrapper<T> {
        Wrapper(self)
    }
}

impl<T> ToWrapper<Wrapper<T>> for Wrapper<T> {
    fn to_wrap(self) -> Self {
        self
    }
}

fn main() {
    let a = 1i32;
    println!("{:?}", a);
    let a = 1.to_wrap();
    println!("{:?}", a);
    let a: Wrapper<i32> = 1.to_wrap().to_wrap();
    // let a = 1.to_wrap().to_wrap();
    // boom with `cannot infer type`
    println!("{:?}", a);
}

Playground

如果我从let a: Wrapper<i32> = 1.to_wrap().to_wrap()中删除类型注释，则会出现编译错误：

error[E0282]: type annotations needed
  --> src/main.rs:27:9
   |
27 |     let a = 1.to_wrap().to_wrap();
   |         ^
   |         |
   |         cannot infer type
   |         consider giving `a` a type

我希望Rust编译器自动派生出1.to_wrap().to_wrap()的类型。如何编写正确的版本，或者为什么不能编写它？

Answer 1

我不相信你现在可以通过专业化来实现你实现单一特质的目标。

您的特征定义允许相同类型的特征的多个实现：

trait ToWrapper<W> {
    fn to_wrap(self) -> W;
}

impl ToWrapper<i32> for u8 {
    fn to_wrap(self) -> i32 {
        i32::from(self)
    }
}

impl ToWrapper<i16> for u8 {
    fn to_wrap(self) -> i16 {
        i16::from(self)
    }
}

有了这样的设置，就不可能知道to_wrap应该是什么样的结果;你总是需要以某种方式提供输出类型。然后通过尝试在未知类型上调用to_wrap来产生另一种未知类型来复合问题！

通常，使用关联类型将是解决方案，但由于它们与专业化的交互方式，您无法切换到此处。

也可以看看：

• When is it appropriate to use an associated type versus a generic type?
• Mismatch between associated type and type parameter only when impl is marked `default`
• How do I unwrap an arbitrary number of nested Option types?

Answer 2

你可以实现这样的事情，不是使用专业化，而是使用两种不同的特征和一个自动特征来区分它们。

#![feature(optin_builtin_traits)]

auto trait IsWrap {}

#[derive(Debug)]
struct Wrapper<T>(T);

impl<T> !IsWrap for Wrapper<T> {}

trait ToWrapper: Sized {
    fn to_wrap(self) -> Wrapper<Self>;
}

impl<T: IsWrap> ToWrapper for T {
    fn to_wrap(self) -> Wrapper<T> {
        Wrapper(self)
    }
}

trait ToWrapperSelf {
    fn to_wrap(self) -> Self;
}

impl<T> ToWrapperSelf for Wrapper<T> {
    fn to_wrap(self) -> Self {
        self
    }
}

fn main() {
    let a = 1.to_wrap();
    println!("{:?}", a);
    let a = 1.to_wrap().to_wrap(); 
    println!("{:?}", a);
}

与chabapok's suggestion一样，你不能使用这种技术来编写一个泛型函数，当给定一种类型时，它会以一种方式运行，而另一种类型则使用另一种方式（尽管请参见下面的链接）。但是，当编译器知道具体类型而不是程序员知道具体类型时，可以使用它 - 宏可以用作一个可能的用例。

它还有一个优点，就是在任何类型上调用to_wrap方法都不存在歧义。每种类型最多只有一种to_wrap方法，因为Wrappers只有ToWrapperSelf::is_wrap而非Wrappers只有ToWrapper::is_wrap。

另一个缺点是!IsWrap的Wrapper<T>是“传染性的”：包含或可能包含Wrapper<T>的任何类型也将自动!IsWrap。如果在这种类型上调用.to_wrap()，编译器将无法找到该方法并将发出错误。如果这是一个问题，您可以为这些类型手动实现IsWrap，但是寻找另一个不那么脆弱的解决方案可能更为谨慎。

（上面唯一的例外是Box<Wrapper<T>>：你可以在它上面调用ToWrapperSelf::to_wrap来获得Wrapper<T>。这是因为自动解引用规则和Box is special。）

也可以看看

• What is an auto trait in Rust?
• 上面概述的解决方案类似于this answer。
• Can I avoid eager ambiguity resolution for trait implementations with generics?有类似的“专业化但不是真正的”味道。我对这个问题的回答可以与这个答案结合起来创建特征和通用函数，透明地发送Wrappers和非Wrappers，即使你不能充分利用专业化的全部功能。

Answer 3

#[derive(Debug)]
struct Wrapper<T>(T);

trait ToWrapper<W> {
    fn to_wrap(self) -> Wrapper<W>;
}

impl<T> ToWrapper<T> for T {
    fn to_wrap(self) -> Wrapper<T> {
        Wrapper(self)
    }
}

impl<T> Wrapper<T> {
    fn to_wrap(self) -> Wrapper<T> {
        self
    }
}

fn main() {
    let a = 1i32;
    println!("{:?}", a);
    let a = 1.to_wrap();
    println!("{:?}", a);
    let a: Wrapper<i32> = 1.to_wrap().to_wrap();
    let b = 1.to_wrap().to_wrap();
    println!("{:?}", a);
    println!("{:?}", b);
}