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

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,但内部操作是通用的.

我最初在Reddit上问过这个问题

Answer 1

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

• 指针：fn(A, B) -> C,
• 性状：Fn(A, B) -> C, FnMut(A, B) -> C, FnOnce(A, B) -> C.

无论哪种情况，它们都由参数和结果类型来表征。

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

这取决于。

从你的例子中，我们可以看到它是FnOnce(T, T) -> T针对Tin 的[i64, i32, ...]。

这不是一种类型，这是多种类型。因此它需要的不是单一的功能而是多种功能；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);
}

印刷I32(3)。