Rust显式定义函数签名后仍无法推断泛型类型的原因与解决

Compiling playground v0.0.1 (/playground)
error[E0282]: type annotations needed
  --> src/main.rs:41:8
   |
41 |       &produce_generic(),
   |        ^^^^^^^^^^^^^^^ cannot infer type of the type parameter `P` declared on the function `produce_generic`
   |
help: consider specifying the generic argument
   |
41 |       &produce_generic::<P>(),
   |                       +++++

For more information about this error, try `rustc --explain E0282`.
error: could not compile `playground` due to previous error

trait Produce {
    type Output<A>;
    fn produce<A>(a: A) -> Self::Output<A>;
}

struct ProduceUint;

impl Produce for ProduceUint {
    type Output<A> = u64;
    
    fn produce<A>(_a: A) -> Self::Output<A> {
        0
    }
}

struct ProduceString;

impl Produce for ProduceString {
    type Output<A> = String;
    
    fn produce<A>(_a: A) -> Self::Output<A> {
        "hello".into()
    }
}

fn produce_both<A>(
  produce_uint: &<ProduceUint as Produce>::Output<A>,
  produce_string: &<ProduceString as Produce>::Output<A>
) -> (u64, String) {
    (*produce_uint, produce_string.clone())
}

struct SomeType;

fn produce_generic<P: Produce>() -> P::Output<SomeType> {
    P::produce(SomeType)
}

fn main() {
    assert_eq!(produce_both::<SomeType>(
      &produce_generic(),
      &produce_generic()
    ), (0, "hello".into()))
}

明明produce_both的函数签名已经明确指定了参数对应的Produce实现（ProduceUint和ProduceString），但编译器仍无法推断produce_generic的类型参数P，请问该场景下类型推断失败的原因是什么？是否有替代的函数定义方式帮助编译器完成类型推断？

Rust的类型推断遵循局部性原则，仅支持从「输入参数」推导泛型参数，不支持反向从「返回值类型」推导。具体来说：

• produce_generic是无参数泛型函数，泛型参数P没有任何输入来源供编译器推断。
• 虽然produce_both的参数类型明确对应P::Output<SomeType>的结果，但编译器不会为匹配返回值去枚举所有满足条件的Produce实现——理论上可能存在多个不同的P类型都能生成相同的Output类型，这种反向推导会带来歧义，不符合Rust类型推断的设计逻辑。

方法1：显式指定泛型参数（最直接） #

调用produce_generic时，通过turbofish语法明确指定P的类型：

fn main() {
    assert_eq!(produce_both::<SomeType>(
      &produce_generic::<ProduceUint>(),
      &produce_generic::<ProduceString>()
    ), (0, "hello".into()))
}

方法2：给produce_generic添加标记参数 #

修改函数定义，加入一个P类型的标记参数，让编译器通过参数类型推断P：

fn produce_generic<P: Produce>(_marker: P) -> P::Output<SomeType> {
    P::produce(SomeType)
}

fn main() {
    assert_eq!(produce_both::<SomeType>(
      &produce_generic(ProduceUint),
      &produce_generic(ProduceString)
    ), (0, "hello".into()))
}

内容的提问来源于stack exchange，提问作者Peteris