如何在 Rust 中进行高阶组合？

Question

我有这个有效的功能：

fn compose<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(B) -> C) -> impl Fn(A) -> C {
    move |x: A| g(f(x))
}

我想在这种情况下使用柯里化，这样我就可以做到：

/* THIS */
compose(f)(g)(x)

/* Instead of this */
compose(f, g)(x)

考虑制作一个这样的宏是否合理？

compose(f)(g)(h)···(x)

我设法得到了一些与我想要的有点相似的东西：

fn compose<A, B, C, F: 'static, G: 'static>(f: F) -> impl Fn(G) -> Box<dyn Fn(A) -> C>
where
    F: Fn(A) -> B + Copy,
    G: Fn(B) -> C + Copy,
{
    move |g: G| Box::new(move |x: A| g(f(x)))
}

let inc = |x| x + 1;
let mult2 = |x| x * 2;

let inc_compose = compose(inc);

println!("{}", inc_compose(mult2)(3)); // 8

现在有一个新问题：在基于我的compose函数创建高阶函数时，我需要给函数一个依赖于另一个函数的类型：

let inc   = |x: usize| x + 1;
let mult2 = |x: usize| x * 2;
let mult3 = |x: usize| x * 3;

let inc_compose = compose(inc);

println!("{}", inc_compose(mult2)(3)); // 8

println!("{}", inc_compose(mult3)(3)); // ERROR: [rustc E0308] [E] mismatched types

有没有办法避免这个错误？

这些类似的帖子都没有回答我的问题：

• How do I emulate Lisp (apply) or (curry) in Rust?
• How to implement a multiple level currying function in Rust?
• How to invoke a multi-argument function without creating a closure?

主要是想通过currying获得做无点编程的能力。

Answer 1

在 Rust 中，柯里化很难。严格的类型系统、生命周期和不存在的嵌套 impl 特征都会在您尝试时破坏您的一天。但是，可以创建一个宏来 curry 函数，我曾经为代码高尔夫这样做过。未打高尔夫球的版本在这里：

macro_rules! curry{
    (
        $f:ident
        $(
            ($args:ident : $types:ty)
        )*
    ) => {
        $(move |$args: $types|)*
        $f(
            $($args),*
        )
    }
}

这匹配name(arg1, type1)(arg2, type2)...(argN, typeN) 形式的表达式并返回导致函数调用的move 闭包链。然而，大多数时候，您可以只使用_ 作为类型，然后让推理来解决。与compose 一起使用很简单：

let inc = |x| x as u32 + 1;
let double = |x| x * 2;
let curried = curry!(compose(f: _)(g: _));
assert_eq!(curried(inc)(double)(7), 16);

在本例中，宏生成的代码如下所示：

move |f: _| move |g: _| compose(f, g)

它简单地将提供的名称和类型粘贴到闭包头中，因此您可以使用它将泛型函数的参数强制转换为具体类型。 Playground