rust - 是否可以在运行时组成一个函数链？

Question

我有 3 个功能:

fn f1() -> u64 {
    println!("Hello world: 1");
    2
}

fn f2(i: u64) -> Box<FnMut()> {
    println!("Hello world: {}", i);
    Box::new(|| println!("Hello world: {}", 3))
}

fn f3(mut f: Box<FnMut()>) {
    f()
}

一种函数式技术是链接——将函数 A 的输出连接到函数 B 的输入:

fn main() {
    f3(f2(f1()));
}

这在 Rust 中可能有所帮助，因为这种方法是纯函数式的，函数可以是纯函数；它们不涉及全局变量，只处理被移动(这很棒)的参数。

如何在运行时执行此链？如果我有函数 f4，它接受 f2 的输入但不将其用作 f3。我们还可以通过向其添加返回类型来将其用于进一步链接:

fn f4(_: Box<FnMut()>) -> bool {
    println!("Hello world: 4");
    true
}

fn main() {
    f4(f2(f1())) // returns f4's result (true)
}

我希望能够决定如何在运行时链接我的函数。这个例子就是这个 Lua 代码(对此感到抱歉):

function f1()
    print("Hello world: 1")
    return 2
end

function f2(args)
    print("Hello world: " .. args)
    return function()
        print("Hello world: " .. args + 1)
    end
end

function f3(args)
    args()
end

function f4()
    print("Hello world: 4")
end


function run_chain(list)
    local args
    for _, v in ipairs(list) do
        args = v(args)
    end
end

local list = {}
list[#list + 1] = f1
list[#list + 1] = f2
list[#list + 1] = f3
run_chain(list)
list[#list] = f4
run_chain(list)

这是脚本语言动态类型的一大优势，但据我所知，Rust 声称它比 C++ 等功能更强大。是否有可能以这种方式链接功能？

Answer 1

这是解决简单链接问题的方法。将其从自由函数转换为构建器或运算符样式留作练习。它还使用 Rust 1.26 中引入的“impl Trait”功能使其变得更好。

fn f1(_: ()) -> u64 {
    println!("Hello world: 1");
    2
}
fn f2(i: u64) -> Box<FnMut()> {
    println!("Hello world: {}", i);
    Box::new(|| println!("Hello world: {}", 3))
}
fn f3(mut f: Box<FnMut()>) {
    f()
}
fn f4(_: Box<FnMut()>) -> bool {
    println!("Hello world: 4");
    true
}

fn dot<I, X, O, F1, F2>(mut f1: F1, mut f2: F2) -> impl FnMut(I) -> O
where
    F1: FnMut(I) -> X,
    F2: FnMut(X) -> O,
{
    move |i| f2(f1(i))
}

fn main() {
    let mut c = dot(dot(f1, f2), f3);
    c(());
    let mut c2 = dot(dot(f1, f2), f4);
    c2(());
}

Playground

将两个函数粘合在一起并不难，但如果您的类型更复杂，您可能会遇到生命周期问题。特别是，如果链中某个函数的输入参数是对前一个函数返回的类型的引用，则此代码将无法编译。我相信更多的参数和通用边界可以解决这个问题，但您必须进行一些试验。

另见 tool crate (compose 几乎就是我刚刚发布的内容)和 rustz crate ，这两者都为 Rust 添加了更多功能性习语。