function - 如何从泛型函数返回具体类型？

Question

在下面的示例中，Default 特性仅用于演示目的。

我的问题是:

1. f() 和g() 的声明有什么区别？
2. 为什么 g() 不能编译，因为它与 f() 相同？
3. 如何从 impl trait 通用类型声明中返回具体类型？

struct Something {
}

impl Default for Something {
    fn default() -> Self {
        Something{}
    }
}

// This compiles.
pub fn f() -> impl Default {
    Something{}
}

// This doesn't.
pub fn g<T: Default>() -> T {
    Something{}
}

Answer 1

What is the difference between the declarations of f() and g()?

• f 返回一些实现了 Default 的类型。 f 的调用者无法决定它将返回什么类型。
• g 返回一些实现了 Default 的类型。 g 的调用者可以选择必须返回的确切类型。

您可以清楚地看到 f 和 g 调用方式的差异。例如:

fn main() {
    let t = f(); // this is the only way to call f()
    let t = g::<i32>(); // I can call g() like this
    let t = g::<String>(); // or like this
    let t = g::<Vec<Box<u8>>(); // or like this... and so on!
    // there's potentially infinitely many ways I can call g()
    // and yet there is only 1 way I can call f()
}

Why g() doesn't compile since it's identical to f()?

它们并不相同。 f 的实现可以编译，因为它只能以一种方式调用，并且它将始终返回完全相同的类型。 g 的实现无法编译，因为它可以为所有不同类型调用无限多种方式，但它总是会返回损坏的 Something。

How can I return a concrete type out of a impl trait generically typed declaration?

如果我没有正确理解你的问题，你就不能。当您使用泛型时，您让调用者决定您的函数必须使用的类型，因此您的函数的实现本身必须是泛型的。如果您想在泛型函数中构造并返回泛型类型，通常的做法是将 Default 特性绑定(bind)到泛型类型上，并在您的实现中使用它:

// now works!
fn g<T: Default>() -> T {
    T::default()
}

如果您需要在函数中有条件地选择具体类型，那么唯一的其他解决方案是返回一个特征对象:

struct Something;
struct SomethingElse;

trait Trait {}

impl Trait for Something {}
impl Trait for SomethingElse {}

fn g(some_condition: bool) -> Box<dyn Trait> {
    if some_condition {
        Box::new(Something)
    } else {
        Box::new(SomethingElse)
    }
}