如果我指定了正确的“Fn”边界，为什么我不能传递泛型函数？

Question

我在回答其他人的问题，试图命名一个泛型函数的类型，并将其传递给其他人，我试图编写这段代码，这似乎符合Rust的类型和特性：

use std::fmt::Display;
fn generic_fn<A: Display>(x: A) -> String { format!("→{}←", x) }

fn use_twice<F>(f: F) -> String
where
    F: Fn(i32) -> String,
    F: Fn(f32) -> String,
{
    f(1) + &f(2.0)
}

fn main() {
    dbg!(use_twice(generic_fn));
}

但是，它无法编译（在稳定的Rust 1.52.0上）：

error[E0631]: type mismatch in function arguments
  --> src/main.rs:13:15
   |
1  | fn generic_fn<A>(x: A) -> A { x }
   | --------------------------- found signature of `fn(i32) -> _`
2  | 
3  | fn use_twice<F>(f: F)
   |    --------- required by a bound in this
...
6  |     F: Fn(f32) -> f32,
   |        -------------- required by this bound in `use_twice`
...
13 |     use_twice(generic_fn);
   |               ^^^^^^^^^^ expected signature of `fn(f32) -> _`

我理解这意味着编译器要求将fn项泛型_fn强制为函数指针（部分指定的类型fn（f32））-

我知道这在逻辑上并不是不可能的，因为如果我编写自己的trait而不是使用Fn，那么我可以显式定义一个可以作为值传递的泛型函数：

trait PolyFn1<A> {
    type Output;
    fn apply(&self, x: A) -> Self::Output;
}

use std::fmt::Display;
struct GenericFn;
impl<A: Display> PolyFn1<A> for GenericFn {
    type Output = String;
    fn apply(&self, x: A) -> String { format!("→{}←", x) }
}

fn use_twice<F>(f: F) -> String
where
    F: PolyFn1<i32, Output=String>,
    F: PolyFn1<f32, Output=String>,
{
    f.apply(1) + &f.apply(2.0)
}

fn main() {
    dbg!(use_twice(GenericFn));
}

[src/main.rs:22] use_twice(GenericFn) = "→1←→2←"

使用不稳定的Rust功能，我甚至可以这样实现Fn：

#![feature(fn_traits)]
#![feature(unboxed_closures)]
use std::fmt::Display;

struct GenericFn;
impl<A: Display> FnOnce<(A,)> for GenericFn {
    type Output = String;
    extern "rust-call" fn call_once(self, args: (A,)) -> String {
        self.call(args)
    }
}
impl<A: Display> FnMut<(A,)> for GenericFn {
    extern "rust-call" fn call_mut(&mut self, args: (A,)) -> String {
        self.call(args)
    }
}
impl<A: Display> Fn<(A,)> for GenericFn {
    extern "rust-call" fn call(&self, args: (A,)) -> String {
        format!("→{}←", args.0)
    }
}

fn use_twice<F>(f: F) -> String
where
    F: Fn(i32) -> String,
    F: Fn(f32) -> String,
{
    f(1) + &f(2.0)
}

fn main() {
    dbg!(use_twice(GenericFn));
}

鉴于此，我可以重申我的问题：为什么Rust的正常功能项不这样工作？为什么他们有这种看似可以避免的限制？




Answer 1

这里的问题是，这些类型确实不兼容。您将一个函数传递给use_两次，该函数需要有一个定义良好的类型，因此它无法处理

    F: Fn(i32) -> String,
    F: Fn(f32) -> String,

因为一个函数不能有两种不同类型的参数。我假设你希望它会自动应用模板两次，同时仍然有一个单一的功能，但这不是Rust的工作原理。

所以重新审视这个错误

error[E0631]: type mismatch in function arguments
  --> src/main.rs:13:15
   |
1  | fn generic_fn<A>(x: A) -> A { x }
   | --------------------------- found signature of `fn(i32) -> _`
2  | 
3  | fn use_twice<F>(f: F)
   |    --------- required by a bound in this
...
6  |     F: Fn(f32) -> f32,
   |        -------------- required by this bound in `use_twice`
...
13 |     use_twice(generic_fn);
   |               ^^^^^^^^^^ expected signature of `fn(f32) -> _`

它说它使用了generic_fn::

所以从根本上说，你的函数参数边界是不可行的，你的设计需要改变。

Answer 2

我的问题也许是：为什么具体类型的generic_fn不提供这个？

因为没有“generic_fn的具体类型”这样的东西。当你写

use_twice(generic_fn)

真的

use_twice(generic_fn::<Something>)

其中某事由编译器推断。但是如果某事是i32，那么generic_fn::

也许吧

where
    F: for<A> Fn(A) -> String,

会工作，但不支持（还？）。

在工作情况下，您只需传递GenericFn，那里没有类型参数可供推断。它需要在f.apply（1）和f.apply（2.0）中推断，但这是两个不同的地方，那里有不同的类型参数没有问题。

Answer 3

我认为答案在于structGenericFn不是泛型类型。

泛型类型提供了一个“配方”，编译器使用它来构造一个可以使用的实际具体类型。

通用结构Foo

泛型函数基本上是一样的，它为它所泛化的每个不同类型创建一个不同的函数指针<代码>foo

现在，一个函数需要一个同时具有traitFn（bar）的类型-

您的GenericFn有效，因为具体类型实际上实现了PolyFn1