如何在 Rust 中动态构建具有不同数量参数的函数调用？

Question

如何获取函数参数 AST 变体的向量、提取值并使用它们来实例化函数调用？

我正在编写一个解释器来评估某些表达式。一些表达式是函数调用。我很难弄清楚如何将函数调用 AST 转换为实际调用。 AST 给了我函数名和参数向量。我可以使用映射从名称中查找要调用的函数指针，但是将参数传递给函数指针是有问题的。

Rust 没有 splat 运算符（参数扩展）。我可以将它们作为元组传递并使用参数的解构，但我不知道如何将 AST 参数枚举变量的向量转换为具体类型的元组。

我不能简单地映射或循环 AST 参数来提取值并生成一个元组。

我可以使用嵌套元组逐步构建异构列表：

fn prepend<I,T>(i: I, t: T) -> (I,T) { (i, t) }

fn foo() {
    let x = ();
    let x = prepend(1, x);
    let x = prepend(2.0, x);
    let x = prepend(true, x);
}

但这只是因为x 被遮蔽并且新绑定具有不同的类型。这行不通：

fn foo() {
    let mut x = ();
    x = prepend(1, x);
    x = prepend(2.0, x);
    x = prepend(true, x);
}

有什么想法吗？

Answer 1

你没有。 Rust 是一种 静态类型 语言，您正在尝试执行非静态可确定的操作。

相反，您的所有函数都需要接收一组参数，验证参数数量是否正确（和类型，如果适合您的解释器），然后使用固定数量的参数调用适当的 Rust 函数：

// All of the panicking can be replaced by proper error handling.

enum Arg {
    Bool(bool),
    Int(i32),
}

impl Arg {
    fn into_bool(self) -> bool {
        match self {
            Arg::Bool(b) => b,
            _ => panic!("Not a bool"),
        }
    }

    fn into_int(self) -> i32 {
        match self {
            Arg::Int(i) => i,
            _ => panic!("Not an int"),
        }
    }
}

fn some_fn_wrapper(mut args: Vec<Arg>) {
    assert_eq!(args.len(), 3);

    let c = args.pop().unwrap();
    let b = args.pop().unwrap();
    let a = args.pop().unwrap();

    some_fn(a.into_bool(), b.into_int(), c.into_bool())
}

fn some_fn(_a: bool, _b: i32, _c: bool) {}

所有这些都将在运行时发生，因为您想创建一种高度动态的语言。

另见：

• How do I pass each element of a slice as a separate argument to a variadic C function?
• How to pass a dynamic amount of typed arguments to a function?
• Calling a function only known at runtime
• How can I create a function with a variable number of arguments?
• Is Reflection possible in Rust, and if so how can I invoke an unknown function with some arguments?