如何在Rust中实现类似Solidity modifier修饰器的功能

Rust 没有内置类似 Solidity 的 modifier 语法糖，但有三种常用的实现方案可以完美实现环绕执行、复用逻辑的需求，还能覆盖异常场景的逻辑执行，比手写前后置代码更安全：

方案1：RAII 守卫（最推荐，符合 Rust 原生设计） #

Rust 的 Drop trait 可以实现变量离开作用域时自动执行指定代码，刚好匹配 modifier 的前置+后置逻辑，零运行时开销，还能自动处理函数提前返回、panic 等异常场景：

// 假设你的共享状态结构如下
struct Slot {
    unlocked: bool,
    // 其他业务字段
}

// 定义守卫结构体，持有状态的可变引用
struct LockGuard<'a> {
    slot: &'a mut Slot,
}

impl<'a> LockGuard<'a> {
    // 构造函数里写 modifier 前置逻辑
    fn new(slot: &'a mut Slot) -> Self {
        assert!(slot.unlocked, "LOK");
        slot.unlocked = false;
        LockGuard { slot }
    }
}

// Drop 实现里写 modifier 后置逻辑，自动执行
impl<'a> Drop for LockGuard<'a> {
    fn drop(&mut self) {
        self.slot.unlocked = true;
    }
}

使用方式非常简单，只需要在函数第一行创建守卫即可：

fn my_function(slot0: &mut Slot) -> u8 {
    // 一行引入 modifier，自动执行前置逻辑
    // 注意不要写成 `let _ = LockGuard::new(...)`，否则守卫会被立即释放，逻辑不生效
    let _guard = LockGuard::new(slot0);

    // 你的业务逻辑写在这里，不需要手动处理后置
    // ...
}

方案2：高阶函数封装 #

如果你需要更灵活的逻辑组合，可以把 modifier 封装为接收闭包作为参数的高阶函数：

fn with_lock<R>(slot0: &mut Slot, logic: impl FnOnce() -> R) -> R {
    // 前置逻辑
    assert!(slot0.unlocked, "LOK");
    slot0.unlocked = false;

    // 执行原函数业务逻辑
    let result = logic();

    // 后置逻辑
    slot0.unlocked = true;

    result
}

使用时把业务逻辑包在闭包里传入即可：

fn my_function(slot0: &mut Slot) -> u8 {
    with_lock(slot0, || {
        // 你的业务逻辑写在这里
        // ...
    })
}

如果需要嵌套多个 modifier，直接多层嵌套高阶函数调用即可。

方案3：过程宏（最接近 Solidity 写法） #

如果想要和 Solidity 一样直接在函数上加标记的使用方式，可以自定义过程宏，在编译期自动把前后置逻辑插入到目标函数中。实现后使用效果如下：

// 自定义的 lock 过程宏
#[lock(slot0)]
fn my_function(slot0: &mut Slot) -> u8 {
    // 你的业务逻辑写在这里
    // ...
}

这种方案的缺点是需要额外实现过程宏，开发成本比前两种高，适合有大量函数需要复用同个 modifier 的场景。

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