如何在不使该函数泛型的情况下将带有泛型的闭包传递给函数？

Question

我有一个与枚举一起使用二进制函数的函数。这是给口译员的：

use std::ops::*;

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub enum Scalar {
    I64(i64),
    I32(i32),
    //many many others
}

pub trait TMath: Add + Mul + Sized {} //mark numerical types
impl<T: Add + Mul> TMath for T {}

fn add<T: TMath>(x: T, y: T) -> <T as Add>::Output {
    x + y
}

pub type NatBinExpr<T: TMath> = Fn(&T, &T) -> T;

我想做：

let result = bin_op(add, &Scalar::I32(1), &Scalar::I32(2));

还要让它适用于任意二进制函数：

let result = bin_op(Scalar::concat, &Scalar::I32(1), &Scalar::I32(2));

但是，我还没有找到一种方法来通过闭包而不使bin_op 泛型：

fn bin_op(apply: &NatBinExpr???, x: &Scalar, y: &Scalar) -> Scalar {
    match (x, y) {
        (Scalar::I64(a), Scalar::I64(b)) => Scalar::I64(apply(a, b)),
        (Scalar::I32(a), Scalar::I32(b)) => Scalar::I32(apply(a, b)),
    }
}

使bin_op 泛型是不对的； bin_op 对Scalar 进行操作，但内部操作是通用的。

我原来asked this question on Reddit

Answer 1

基本上有两种不同的方式来谈论函数类型：

• 指针：fn(A, B) -> C,
• 特征：Fn(A, B) -> C、FnMut(A, B) -> C、FnOnce(A, B) -> C。

在任何一种情况下，它们都以参数和结果类型为特征。

那么，apply 的参数和结果类型是什么？

视情况而定。

从您的示例中，我们可以看到[i64, i32, ...] 中的T 是FnOnce(T, T) -> T。

这不是 one 类型，这是 许多 类型。因此，它需要的不是单一功能，而是多种功能；或者可能是一个函数对象多次实现FnOnce。

---

函数对象路由仅在夜间可用，并且需要大量样板文件（宏会有所帮助）：

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

use std::ops::*;

#[derive(Debug, Clone, PartialEq, PartialOrd)]
pub enum Scalar {
    I64(i64),
    I32(i32),
    //many many others
}

pub trait TMath: Add + Mul + Sized {} //mark numerical types

impl<T: Add + Mul> TMath for T {}

struct Adder;

impl FnOnce<(i64, i64)> for Adder {
    type Output = i64;
    extern "rust-call" fn call_once(self, args: (i64, i64)) -> i64 {
        args.0 + args.1
    }
}

impl FnMut<(i64, i64)> for Adder {
    extern "rust-call" fn call_mut(&mut self, args: (i64, i64)) -> i64 {
        args.0 + args.1
    }
}

impl Fn<(i64, i64)> for Adder {
    extern "rust-call" fn call(&self, args: (i64, i64)) -> i64 {
        args.0 + args.1
    }
}

impl FnOnce<(i32, i32)> for Adder {
    type Output = i32;
    extern "rust-call" fn call_once(self, args: (i32, i32)) -> i32 {
        args.0 + args.1
    }
}

impl FnMut<(i32, i32)> for Adder {
    extern "rust-call" fn call_mut(&mut self, args: (i32, i32)) -> i32 {
        args.0 + args.1
    }
}

impl Fn<(i32, i32)> for Adder {
    extern "rust-call" fn call(&self, args: (i32, i32)) -> i32  {
        args.0 + args.1
    }
}

fn bin_op<F>(apply: &F, x: Scalar, y: Scalar) -> Scalar
    where
        F: Fn(i64, i64) -> i64,
        F: Fn(i32, i32) -> i32,
{
    match (x, y) {
        (Scalar::I64(a), Scalar::I64(b))
            => Scalar::I64((apply as &Fn(i64, i64) -> i64)(a, b)),
        (Scalar::I32(a), Scalar::I32(b))
            => Scalar::I32((apply as &Fn(i32, i32) -> i32)(a, b)),
        _ => unreachable!(),
    }
}

fn main() {
    let result = bin_op(&Adder, Scalar::I32(1), Scalar::I32(2));
    println!("{:?}", result);
}

Prints I32(3).