Rust中如何实现Scala式多参数列表函数模式？

Rust原生不支持Scala那种def add(n1: Int)(n2: Int)的多参数列表语法，但针对你提到的不可变结构体增量构建场景，有几种更简洁的替代方案，远比手动为每个字段写柯里化函数高效。

推荐方案：构建器模式（Builder Pattern） #

这是Rust中处理多字段增量构建的标准实践，扩展性极强——不管结构体有多少字段，只需要实现一套构建器逻辑，就能实现“先填充部分字段，后续补全剩余字段”的效果，完全匹配你的需求。

示例实现 #

#[derive(Debug)]
#[non_exhaustive]
pub struct Name<'a> {
    pub first: &'a str,
    pub last: &'a str,
}

#[derive(Default)]
pub struct NameBuilder<'a> {
    first: Option<&'a str>,
    last: Option<&'a str>,
}

impl<'a> NameBuilder<'a> {
    // 初始化空构建器
    pub fn new() -> Self {
        Self::default()
    }

    // 设置first字段，返回构建器自身（链式调用）
    pub fn first(mut self, first: &'a str) -> Self {
        self.first = Some(first);
        self
    }

    // 设置last字段，返回构建器自身
    pub fn last(mut self, last: &'a str) -> Self {
        self.last = Some(last);
        self
    }

    // 最终构建Name，做合法性校验
    pub fn build(self) -> Result<Name<'a>, &'static str> {
        let first = self.first.ok_or("first must not be empty")?;
        let last = self.last.ok_or("last must not be empty")?;
        
        if first.is_empty() || last.is_empty() {
            return Err("first and last must not be empty");
        }

        Ok(Name { first, last })
    }
}

使用方式 #

完全贴合你想要的“先填部分字段，后续补全”的流程：

// 先填充first，得到等待补全last的构建器
let takes_last = NameBuilder::new().first("John");
// 补全last并完成构建
let name = takes_last.last("Smith").build().unwrap();

println!("{:?}", name); // 输出 Name { first: "John", last: "Smith" }

如果结构体有5个字段，只需要在构建器里添加5个对应的setter方法即可，远比重写5个柯里化函数高效。

针对纯函数柯里化的方案 #

如果你只是想实现普通函数的多参数列表/柯里化（而非结构体构建），可以直接返回闭包，写法可以更简洁：

// 模拟Scala的add(n1)(n2)
fn add(n1: i32) -> impl Fn(i32) -> i32 {
    move |n2| n1 + n2
}

// 使用
let incrementer = add(1);
let three = incrementer(2);
let four = incrementer(3);

这种写法虽然比Scala的语法繁琐一点，但已经是Rust里最直接的柯里化实现方式。

为什么不推荐手动写多个柯里化函数？ #

你之前尝试的为每个字段写单独的柯里化函数的方式，会随着字段数量增加导致代码冗余度急剧上升，而且维护成本高——如果结构体字段修改，所有对应的柯里化函数都要同步调整。而构建器模式只需要维护一套逻辑，扩展性和可维护性都强得多。

内容的提问来源于stack exchange，提问作者Patrick