为了尝试重载调用语法,我引入了一个简单的缓存,可以缓存昂贵的计算结果。我对使用部分语法感到困惑。在问题之前,我将逐步介绍代码。
高速缓存旨在像这样使用:
fn fib(x: i32) -> i32 {
if x < 2 { x } else { fib(x-1) + fib(x-2) }
}
fn main() {
let mut cfib = Cache::new(fib);
// Loop that repeats computation and extracts it from the cache
// the second time.
for x in 1..200 {
let val = 5 * x % 40;
println!("fibc({}) = {}", val, cfib(val));
}
}
我们首先有一个序言,以启用尚未稳定的功能:
#![feature(fn_traits, unboxed_closures)]
use std::collections::HashMap;
use std::hash::Hash;
我们将缓存作为一种带有
HashMap
的结构和一个用于计算新值的函数来介绍。struct Cache<T, R> {
cache: HashMap<T, R>,
func: fn(T) -> R,
}
impl<T, R> Cache<T, R>
where T: Eq + Hash + Copy,
R: Copy
{
fn new(func: fn(T) -> R) -> Cache<T, R> {
Cache { cache: HashMap::new(), func: func }
}
fn compute(&mut self, x: T) -> R {
let func = self.func;
let do_insert = || (func)(x);
*self.cache.entry(x).or_insert_with(do_insert)
}
}
由于缓存需要可变,因此我创建了
FnMut
特性的实现。impl<T, R> FnMut<(T,)> for Cache<T, R>
where T: Eq + Hash + Copy,
R: Copy
{
extern "rust-call" fn call_mut(&mut self, args: (T,))
-> Self::Output
{
let (arg,) = args;
self.compute(arg)
}
}
即使我发现
FnMut<(T,)>
语法很奇怪,这也很好并且安全,传达的意图也很清楚。由于我需要定义函数的返回类型,因此我想将开头写成:impl<T, R> FnMut<(T,), Output=R> for Cache<T, R>
where T: Eq + Hash + Copy,
R: Copy
{}
但这失败并显示错误:
error[E0229]: associated type bindings are not allowed here
--> src/main.rs:55:24
|
55 | impl<T, R> FnMut<(T,), Output=R> for Cache<T, R>
| ^^^^^^^^ associate type not allowed here
我必须像这样实现
FnOnce
:impl<T, R> FnOnce<(T,)> for Cache<T,R>
where T: Eq + Hash + Copy,
R: Copy
{
type Output = R;
extern "rust-call" fn call_once(self, _arg: (T,))
-> Self::Output
{
unimplemented!()
}
}
这是毫无意义的,因为永远不会调用
call_once
,并且从Associated Types看来这应该是可能的。但是,它失败并显示错误消息,表明那里不允许使用关联的类型。Rust Compiler Error Index提到语法
Fn(T) -> R
,还说Fn<(T,), Output=U>
应该可以工作,但是即使我使用每晚的Rust编译器,我也无法使其工作。由于希望在编译时捕获尽可能多的错误,因此最好避免在
FnOnce
中创建“未实现”的函数,因为这将在运行时而不是编译时失败。是否可以仅实现
FnMut
并以某种方式提供函数的返回类型? 最佳答案
这不是您决定的;这取决于来电者。他们可能决定在FnOnce
上下文中调用缓存。
好消息是FnOnce
有一个非常合理的实现-只需委托(delegate)给FnMut
实现即可:
impl<T, R> FnOnce<(T,)> for Cache<T,R>
where T: Eq + Hash + Copy,
R: Copy
{
type Output = R;
extern "rust-call" fn call_once(mut self, arg: (T,))
-> Self::Output
{
self.call_mut(arg)
}
}
这就是编译器对这些特征的自动实现。如果合适,它还会将
FnMut
委派给Fn
。也可以看看