Rust 是否有可能同时避免不兼容的不透明类型和代码重复

我个人不同意对两个不同类型的单个函数调用属于"重复代码"的说法.

然而，我怀疑您的实际问题不是关于单个函数调用.但事实是，你必须复制粘贴if次.我怀疑您的真实代码是这样的，而实际问题是要复制粘贴的整个if块代码.

fn f(b: bool) {
    if b {
        foo_true().foo()
    } else {
        foo_false().foo()
    }

    if b {
        foo_true().foo()
    } else {
        foo_false().foo()
    }

    if b {
        foo_true().foo()
    } else {
        foo_false().foo()
    }
}

归根结底，您要处理两种不同的类型，因此需要在某个地方手动处理.或者，您可以使用Box和动态调度，但您说您不想这样做.

您还可以执行以下操作:

fn f(b: bool) {
    let (foo_true, foo_false) = (foo_true(), foo_false());
    let foo: &dyn Foo = if b { &foo_true } else { &foo_false };

    foo.foo();
    foo.foo();
    foo.foo();
}

如果是因为你想完全外推if块.然后你可以将逻辑移动到一个单独的函数中，该函数接受一个闭包:

fn with<T, F>(b: bool, f: F) -> T
where
    F: FnOnce(&dyn Foo) -> T,
{
    if b {
        f(&foo_true())
    } else {
        f(&foo_true())
    }
}

and separately 100 if needed.

然后，您只需要实际的单行:

fn f(b: bool) {
    with(b, |foo| foo.foo());

    with(b, |foo| foo.foo());

    with(b, |foo| foo.foo());
}

然而，第一种情况需要实例化Bar和Baz，而第二种情况需要连续多次实例化相同的Bar/Baz.

而你说你想避免Box岁.那么，您应该同样避免&dyn，因为两者都引入了动态调度.

如果您希望同时避免Box和动态调度，那么最好的方法是引入一个enum，它包含实现Foo的所有变量.

您甚至不必自己维护所有重复的代码.你可以使用enum_dispatch crate，为你生成所有这些.使用enum_dispatch crate应该是这样的:

use enum_dispatch::enum_dispatch;

#[enum_dispatch]
trait Foo {
    fn foo(&self) {}
}

#[enum_dispatch(Foo)]
enum AnyFoo {
    Bar(Bar),
    Baz(Baz),
}

现在，您可以将f()简化为以下公式:

fn f(b: bool) {
    let foo: AnyFoo = if b { Bar.into() } else { Baz.into() };

    foo.foo();
    foo.foo();
    foo.foo();
}

此外，还可以看看benchmarks for the enum approach.因为它显示了使用enum、Box和&dyn的基准结果.