Rust 函数式吃瘪

[vst-h]

• 使用 Rust 一大障碍就是要探索函数式运用的边界，有种浪费生命的感觉，折磨
• 以致我不爱用 Rust 来写项目
• 放眼望去，有些项目用 Rust 收益还是有的
  • C# 类型系统老旧（2025）
    • Nullable，大问题，很多抽象的东西没法做
    • 没有 Union Tagged 类型
    • 性能差 Rust 一档（别说只相差 1.x 倍多，远不止）
  • F# 将将跟得上 C# 的特性
    • 使用体验部分地方优于 C#
    • 写一些需要性能的命令式循环，累死人
    • 没有提前 return （虽然函数式不喜欢，但是我真喜欢提前 return，没提前 return 的代码不如 C# 好阅读）
  • JS/TS，性能选择，场景有限，写起来不错
  • Zig，没到 1.0，简单看过一些特性还是比较香，看过一些代码感觉难以 Hold 住
  • Moonbit（2025），看好，特性都有，生态从零发展，目前对我没有应用场景。

---

1. 本地函数不能捕获上下文变量
2. 闭包生命周期不知道什么时候要你死

[vst-h]

本地函数不能捕获上下文变量

• 我很喜欢 C# 的本地函数
• 代码自解释，函数做事清晰，还有节点目录（vscode 有）
• 示例：

void Test(int x) {
  if ( isXx(x) ) {
    doFn1();
    return; 
  }
 var y = doFn2();
 if ( isYy(y) ) {
    doFn3();
    return;
 }
  ... 等等
  return;
  bool isXx() => ...
  bool isYy() => ...
  void doFn1() { ... }
  void doFn2() { ... }
  void doFn3() { 
    // 这里能捕获到 y 变量的，超出范围使用会报错
  }
}

• 本地函数能获取到当前函数的变量，还有临时中间状态
• 把要做的什么事一眼扫出来，大致流程也明白
• 为什么不抽成类成员方法？
  • 不符合我的习惯，有必要才会提升到成员方法
  • 可见性会提升一档，没必要，会导致 this 上下文的东西过多
  • 其他地方或同事调用了，函数引用到别处带来管理依赖，如果还修改内部状态，更麻烦

---

• Rust 是有类似的本地变量，也可以写在 return 的后面（这点对阅读很重要）
• 它不能使用 self，类一个静态方法了
• 不能捕获局部变量
• 基于这两点我就很难使用本地函数了，几乎做啥做不了
• 前进一步是使用闭包捕获
• 后退一步是变成 impl 内部成员

[vst-h]

Rust 修改局部函数为闭包，必须放在 return 之前

• 定义成变量，有顺序影响，不能随便捕获上下文
• 捕获中间状态，以致干活的函数和中间状态会混乱在一起
• 因为定义在开始，不知道当前函数do_aaa应该从哪里开始阅读，从哪里开始干活做事

fn do_aaa() {
  let f1 = |x| fn2() + x; //  报错
  let f2 = || 2;
  let f3 = || {
    ..
    ..
    ..
  };
  // f4 需要一个中间状态，产生一个中间状态
  let x = f3();
  let f4 = || {
    ..
    f1(x) // 捕获了上下文中间状态
    ..
  }
}

[vst-h]

闭包捕获了 &mut self，后继的 self 都不能用了

• palyground

struct S1(u8);
impl S1 {
    fn fn1(&mut self, x: u8) {
        let mut add1 = || self.0 = x + 1;
        if self.0 < 10 {  // 报错 cannot use `self.0` because it was mutably borrowed
            add1();
        }
    }
}

• 修改闭包为 FnOnce

struct S1(u8);
impl S1 {
    fn fn1(&mut self, x: u8) {
        let mut add1: Box<dyn FnOnce()> = Box::new(|| self.0 = x + 1);
        if self.0 < 10 {
            add1();
        }
    }
}

• 一样的报错，放弃了

[vst-h]

Rust 不配写一点本地函数、本地闭包，又一次跌倒。不知道后面到底要不要改为 mut self，浪费时间。

[vst-h]

在群里吐槽。群友给出了解决方案，参数传递 self。let f1 = |self_: &mut Self| { ... }。因为我的 impl Trait 的 Self 有很多的约束，不可能还重写一遍泛型参数和类型约束。

[vst-h]

两个闭包类型不相同

    fn test_iter2(&self) -> impl Iterator<Item=usize> { 
        if true {
            std::iter::from_fn(|| todo!())
        } else {
            std::iter::from_fn(|| todo!())  // 报错:  `if` and `else` have incompatible types
        }
    }

`if` and `else` have incompatible types
no two closures, even if identical, have the same type
consider boxing your closure and/or using it as a trait object

就算换成本地函数也不行，这个应该使用 Box

---

带有生命周期的 Box：

fn test_iter2<'a>(&'a self) -> Box<dyn Iterator<Item=T<'a>> + 'a>