如果将返回值分配给变量之前，方法返回dyn将无法编译

Question

在编写工厂方法数小时挣扎后，该方法返回包含通用类型字段（实现特征）的结构的实例，我发现它仅在返回变量之前将结果分配给变量时才进行编译并运行（有关完整的工作示例，请参见帖子的底部：

此编译和运行：

fn compiles() -> Parent<dyn IsAChild> {
    return match rand::thread_rng().gen_bool(1.0/2.0) {
        true => Parent { child: Box::new(Daughter{} ) },
        false => Parent { child: Box::new(Son{} ) },
    }
}

这不编译：

fn does_not_compile() -> Parent<dyn IsAChild> {
    return match rand::thread_rng().gen_bool(1.0/2.0) {
        true => {
            let parent = Parent { child: Box::new(Daughter {}) };
            parent
        },
        false => {
            let parent = Parent { child: Box::new(Son {}) };
            parent
        },
    }

}

di dio_not_compile（）函数会导致以下错误：

error[E0308]: mismatched types
  --> src\main.rs:39:13
   |
39 |             parent
   |             ^^^^^^ expected trait object `dyn IsAChild`, found struct `Daughter`
   |
   = note: expected struct `Parent<(dyn IsAChild + 'static)>`
              found struct `Parent<Daughter>`

这使我完全陷入困境。对我来说，两者之间没有语义差异，只有结果（暂时）存储在变量之前的事实。这里发生了什么？

完成示例（添加rand =“*”到依赖项）：

use rand::Rng;

trait IsAChild {}

struct Parent<T: IsAChild + ?Sized> {
    child: Box<T>
}

struct Son;
impl IsAChild for Son {}

struct Daughter;
impl IsAChild for Daughter {}

fn compiles() -> Parent<dyn IsAChild> {
    return match rand::thread_rng().gen_bool(1.0/2.0) {
        true => Parent { child: Box::new(Daughter{} ) },
        false => Parent { child: Box::new(Son{} ) },
    }
}

fn compiles_too() -> Parent<dyn IsAChild> {
    return match rand::thread_rng().gen_bool(1.0/2.0) {
        true => {
            println!("It's a girl!");
            Parent { child: Box::new(Daughter{} ) }
        },
        false => {
            println!("It's a boy!");
            Parent { child: Box::new(Son{} ) }
        },
    }
}

/*
fn does_not_compile() -> Parent<dyn IsAChild> {
    return match rand::thread_rng().gen_bool(1.0/2.0) {
        true => {
            let parent = Parent { child: Box::new(Daughter {}) };
            parent
        },
        false => {
            let parent = Parent { child: Box::new(Son {}) };
            parent
        },
    }
}
*/

fn main() {
    compiles();
}    

Answer 1

这里的区别是类型推理。在第一个示例中，因为表达式是返回值，因此编译器查看函数签名以确定parent的通用参数，它决定为dyn> dyn dyn isachild。在第二个示例中，编译器需要推断变量parent的类型。它首先查看分配给表达式的类型，然后parent {child：box :: box :: new（daughter {}）}的类型是明确的parent＆lt; apent＆lt; daight＆gt; ，因此给出了该类型的变量，而不是parent＆lt; dyn isachild＆gt;。您可以通过明确地说编译器仅将box的内容胁迫的内容来修复第二个示例

let parent: Parent<dyn IsAChild> = Parent { child: Box::new(Daughter {}) };

，如果需要的话，将其固定在未介绍的类型上，因此这就是为什么需要明确具有变量的示例的原因。

Answer 2

这是因为编译器从我们对其的使用情况下推论了板条的确切类型。

当这是匹配语句的直接结果时，因此该功能的结果必须与parent＆lt; dyn isachild＆gt;完全匹配。

但是，如果您将其存储在本地变量中，则该类型不受限制，它只是parent＆lt; daughter＆gt;或parent＆lt; son＆gt;（no dyn the there）。
当使用这些变量以产生函数的结果时，它们不匹配。

您可以强制变量的类型让父级：parent＆lt; dyn isachild＆gt; = parent {child：box :: new（daughter {}），};。