为什么对实现 Fn 特征的特征的引用不可调用？

Question

我找到了自己对my own question 的回答，如下所示

trait Mu<T> {
    fn unroll(&self, &Mu<T>) -> T;
}

impl<T, F:Fn(&Mu<T>) -> T> Mu<T> for F {
    fn unroll(&self, o:&Mu<T>) -> T { self(o) }
}

fn y<T, F:Fn(T) -> T>(f:&F) -> T {
    (&|w:&Mu<T>| { w.unroll(w) }).unroll(&|w:&Mu<T>| { f(w.unroll(w)) })
}

它编译并完全回答了问题。但为了让它更漂亮，我为Mu<T> 实现了Fn 特征，如下所示：

impl<'a, T> Fn<&'a Mu<T>> for &'a Mu<T> {
    extern "rust-call" fn call(&self, o: &'a Mu<T>) -> T {
        self.unroll(o)
    }
}

impl<'a, T> FnMut<&'a Mu<T>> for &'a Mu<T> {
    extern "rust-call" fn call_mut(&mut self, o: &'a Mu<T>) -> T {
        self.unroll(o)
    }
}

impl<'a, T> FnOnce<&'a Mu<T>> for &'a Mu<T> {
    type Output = T;
    extern "rust-call" fn call_once(self, o: &'a Mu<T>) -> T {
        self.unroll(o)
    }
}

有特色

#![feature(fn_traits)]
#![feature(unboxed_closures)]

我想把 y 组合器写成

fn y1<T, F:Fn(T) -> T>(f:&F) -> T {
    (&|w:&Mu<T>| { w(w) })(&|w:&Mu<T>| { f(w(w)) })
}

但这不会编译。错误信息：

rustc 1.19.0-nightly (78d8416ca 2017-06-17)
error[E0618]: expected function, found `&Mu<T>`
  --> <anon>:36:20
   |
36 |     (&|w:&Mu<T>| { w(w) })(&|w:&Mu<T>| { f(w(w)) })
   |                    ^^^^
   |
note: defined here
  --> <anon>:36:8
   |
36 |     (&|w:&Mu<T>| { w(w) })(&|w:&Mu<T>| { f(w(w)) })
   |        ^

error[E0618]: expected function, found `&Mu<T>`
  --> <anon>:36:44
   |
36 |     (&|w:&Mu<T>| { w(w) })(&|w:&Mu<T>| { f(w(w)) })
   |                                            ^^^^
   |
note: defined here
  --> <anon>:36:30
   |
36 |     (&|w:&Mu<T>| { w(w) })(&|w:&Mu<T>| { f(w(w)) })
   |                              ^

为什么 Rust 无法找出给定的 Fn 实现？有什么办法可以改善吗？

进一步的尝试表明它与这些功能无关，甚至与闭包有关。即使答案中显示的示例 Shepmaster 也不是最小的。一个最小的示例如下所示：

trait T1 {}

trait T2 {}

impl<'a> T1 for &'a T2 {}

struct S {}

impl T2 for S {}

fn main() {
    let t2: &T2 = &S {};
    let t1: &T1 = &t2; //This is OK
    let t3: &T1 = t2; //E0308: Expecting `T1`, found `T2`
}

问题是我们试图为 trait 对象引用实现一个 trait，然后我们需要在将 trait 对象转换为目标 trait 的 trait 对象时添加额外的引用。

Answer 1

在与 Rust 开发人员讨论后，我们认为这是某种错误。为此，我们已提交issue 42736。

一个较小的示例显示了与特征分开的问题。它实际上是任何参考，而不仅仅是特征：

#![feature(fn_traits)]
#![feature(unboxed_closures)]

struct S;

fn repro_ref(thing: &S) {
    thing();
}

impl<'a> FnOnce<()> for &'a S {
    type Output = ();

    extern "rust-call" fn call_once(self, _arg: ()) -> () {}
}

fn main() {}

有一个解决方法是采取另一个参考：

fn ok_ref_ref(thing: &S) {
    (&thing)();
}

但这并不能修复原始示例：

fn y1<T, F>(f: &F) -> T
where
    F: Fn(T) -> T,
{
    (&|w: &Mu<T>| (&w)(w))(&|w: &Mu<T>| f((&w)(w)))
}

error[E0059]: cannot use call notation; the first type parameter for the function trait is neither a tuple nor unit
  --> src/main.rs:41:19
   |
41 |     (&|w: &Mu<T>| (&w)(w))(&|w: &Mu<T>| f((&w)(w)))
   |                   ^^^^^^^

这是因为 Fn* 特征的原始实现并不完全正确。参数应该是单个元组。注意Fn<(&'a Mu<T>,)> 中的括号和尾随逗号。

总的来说，这是可行的：

#![feature(fn_traits)]
#![feature(unboxed_closures)]

trait Mu<T> {
    fn unroll(&self, &Mu<T>) -> T;
}

impl<T, F> Mu<T> for F
where
    F: Fn(&Mu<T>) -> T,
{
    fn unroll(&self, o: &Mu<T>) -> T {
        self(o)
    }
}

impl<'a, T> Fn<(&'a Mu<T>,)> for &'a Mu<T> {
    extern "rust-call" fn call(&self, o: (&'a Mu<T>,)) -> T {
        self.unroll(o.0)
    }
}

impl<'a, T> FnMut<(&'a Mu<T>,)> for &'a Mu<T> {
    extern "rust-call" fn call_mut(&mut self, o: (&'a Mu<T>,)) -> T {
        self.call(o)
    }
}

impl<'a, T> FnOnce<(&'a Mu<T>,)> for &'a Mu<T> {
    type Output = T;
    extern "rust-call" fn call_once(mut self, o: (&'a Mu<T>,)) -> T {
        self.call_mut(o)
    }
}

fn y1<T, F>(f: &F) -> T
where
    F: Fn(T) -> T,
{
    (&|w: &Mu<T>| (&w)(w))(&|w: &Mu<T>| f((&w)(w)))
}

fn main() {}

我还将来自 Fn* 特征的调用委托给彼此以避免重复实现。