我有一个简单的分类器：
struct Clf {
x: f64,
}
x返回0，大于x返回1。我想为这个分类器实现调用运算符，但函数应能够接受浮点数或向量作为参数。对于向量，输出是一个大小与输入向量相同的0或1向量。let c = Clf { x: 0 };
let v = vec![-1, 0.5, 1];
println!("{}", c(0.5)); // prints 1
println!("{}", c(v)); // prints [0, 1, 1]
在这种情况下，我应该如何编写Fn的实现？
impl Fn for Clf {
extern "rust-call" fn call(/*...*/) {
// ...
}
}
FnOnce，因为Fn需要FnMut，而FnMut需要FnOnce。所以，如果我们把这一切都搞定了，我们就可以为其他函数特性做到这一点。#![feature(unboxed_closures, fn_traits)]
那么，让我们为获取 f64 值编写 impl：
impl FnOnce<(f64,)> for Clf {
type Output = i32;
extern "rust-call" fn call_once(self, args: (f64,)) -> i32 {
if args.0 > self.x {
1
} else {
0
}
}
}
Fn特质系列的参数是通过元组提供的，因此这就是(f64,)语法;它是一个只有一个元素的元组。
这很好，我们现在可以执行c(0.5)，虽然它会消耗c，直到我们实现其他特质为止。
现在让我们对Vec做同样的事情：
impl FnOnce<(Vec<f64>,)> for Clf {
type Output = Vec<i32>;
extern "rust-call" fn call_once(self, args: (Vec<f64>,)) -> Vec<i32> {
args.0
.iter()
.map(|&f| if f > self.x { 1 } else { 0 })
.collect()
}
}
在 Rust 1.33 nightly之前，您无法直接调用c(v)或者c(0.5)（这在之前是可行的），因为我们会遇到函数类型未知的错误。基本上，这些版本的Rust不支持函数重载。但是我们仍然可以使用完全限定语法调用这些函数，其中c(0.5)变成了FnOnce::call_once(c, (0.5,))。
不了解你的整体情况，我想通过以下方式简单地为Clf提供两个函数来解决这个问题：
impl Clf {
fn classify(&self, val: f64) -> u32 {
if val > self.x {
1
} else {
0
}
}
fn classify_vec(&self, vals: Vec<f64>) -> Vec<u32> {
vals.into_iter().map(|v| self.classify(v)).collect()
}
}
let c = Clf { x: 0 };
let v = vec![-1, 0.5, 1];
println!("{}", c.classify(0.5)); // prints 1
println!("{}", c.classify_vec(v)); // prints [0, 1, 1]
classify_slice变得更加通用，接受&[f64]参数，这样您就可以通过引用来使用它与Vec一起使用：c.classify_slice(&v)。请保留HTML标签。enum VecOrScalar<T> {
Scalar(T),
Vector(Vec<T>),
}
use VecOrScalar::*;
T (hidden) -> VecOrScalar<T> -> T (known)
Vec<T> (hidden) -> VecOrScalar<T> -> Vec<T> (known)
T，用VecOrScalar包装起来，并使用match提取真实的类型T。T (known) -> bool = T::Output
Vec<T> (known) -> Vec<bool> = Vec<T>::Output
但是如果没有高阶类型，这有点棘手。相反，您可以这样做：
T (known) -> VecOrScalar<T> -> T::Output
Vec<T> (known) -> VecOrScalar<T> -> Vec<T>::Output
trait FromVecOrScalar<T> {
type Output;
fn put(self) -> VecOrScalar<T>;
fn get(out: VecOrScalar<bool>) -> Self::Output;
}
使用实现
impl<T> FromVecOrScalar<T> for T {
type Output = bool;
fn put(self) -> VecOrScalar<T> {
Scalar(self)
}
fn get(out: VecOrScalar<bool>) -> Self::Output {
match out {
Scalar(val) => val,
Vector(_) => panic!("Wrong output type!"),
}
}
}
impl<T> FromVecOrScalar<T> for Vec<T> {
type Output = Vec<bool>;
fn put(self) -> VecOrScalar<T> {
Vector(self)
}
fn get(out: VecOrScalar<bool>) -> Self::Output {
match out {
Vector(val) => val,
Scalar(_) => panic!("Wrong output type!"),
}
}
}
你的类型
#[derive(Copy, Clone)]
struct Clf {
x: f64,
}
首先实现这两个分支：
impl Clf {
fn calc_scalar(self, f: f64) -> bool {
f > self.x
}
fn calc_vector(self, v: Vec<f64>) -> Vec<bool> {
v.into_iter().map(|x| self.calc_scalar(x)).collect()
}
}
然后它将通过为 T: FromVecOrScalar<f64> 实现 FnOnce 来进行调度。
impl<T> FnOnce<(T,)> for Clf
where
T: FromVecOrScalar<f64>,
{
使用类型
type Output = T::Output;
extern "rust-call" fn call_once(self, (arg,): (T,)) -> T::Output {
首先，调度程序将私有类型封装起来，因此您可以使用enum提取它，然后使用T::get获取结果，以再次隐藏它。
match arg.put() {
Scalar(scalar) => T::get(Scalar(self.calc_scalar(scalar))),
Vector(vector) => T::get(Vector(self.calc_vector(vector))),
}
}
}
fn main() {
let c = Clf { x: 0.0 };
let v = vec![-1.0, 0.5, 1.0];
println!("{}", c(0.5f64));
println!("{:?}", c(v));
}
由于编译器可以看穿这些废话，它实际上编译成与直接调用calc_方法基本相同的汇编代码。
这并不意味着写起来很好。像这样的重载是痛苦的、易碎的，并且绝对是一个坏主意™。不要这样做，但知道你可以这样做也没问题。
Fn*系列特质是不稳定的，随时可能发生变化，因此依赖于它是一个坏主意。Fn*实现的值。因为通常情况下它无法确定你想要做什么。唯一的解决方法是完全指定要调用的特质，但这时你已经失去了任何可能的人机工效性优势。Fn*特质，不如定义和实现自己的特质。我在问题上做了一些改动以避免/修复可疑的方面。struct Clf {
x: f64,
}
trait ClfExt<T: ?Sized> {
type Result;
fn classify(&self, arg: &T) -> Self::Result;
}
impl ClfExt<f64> for Clf {
type Result = bool;
fn classify(&self, arg: &f64) -> Self::Result {
*arg > self.x
}
}
impl ClfExt<[f64]> for Clf {
type Result = Vec<bool>;
fn classify(&self, arg: &[f64]) -> Self::Result {
arg.iter().map(|v| self.classify(v)).collect()
}
}
fn main() {
let c = Clf { x: 0.0 };
let v = vec![-1.0, 0.5, 1.0];
println!("{}", c.classify(&0.5f64));
println!("{:?}", c.classify(&v[..]));
}
Fn*特质我包含了这个内容是为了完整性；实际上不要这样做。 不仅不被支持，而且非常丑陋。
#![feature(fn_traits, unboxed_closures)]
#[derive(Copy, Clone)]
struct Clf {
x: f64,
}
impl FnOnce<(f64,)> for Clf {
type Output = bool;
extern "rust-call" fn call_once(self, args: (f64,)) -> Self::Output {
args.0 > self.x
}
}
impl<'a> FnOnce<(&'a [f64],)> for Clf {
type Output = Vec<bool>;
extern "rust-call" fn call_once(self, args: (&'a [f64],)) -> Self::Output {
args.0
.iter()
.cloned()
.map(|v| FnOnce::call_once(self, (v,)))
.collect()
}
}
fn main() {
let c = Clf { x: 0.0 };
let v = vec![-1.0, 0.5, 1.0];
// Before 1.33 nightly
println!("{}", FnOnce::call_once(c, (0.5f64,)));
println!("{:?}", FnOnce::call_once(c, (&v[..],)));
// After
println!("{}", c(0.5f64));
println!("{:?}", c(&v[..]));
}
您可以使用夜间版和不稳定的功能：
#![feature(fn_traits, unboxed_closures)]
struct Clf {
x: f64,
}
impl FnOnce<(f64,)> for Clf {
type Output = i32;
extern "rust-call" fn call_once(self, args: (f64,)) -> i32 {
if args.0 > self.x {
1
} else {
0
}
}
}
impl FnOnce<(Vec<f64>,)> for Clf {
type Output = Vec<i32>;
extern "rust-call" fn call_once(self, args: (Vec<f64>,)) -> Vec<i32> {
args.0
.iter()
.map(|&f| if f > self.x { 1 } else { 0 })
.collect()
}
}
fn main() {
let c = Clf { x: 0.0 };
let v = vec![-1.0, 0.5, 1.0];
println!("{:?}", c(0.5));
let c = Clf { x: 0.0 };
println!("{:?}", c(v));
}