Starlark-go: 在Go中实现Python风格确定性评估

Starlark-go是Google开发的一个Go库，它实现了Starlark语言（原名Skylark），这是一种类似Python的确定性脚本语言，最初为Bazel构建系统开发。Starlark-go允许你在Go应用程序中嵌入这种轻量级脚本语言。

主要特性

1. Python语法兼容：语法与Python 3高度相似
2. 确定性执行：没有随机性、时间依赖或全局状态
3. 沙盒环境：严格控制脚本访问权限
4. 线程安全：适合并发环境
5. 轻量级：设计简单，资源占用少

基本使用示例

package main

import (
	"fmt"
	"log"
	"go.starlark.net/starlark"
)

func main() {
	// 定义一个简单的Starlark脚本
	script := `
def factorial(n):
    if n <= 1:
        return 1
    return n * factorial(n-1)

result = factorial(5)
`

	// 创建线程和全局环境
	thread := &starlark.Thread{Name: "my thread"}
	globals := starlark.StringDict{}

	// 执行脚本
	_, err := starlark.ExecFile(thread, "factorial.star", script, globals)
	if err != nil {
		log.Fatal(err)
	}

	// 获取结果
	result := globals["result"]
	fmt.Printf("Factorial of 5 is: %v\n", result)
}

与Go类型交互

从Go调用Starlark函数

func callStarlarkFunc() {
	script := `
def greet(name):
    return "Hello, " + name + "!"
`
	thread := &starlark.Thread{Name: "greet"}
	globals := starlark.StringDict{}

	_, err := starlark.ExecFile(thread, "greet.star", script, globals)
	if err != nil {
		log.Fatal(err)
	}

	fn, ok := globals["greet"].(*starlark.Function)
	if !ok {
		log.Fatal("greet is not a function")
	}

	// 调用函数
	result, err := starlark.Call(thread, fn, starlark.Tuple{starlark.String("Gopher")}, nil)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(result) // 输出: "Hello, Gopher!"
}

向Starlark暴露Go函数

func exposeGoFunctions() {
	// 定义一个Go函数
	toUpper := starlark.NewBuiltin("to_upper", func(
		thread *starlark.Thread,
		fn *starlark.Builtin,
		args starlark.Tuple,
		kwargs []starlark.Tuple,
	) (starlark.Value, error) {
		var s string
		if err := starlark.UnpackArgs("to_upper", args, kwargs, "s", &s); err != nil {
			return nil, err
		}
		return starlark.String(strings.ToUpper(s)), nil
	})

	// 准备全局环境
	globals := starlark.StringDict{
		"to_upper": toUpper,
	}

	// 执行使用该函数的脚本
	script := `
message = to_upper("hello world")
`
	thread := &starlark.Thread{Name: "expose"}
	_, err := starlark.ExecFile(thread, "expose.star", script, globals)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(globals["message"]) // 输出: "HELLO WORLD"
}

高级用法

模块系统

func moduleSystem() {
	// 定义一个模块加载器
	loader := func(thread *starlark.Thread, module string) (starlark.StringDict, error) {
		if module == "math" {
			return starlark.StringDict{
				"pi":   starlark.Float(math.Pi),
				"sqrt": starlark.NewBuiltin("sqrt", sqrtFunc),
			}, nil
		}
		return nil, fmt.Errorf("module %s not found", module)
	}

	// 创建线程并设置模块加载器
	thread := &starlark.Thread{
		Name:  "module example",
		Load:  loader,
	}

	// 使用模块的脚本
	script := `
load("math", "pi", "sqrt")
result = sqrt(pi * 4)
`
	globals := starlark.StringDict{}
	_, err := starlark.ExecFile(thread, "module.star", script, globals)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(globals["result"])
}

// sqrtFunc 实现平方根函数
func sqrtFunc(thread *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
	var x float64
	if err := starlark.UnpackArgs("sqrt", args, kwargs, "x", &x); err != nil {
		return nil, err
	}
	return starlark.Float(math.Sqrt(x)), nil
}

自定义类型

// 定义一个自定义类型
type Person struct {
	Name string
	Age  int
}

// 实现starlark.Value接口
func (p *Person) String() string        { return fmt.Sprintf("Person(%q, %d)", p.Name, p.Age) }
func (p *Person) Type() string          { return "Person" }
func (p *Person) Freeze()               {} // 不可变对象
func (p *Person) Truth() starlark.Bool  { return starlark.True }
func (p *Person) Hash() (uint32, error) { return 0, fmt.Errorf("Person is unhashable") }

// 为Person类型定义方法
func (p *Person) Attr(name string) (starlark.Value, error) {
	switch name {
	case "name":
		return starlark.String(p.Name), nil
	case "age":
		return starlark.MakeInt(p.Age), nil
	case "greet":
		return starlark.NewBuiltin("greet", p.greet), nil
	default:
		return nil, nil
	}
}

func (p *Person) greet(thread *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
	return starlark.String(fmt.Sprintf("Hello, I'm %s, %d years old", p.Name, p.Age)), nil
}

func customTypeExample() {
	// 创建Person实例
	p := &Person{Name: "Alice", Age: 30}

	// 将Person暴露给Starlark
	globals := starlark.StringDict{
		"person": p,
	}

	// 执行脚本
	script := `
print(person)
print("Name:", person.name)
print("Age:", person.age)
print(person.greet())
`
	thread := &starlark.Thread{Name: "custom type"}
	_, err := starlark.ExecFile(thread, "person.star", script, globals)
	if err != nil {
		log.Fatal(err)
	}
}

实际应用场景

1. 配置脚本：允许用户编写复杂的配置逻辑
2. 规则引擎：定义业务规则和流程
3. 插件系统：让用户扩展应用程序功能
4. 模板引擎：动态生成内容
5. 教育工具：教授Python语法的基础知识

注意事项

1. Starlark是Python的子集，不是所有Python特性都支持
2. 性能关键代码仍应该用Go编写
3. 需要仔细设计API边界，确保安全性
4. 错误处理需要同时考虑Starlark和Go的错误

Starlark-go提供了一种安全、可控的方式在Go应用中嵌入脚本功能，特别适合需要用户自定义逻辑但又需要严格控制执行环境的场景。