Lua 与 Rust、Go 的互操作实践：mlua 与 gopher-lua

-- 目标形态：Lua 脚本能调用宿主注册的函数，宿主也能调用 Lua 里的函数
-- （下面只是语义示意，具体 API 见后文）
local config = load_config()
apply_rules(config)

Rust/Go 宿主函数
    │  C ABI 边界（成本：栈编组 + 异常转换）
    ▼
lua_State 栈
    │
    ▼
Lua 虚拟机（解释器或 JIT）

use mlua::{Lua, Result, Variadic};

fn main() -> Result<()> {
    let lua = Lua::new();

    // 执行 Lua 表达式并取回结果
    let n: i64 = lua.load("1 + 2 * 3").eval()?;
    println!("result: {n}");     // 7

    // 注册全局变量，供 Lua 脚本读取
    let globals = lua.globals();
    globals.set("app_name", "plumephp")?;

    lua.load(r#"
        print("hello from " .. app_name)
    "#).exec()?;

    Ok(())
}

use mlua::{Lua, Result};

fn main() -> Result<()> {
    let lua = Lua::new();
    let globals = lua.globals();

    // 把 Rust 闭包注册为 Lua 函数
    globals.set("rust_add", lua.create_function(|_, (a, b): (i64, i64)| {
        Ok(a + b)
    })?)?;

    let result: i64 = lua.load("rust_add(20, 22)").eval()?;
    println!("{result}");         // 42
    Ok(())
}

use mlua::{Lua, Result};

fn main() -> Result<()> {
    let lua = Lua::new();
    lua.load(r#"
        function scale(x, factor)
            return x * factor
        end
    "#).exec()?;

    let globals = lua.globals();
    let scale: mlua::Function = globals.get("scale")?;
    let out: f64 = scale.call((10.0, 3.0))?;
    println!("{out}");            // 30
    Ok(())
}

package main

import (
    "fmt"
    lua "github.com/yuin/gopher-lua"
)

func main() {
    L := lua.NewState()
    defer L.Close()

    // 执行一段 Lua 代码
    if err := L.DoString(`print("hello gopher-lua")`); err != nil {
        panic(err)
    }

    // 注册 Go 函数给 Lua 用
    L.SetGlobal("go_add", L.NewFunction(func(L *lua.LState) int {
        a := L.ToInt(1)          // 取第一个参数
        b := L.ToInt(2)          // 取第二个参数
        L.Push(lua.LNumber(a + b))
        return 1                 // 返回 1 个结果
    }))

    if err := L.DoString(`print(go_add(20, 22))`); err != nil {
        panic(err)
    }
}

L := lua.NewState()
defer L.Close()
_ = L.DoString(`
    function greet(name)
        return "hello, " .. name
    end
`)

fn := L.GetGlobal("greet")
if fn.Type() == lua.LTFunction {
    L.Push(fn)
    L.Push(lua.LString("lua"))
    _ = L.PCall(1, 1, nil)       // 1 个参数，1 个返回值
    ret := L.Get(-1)
    fmt.Println(ret)             // "hello, lua"
    L.Pop(1)
}

// mlua：把 Rust 结构体编码成 Lua table
#[derive(mlua::FromLua)]
struct Player {
    id: u32,
    name: String,
}

// 用 serde 直接转 JSON 化数据
let player: Player = lua
    .load("return { id = 1001, name = 'plume' }")
    .eval()?;

// gopher-lua：table 转 Go 结构
L := lua.NewState()
_ = L.DoString(`return { id = 1001, name = "plume" }`)
tbl := L.Get(-1).(*lua.LTable)
id := tbl.RawGetString("id").(lua.LNumber)
name := tbl.RawGetString("name").(lua.LString)
L.Pop(1)

// Rust 闭包捕获宿主变量，Lua 侧透明
let base: i64 = 10;
globals.set("offset", lua.create_function(move |_, x: i64| {
    Ok(x + base)             // base 被 move 进闭包
})?)?;

-- Lua 侧：offset(5) 返回 15，它并不知道 base 存在
print(offset(5))

use mlua::{Lua, Result};

fn main() -> Result<()> {
    let lua = Lua::new();
    match lua.load("error('boom')").exec() {
        Ok(_) => println!("ok"),
        Err(e) => println!("捕获到 Lua 错误: {e}"),
    }
    // Lua 错误不会击穿 Rust 栈，程序继续运行
    Ok(())
}

use mlua::{Lua, Result};

fn main() -> Result<()> {
    let lua = Lua::new();
    let globals = lua.globals();

    // 宿主能力：查用户信息、发通知
    globals.set("lookup_user", lua.create_function(|_, uid: u32| {
        Ok(format!("user-{uid}"))           // 实际应查数据库
    })?)?;
    globals.set("notify", lua.create_function(|_, (uid, msg): (u32, String)| {
        println!("[notify] {uid}: {msg}");  // 实际应走消息队列
        Ok(())
    })?)?;

    // 规则脚本可从配置文件热加载
    lua.load(r#"
        function evaluate(uid, amount)
            local user = lookup_user(uid)
            if amount > 1000 then
                notify(uid, user .. " 触发大额交易")
                return "alert"
            end
            return "pass"
        end
    "#).exec()?;

    // 宿主调用规则
    let ev: mlua::Function = globals.get("evaluate")?;
    let action: String = ev.call((1001, 2500))?;
    println!("规则结论: {action}");          // alert
    Ok(())
}