我想编写一个通用函数count_calls，该函数调用一个函数f，该函数带有一个函数指针（lambda），其中count_calls计算调用函数f的频率lambda函数。
我对方法（Playground）感到困惑。
fn count_calls<S, F>(s: S, f: F) -> u32
where
S: Clone,
F: Sized + FnMut(Fn() -> S) -> (),
{
let mut counter: u32 = 0;
f(|| {
counter += 1;
s.clone()
});
counter
}
#[cfg(test)]
mod stackoverflow {
use super::*;
fn f(p: fn() -> i32) {
p();
p();
}
#[test]
fn test() {
let counts = count_calls(3, f);
assert_eq!(counts, 2);
}
}
在这里我得到错误：
error[E0277]: the size for values of type `(dyn std::ops::Fn() -> S + 'static)` cannot be known at compilation time
--> src/lib.rs:1:1
|
1 | / fn count_calls<S, F>(s: S, f: F) -> u32
2 | | where
3 | | S: Clone,
4 | | F: Sized + FnMut(Fn() -> S) -> (),
... |
12 | | counter
13 | | }
| |_^ doesn't have a size known at compile-time
|
= help: within `((dyn std::ops::Fn() -> S + 'static),)`, the trait `std::marker::Sized` is not implemented for `(dyn std::ops::Fn() -> S + 'static)`
= note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
= note: required because it appears within the type `((dyn std::ops::Fn() -> S + 'static),)`
= note: required by `std::ops::FnMut`
有人知道如何解决此问题吗？
感谢进阶！
[编辑]
我认为使用Box<Fn()->S>可能是一种解决方案。但是，如果可能的话，我更喜欢仅使用堆栈的解决方案。
答案 0 :(得分：4)
错误“ 在编译时无法知道类型(dyn std::ops::Fn() -> S + 'static)的值的大小”是由于绑定到F的特征导致的：
F: Sized + FnMut(Fn() -> S) -> ()
这等效于F: Sized + FnMut(dyn Fn() -> S)。这意味着闭包F将按值接受特征对象（dyn Fn() -> S）。但是特征对象没有大小，并且不能按值传递（尚未）。
一种解决方案是通过引用或在Box中传递trait对象。 The answer by rodrigo解释并讨论了这些解决方案。
我认为不正确。
一个想法是向count_calls添加另一个类型参数：
fn count_calls<S, F, G>(s: S, f: F) -> u32
where
S: Clone,
F: Sized + FnMut(G),
G: Fn() -> S,
但是，这不起作用：
error[E0308]: mismatched types
--> src/lib.rs:9:7
|
9 | f(|| {
| _______^
10 | | counter += 1;
11 | | s.clone()
12 | | });
| |_____^ expected type parameter, found closure
|
= note: expected type `G`
found type `[closure@src/lib.rs:9:7: 12:6 counter:_, s:_]`
这里的问题是count_calls的调用者选择了count_calls的类型实参。但是我们实际上希望G始终是我们自己的闭包类型。所以那行不通。
我们想要的是一个通用闭包（在其中我们可以选择它的类型参数）。类似的事情是可能的，但仅限于生命周期参数。它称为HRTB，看起来像F: for<'a> Fn(&'a u32)。但这无济于事，因为我们需要一个类型参数并且for<T>不存在（还吗？）。
一种解决方案是不使用闭包，而使用实现FnMut的已知名称的类型。可悲的是，您还不能在稳定状态下为自己的类型实现Fn*特征。 On nightly, this works。
struct CallCounter<S> {
counter: u32,
s: S,
}
impl<S: Clone> FnOnce<()> for CallCounter<S> {
type Output = S;
extern "rust-call" fn call_once(self, _: ()) -> Self::Output {
// No point in incrementing the counter here
self.s
}
}
impl<S: Clone> FnMut<()> for CallCounter<S> {
extern "rust-call" fn call_mut(&mut self, _: ()) -> Self::Output {
self.counter += 1;
self.s.clone()
}
}
fn count_calls<S, F>(s: S, mut f: F) -> u32
where
S: Clone,
F: Sized + FnMut(&mut CallCounter<S>), // <----
{
let mut counter = CallCounter {
counter: 0,
s,
};
f(&mut counter); // <-------
counter.counter
}
不幸的是，现在您的公共接口中有这种奇怪的类型（应该是实现的细节）。
除此之外，我无法想到任何实际的解决方案（只有其他具有很多缺点的超级详细解决方案）。类型系统角的发展（特别是在GAT和HKT方面）可以在将来适当解决。但是，我认为仍然缺少一些不同的功能。特别是，我认为建议的GAT并不能解决这个问题。
因此，如果这是一个现实生活中的问题，需要立即解决，那么我会：
答案 1 :(得分：2)
这是我设法开始工作的最简单的代码（playground）：
fn count_calls<S, F>(s: S, mut f: F) -> u32
where
S: Clone,
F: FnMut(&mut dyn FnMut() -> S) -> (),
{
let mut counter: u32 = 0;
f(&mut || {
counter += 1;
s.clone()
});
counter
}
#[cfg(test)]
mod stackoverflow {
use super::*;
fn f(p: &mut dyn FnMut() -> i32) {
p();
p();
}
#[test]
fn test() {
let counts = count_calls(3, f);
assert_eq!(counts, 2);
}
}
关键的变化是将F的功能参数从Fn() -> S更改为&mut dyn FnMut() -> S。您需要参考，因为您正在使用动态调度。另外，您还需要FnMut，因为您正在捕获counter并在内部进行更改，而Fn则不允许。
请注意，您不能使用Box<FnMut() -> S。不允许捕获对counter的引用，因为带框的函数必须为'static。
如果您发现将Fn更改为FnMut是不受欢迎的（因为您正在更改公共API），则可以通过将counter定义为{{1}来返回到F: FnMut(&mut dyn Fn() -> S) -> () }：
Cell<u32>