# dsl **Repository Path**: blizzard1413/dsl ## Basic Information - **Project Name**: dsl - **Description**: No description available - **Primary Language**: Unknown - **License**: MIT - **Default Branch**: main - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 0 - **Forks**: 0 - **Created**: 2026-01-06 - **Last Updated**: 2026-01-08 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README # Rule DSL Core [![Go Version](https://img.shields.io/badge/Go-1.21+-00ADD8?style=flat&logo=go)](https://go.dev/) [![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE) [![Tests](https://img.shields.io/badge/Tests-Passing-success)](docs/test-report.md) [![Performance](https://img.shields.io/badge/Performance-Excellent-success)](docs/performance-report.md) [![Version](https://img.shields.io/badge/Version-1.2.0-blue)](CHANGELOG.md) 一个精简、高性能的规则引擎 Go 库，采用 JavaScript/TypeScript 语法风格，支持中英文关键字。 **🎉 v1.2.0 新增：统一插件系统 - 支持四种插件类型** ## ✨ 特性亮点 ### 🚀 核心功能 - **JS/TS 语法风格**：箭头函数、类型注解、可选链、空值合并等现代语法 - **中英文关键字**：支持 `let`/`让`、`if`/`如果`、`&&`/`且` 等双语关键字 - **Lambda 表达式**：完整支持高阶函数、闭包和函数式编程 - **模块化系统**：支持 import/export，实现代码复用和组织 - **类型系统**：基本类型检查、类型推断、可空类型、联合类型 - **丰富的内置函数**：Math、String、Array、Object、Console 等 - **自定义函数**：支持注册和使用自定义 Go 函数 ### 🆕 v1.2.0 新特性 - 统一插件系统 #### 四种插件类型 | 类型 | 语言 | 性能 | 平台 | 适用场景 | |------|------|------|------|----------| | Script | DSL | 中 | 全平台 | 简单逻辑、快速开发 | | Command | 任意 | 中 | 全平台 | 复用现有代码 | | RPC | 任意 | 高 | 全平台 | 高性能、复杂功能 | | Go | Go | 最高 | Linux/macOS | 极致性能 | #### 核心功能 - **PluginManager**：统一管理所有类型的插件 - **热加载**：运行时加载/卸载/更新插件 - **函数缓存**：LRU 缓存提升性能 - **异步调用**：支持 Future 模式的异步执行 - **资源限制**：并发控制、速率限制、超时控制 - **错误隔离**：插件错误不影响主程序 - **监控诊断**：Prometheus 指标导出、健康检查 #### 快速开始 ```go import "gitee.com/blizzard1413/dsl/plugin" // 创建插件管理器 pm := plugin.NewPluginManager(nil) pm.Start() defer pm.Stop() // 加载插件 pm.LoadPlugin("plugins/my-plugin/manifest.json") // 调用插件函数 result, err := pm.Call("myns.my_func", []interface{}{"arg1"}) ``` ### v1.1.0 特性 - 事件系统 + 基础插件 #### 事件系统 - **同步/异步事件**：支持同步和异步事件处理 - **事件优先级**：监听器按优先级执行 - **模式匹配**：支持通配符（`order.*`, `*.created`） - **事件过滤**：灵活的过滤器组合 - **事件历史**：记录和重放事件 #### 基础插件系统 - **内置插件**：HTTP、Cache、Logger、Timer - **脚本插件**：动态加载，无需重新编译 - **依赖管理**：自动解析依赖关系 - **版本控制**：支持多种版本匹配格式 ### ⚡ 性能卓越 | 指标 | 目标 | 实际 | 状态 | |------|------|------|------| | 解析速度 | > 1,000 行/秒 | **~5,800 行/秒** | ✅ **5.8倍** | | 执行速度 | > 10,000 次/秒 | **~624,000 次/秒** | ✅ **62倍** | | 内存使用 | < 100 MB | **< 1 MB** | ✅ **极低** | ### 🏗️ 架构优势 - **模块化设计**：清晰的包结构，每个模块职责单一 - **代码质量**：所有文件 ≤ 300 行，易于维护 - **完整测试**：单元测试 + 属性测试 + 集成测试，覆盖率 > 80% - **详细文档**：API 文档、语法文档、示例代码、开发指南 ## 📦 快速开始 ### 安装 ```bash go get gitee.com/blizzard1413/dsl ``` ### 基本使用 ```go package main import ( "fmt" "gitee.com/blizzard1413/dsl/engine" ) func main() { // 创建规则引擎 eng := engine.NewEngine() // 加载 DSL 规则 source := ` export rule calculateDiscount = (price: number, vipLevel: number): number => { if (vipLevel >= 3) { return price * 0.7; } else if (vipLevel >= 2) { return price * 0.8; } else { return price * 0.9; } } ` err := eng.LoadModuleFromSource("discount.dsl", source) if err != nil { panic(err) } // 执行规则 result, err := eng.Execute("calculateDiscount", map[string]interface{}{ "price": 100.0, "vipLevel": 3, }) if err != nil { panic(err) } fmt.Printf("折扣后价格: %.2f\n", result.GetValue().(float64)) // 输出: 折扣后价格: 70.00 } ``` ### 注册自定义函数 ```go package main import ( "fmt" "gitee.com/blizzard1413/dsl/engine" "gitee.com/blizzard1413/dsl/function" "gitee.com/blizzard1413/dsl/types" ) func main() { // 创建规则引擎 eng := engine.NewEngine() // 注册自定义函数 eng.RegisterFunction("double", function.NewFunction( "double", function.NewSignature( []types.Type{types.NewNumberType()}, types.NewNumberType(), ), func(args []interface{}) (interface{}, error) { num := args[0].(float64) return num * 2, nil }, )) // 在 DSL 中使用自定义函数 source := ` export rule calculate = (x: number): number => { return double(x) + 10; } ` eng.LoadModuleFromSource("custom.dsl", source) result, _ := eng.Execute("calculate", map[string]interface{}{"x": 5.0}) fmt.Printf("结果: %.0f\n", result.GetValue().(float64)) // 输出: 结果: 20 } ``` ### DSL 语法示例 ```javascript // 定义规则 rule calculateDiscount = (price: number, vipLevel: number): number => { if (vipLevel >= 3) { return price * 0.7; } else if (vipLevel >= 2) { return price * 0.8; } else { return price * 0.9; } } // 使用 Lambda 表达式 let numbers = [1, 2, 3, 4, 5]; let doubled = numbers.map(x => x * 2); let evens = numbers.filter(x => x % 2 == 0); ``` ### 中文语法示例 ```javascript 规则 计算折扣 = (价格: number, 会员等级: number): number => { 如果 (会员等级 >= 3) { 返回 价格 * 0.7; } 否则如果 (会员等级 >= 2) { 返回 价格 * 0.8; } 否则 { 返回 价格 * 0.9; } } ``` ## 语法特性 ### 变量声明 ```javascript let x = 10; // 可变变量 const PI = 3.14159; // 常量 let name: string; // 类型注解 ``` ### 箭头函数 ```javascript // 单参数简写 let double = x => x * 2; // 多参数 let add = (x, y) => x + y; // 块语句 let complex = (x) => { let result = x * 2; return result + 1; } ``` ### 高阶函数 ```javascript let numbers = [1, 2, 3, 4, 5]; // map let doubled = numbers.map(x => x * 2); // filter let evens = numbers.filter(x => x % 2 == 0); // reduce let sum = numbers.reduce((acc, x) => acc + x, 0); ``` ### 可选链和空值合并 ```javascript let value = obj?.property?.nested; let result = value ?? defaultValue; ``` ### 控制流 ```javascript // if-else if (condition) { // ... } else if (otherCondition) { // ... } else { // ... } // for 循环 for (let i = 0; i < 10; i++) { // ... } // for-of 循环 for (let item of array) { // ... } // while 循环 while (condition) { // ... } ``` ### 模块化 ```javascript // 导入 import { rule1, rule2 } from "./module"; // 导出 export rule myRule = (x: number): number => { return x * 2; } ``` ## 🎯 完整功能列表 ### 语法特性 ✅ **变量声明** - `let` 可变变量 - `const` 常量（不可修改） - 类型注解支持 ✅ **数据类型** - 基本类型：`number`, `string`, `boolean`, `null`, `undefined` - 复合类型：`array`, `object` - 可空类型：`Type?` - 联合类型：`Type1 | Type2` ✅ **运算符** - 算术：`+`, `-`, `*`, `/`, `%`, `**`（幂运算） - 比较：`==`, `!=`, `===`, `!==`, `>`, `<`, `>=`, `<=` - 逻辑：`&&`, `||`, `!`（支持短路求值） - 三元：`condition ? true : false` - 空值合并：`value ?? default` - 可选链：`obj?.property` ✅ **控制流** - `if-else` 条件语句 - `for` 循环（C 风格） - `for-of` 循环 - `while` 循环 - `break` / `continue` / `return` ✅ **函数** - 箭头函数：`(x) => x * 2` - 单参数简写：`x => x * 2` - 块语句：`(x) => { return x * 2; }` - 高阶函数：`map`, `filter`, `reduce` - 闭包支持 - 自定义函数注册：通过 Go API 注册自定义函数 ✅ **模块系统** - `import { rule1, rule2 } from "./module"` - `export rule name = ...` - 模块缓存 - 路径解析 ### 内置函数库 #### Math 函数 - `Math.abs(x)` - 绝对值 - `Math.ceil(x)` - 向上取整 - `Math.floor(x)` - 向下取整 - `Math.round(x)` - 四舍五入 - `Math.max(...values)` - 最大值 - `Math.min(...values)` - 最小值 - `Math.sqrt(x)` - 平方根 - `Math.pow(x, y)` - 幂运算 #### String 函数 - `String.concat(...strings)` - 连接字符串 - `String.length(s)` - 字符串长度 - `String.toUpperCase(s)` - 转大写 - `String.toLowerCase(s)` - 转小写 - `String.trim(s)` - 去除空白 - `String.split(s, separator)` - 分割字符串 #### Array 函数 - `Array.length(arr)` - 数组长度 - `Array.map(arr, fn)` - 映射转换 - `Array.filter(arr, fn)` - 过滤筛选 - `Array.reduce(arr, fn, init)` - 归约累积 - `Array.sort(arr)` - 排序 - `Array.find(arr, fn)` - 查找元素 #### Object 函数 - `Object.keys(obj)` - 获取所有键 - `Object.values(obj)` - 获取所有值 - `Object.entries(obj)` - 获取键值对 #### Console 函数 - `console.log(value)` - 打印日志（调试用） ## 🏗️ 项目架构 ### 目录结构 ``` dsl/ ├── go.mod # Go 模块定义 ├── go.sum # 依赖锁定 ├── README.md # 项目说明 ├── Taskfile.yml # 任务定义 ├── performance_test.go # 性能测试 ├── code_quality_test.go # 代码质量测试 │ ├── engine/ # 规则引擎（核心） │ ├── engine.go # 引擎主接口 │ ├── rule.go # 规则数据结构 │ ├── executor.go # 规则执行器 │ └── *_test.go # 测试文件 │ ├── parser/ # 解析器 │ ├── parser.go # Parser 主接口 │ ├── formatter.go # AST 格式化器 │ ├── visitor_*.go # AST 访问器（按功能拆分） │ ├── ast/ # AST 子包 │ │ ├── base.go # 基础接口 │ │ ├── declarations.go # 声明节点 │ │ ├── statements.go # 语句节点 │ │ ├── expressions.go # 表达式节点 │ │ └── types.go # 类型节点 │ ├── grammar/ # 语法文件 │ │ └── RuleDSL.g4 # ANTLR4 语法定义 │ └── generated/ # ANTLR4 生成代码 │ ├── evaluator/ # 求值器 │ ├── evaluator.go # Evaluator 接口 │ ├── expressions.go # 表达式求值 │ ├── operators.go # 运算符处理 │ ├── statements.go # 语句执行 │ ├── lambda.go # Lambda 表达式 │ └── *_test.go # 测试文件 │ ├── context/ # 上下文管理 │ ├── context.go # Context 接口 │ ├── scope.go # 作用域管理 │ ├── variable.go # 变量管理 │ └── *_test.go # 测试文件 │ ├── types/ # 类型系统 │ ├── type.go # Type 接口 │ ├── primitive.go # 基本类型 │ ├── composite.go # 复合类型 │ ├── nullable.go # 可空类型 │ ├── union.go # 联合类型 │ ├── checker.go # 类型检查 │ ├── inference.go # 类型推断 │ └── *_test.go # 测试文件 │ ├── function/ # 函数系统 │ ├── registry.go # 函数注册表 │ ├── function.go # Function 接口 │ ├── signature.go # 函数签名 │ ├── builtin/ # 内置函数子包 │ │ ├── math.go # Math 函数 │ │ ├── string.go # String 函数 │ │ ├── array.go # Array 函数 │ │ ├── object.go # Object 函数 │ │ ├── console.go # Console 函数 │ │ └── *_test.go # 测试文件 │ └── *_test.go # 测试文件 │ ├── module/ # 模块系统 │ ├── loader.go # 模块加载 │ ├── resolver.go # 路径解析 │ ├── cache.go # 模块缓存 │ ├── import.go # Import 处理 │ ├── export.go # Export 处理 │ └── *_test.go # 测试文件 │ ├── errors/ # 错误处理 │ ├── codes.go # 错误码定义 │ ├── errors.go # Error 结构 │ ├── builder.go # 错误构建器 │ └── *_test.go # 测试文件 │ ├── examples/ # 示例代码 │ ├── 01-hello-world/ # Hello World 示例 │ ├── 02-variables/ # 变量示例 │ ├── 03-control-flow/ # 控制流示例 │ ├── 04-arrays/ # 数组示例 │ ├── 05-chinese-keywords/ # 中文关键字示例 │ ├── 06-real-world/ # 真实场景示例 │ ├── basic/ # 基础示例 │ ├── advanced/ # 高级示例 │ └── lambda/ # Lambda 示例 │ └── docs/ # 文档 ├── api.md # API 文档 ├── grammar.md # 语法文档 ├── examples.md # 示例文档 ├── usage.md # 使用指南 ├── development.md # 开发指南 ├── antlr4-setup.md # ANTLR4 设置 ├── performance-report.md # 性能报告 ├── test-report.md # 测试报告 └── code-quality-report.md # 代码质量报告 ``` ### 架构设计 ``` ┌──────────────────────────────────────┐ │ Application Layer │ │ (使用 Rule Engine 的应用代码) │ └──────────────┬───────────────────────┘ │ ┌──────────────▼───────────────────────┐ │ Rule Engine Layer │ │ - Rule Management │ │ - Module Loading │ │ - Execution Control │ └──────────────┬───────────────────────┘ │ ┌──────────────▼───────────────────────┐ │ Evaluation Layer │ │ - Expression Evaluator │ │ - Statement Executor │ │ - Function Caller │ └──────────────┬───────────────────────┘ │ ┌──────────────▼───────────────────────┐ │ Parsing Layer │ │ - ANTLR4 Parser │ │ - AST Builder (Visitor) │ │ - AST Formatter │ └──────────────┬───────────────────────┘ │ ┌──────────────▼───────────────────────┐ │ Infrastructure Layer │ │ - Context (变量管理) │ │ - Type System (类型检查) │ │ - Function Registry (函数注册) │ │ - Error Handling (错误处理) │ └──────────────────────────────────────┘ ``` ## 🧪 测试 ### 测试覆盖 项目包含完整的测试套件，确保代码质量和正确性： - ✅ **单元测试**：测试每个模块的核心功能 - ✅ **属性测试**：使用 `gopter` 进行基于属性的测试 - ✅ **集成测试**：测试完整的解析-执行流程 - ✅ **性能测试**：基准测试和性能目标验证 - ✅ **代码质量测试**：文件大小、模块内聚性验证 ### 测试统计 - **测试覆盖率**：> 80% - **属性测试**：12 个正确性属性，每个运行 100+ 次 - **单元测试**：覆盖所有核心功能 - **集成测试**：测试真实使用场景 ### 运行测试 ```bash # 运行所有测试 go test ./... # 运行测试并显示覆盖率 go test -cover ./... # 运行属性测试 go test -v ./... -run Property # 运行性能测试 go test -v -run "^Test.*Target$|^TestMemoryUsageLimit$" # 运行基准测试 go test -bench=. -benchmem # 运行代码质量测试 go test -v -run "^TestCodeQuality" ``` ### 正确性属性 项目实现了 12 个正确性属性，通过属性测试验证： 1. **Parse-Format Round Trip** - 解析后格式化再解析应得到相同 AST 2. **Variable Read Consistency** - 变量读取一致性 3. **Const Immutability** - const 不可变性 4. **Lambda Closure Capture** - Lambda 闭包捕获 5. **Map Transformation Correctness** - Map 转换正确性 6. **Filter Predicate Correctness** - Filter 谓词正确性 7. **Reduce Accumulation Correctness** - Reduce 累积正确性 8. **Operator Precedence Correctness** - 运算符优先级正确性 9. **Short-Circuit Evaluation** - 短路求值 10. **Type Annotation Validation** - 类型注解验证 11. **File Size Limit Compliance** - 文件大小限制合规性 12. **Module Cohesion** - 模块内聚性 详细测试报告请参考 [测试报告](docs/test-report.md)。 ## 📊 性能表现 DSL Core 库经过全面的性能优化和测试，在所有指标上都远超设计目标： ### 性能指标 | 指标 | 目标 | 实际表现 | 超越倍数 | |------|------|---------|---------| | **解析速度** | > 1,000 行/秒 | **~5,800 行/秒** | **5.8x** ✅ | | **执行速度** | > 10,000 次/秒 | **~624,000 次/秒** | **62.4x** ✅ | | **内存使用** | < 100 MB | **< 1 MB** | **极低** ✅ | ### 性能亮点 - ⚡ **快速解析**：在不同文件大小下保持约 5,800 行/秒的一致速度 - 🚀 **高效执行**：简单算术运算达到 847K 操作/秒 - 💾 **低内存占用**：100 个复杂规则执行 10 次仅使用 0.63 MB - ⏱️ **快速表达式求值**：大多数表达式在 200 纳秒内完成 - 📦 **高效内置函数**：所有内置函数在亚微秒级时间内执行 ### 基准测试结果 ``` BenchmarkParseSpeed/1000_lines 5,755 lines/sec 103.78 MB/op BenchmarkExecutionSpeed/simple 847,847 exec/sec 880 B/op BenchmarkExecutionSpeed/complex 570,545 exec/sec 1,297 B/op BenchmarkExpressionEvaluation/literal 16.90 ns/op 8 B/op BenchmarkBuiltinFunctions/Math.abs 200.9 ns/op 56 B/op ``` 详细性能报告请参考 [性能测试报告](docs/performance-report.md)。 ### 运行性能测试 ```bash # 运行性能目标测试 go test -v -run "^TestParseSpeedTarget$|^TestExecutionSpeedTarget$|^TestMemoryUsageLimit$" # 运行所有基准测试 go test -bench=^Benchmark -benchmem -benchtime=3s # 运行特定基准测试 go test -bench=BenchmarkParseSpeed -benchmem ``` ## 🛠️ 开发指南 ### 前置要求 - Go 1.21+ - Python 3.7+ (用于 ANTLR4 工具) - Task (任务运行器，可选) ### 环境设置 #### 1. 安装 ANTLR4 ```bash pip install antlr4-tools ``` #### 2. 安装 Go 运行时 ```bash go get github.com/antlr4-go/antlr/v4 ``` #### 3. 安装 Task (可选) ```bash # Windows (使用 Chocolatey) choco install go-task # macOS (使用 Homebrew) brew install go-task # 或使用 Go 安装 go install github.com/go-task/task/v3/cmd/task@latest ``` 详细安装指南请参考 [ANTLR4 设置文档](docs/antlr4-setup.md)。 ### 生成解析器 使用 Task： ```bash task generate ``` 或手动运行： ```bash cd parser/grammar antlr4 -Dlanguage=Go -o ../generated -package generated -visitor RuleDSL.g4 ``` ### 开发工作流 ```bash # 1. 克隆仓库 git clone https://gitee.com/blizzard1413/dsl.git cd dsl # 2. 安装依赖 go mod download # 3. 生成解析器（如果修改了语法） task generate # 4. 运行测试 go test ./... # 5. 运行性能测试 go test -bench=. -benchmem # 6. 检查代码质量 go test -v -run "^TestCodeQuality" ``` ## 📚 文档 - [快速开始](docs/quick-start.md) - 5 分钟上手指南 - [使用指南](docs/usage.md) - 详细使用说明 - [API 文档](docs/api.md) - 完整 API 参考 - [语法文档](docs/grammar.md) - DSL 语法规范 - [示例代码](docs/examples.md) - 丰富的示例集合 - [开发指南](docs/development.md) - 开发者指南 - [性能测试报告](docs/performance-report.md) - 性能基准测试 - [测试报告](docs/test-report.md) - 测试覆盖报告 - [代码质量报告](docs/code-quality-report.md) - 代码质量分析 - [ANTLR4 设置](docs/antlr4-setup.md) - 开发环境配置 ## 🎓 示例 项目包含丰富的示例代码，涵盖各种使用场景： - **01-hello-world** - Hello World 入门示例 - **02-variables** - 变量声明和使用 - **03-control-flow** - 控制流语句 - **04-arrays** - 数组操作 - **05-chinese-keywords** - 中文关键字示例 - **06-real-world** - 真实业务场景（电商订单） - **07-custom-functions** - 自定义函数注册和使用 - **08-events** - 事件系统示例（订单处理、系统监控）🆕 - **09-plugins** - 插件系统示例（内置插件、自定义插件、脚本插件）🆕 - **basic** - 基础功能示例 - **advanced** - 高级功能示例（折扣计算、数据验证） - **lambda** - Lambda 表达式和高阶函数 查看 [examples/](examples/) 目录获取完整示例代码。 ## 🎯 设计原则 1. **先核心后扩展**：专注于最核心的功能，避免过度设计 2. **简单高效**：保持代码简洁，易于理解和维护 3. **文件大小限制**：单个文件不超过 300 行（目标），保持模块小而专注 4. **模块化组织**：使用子包组织复杂模块，职责清晰 5. **测试驱动**：每个功能都有对应的测试，确保质量 6. **性能优先**：在保证正确性的前提下，追求高性能 ## 📈 项目状态 ### v1.0.0 - 已完成 ✅ **完成时间**：2026-01-06 **完成内容**： ✅ **Phase 1**: 项目初始化和基础设施 - 项目结构搭建 - 错误处理系统 ✅ **Phase 2**: RuleDSL 语法和解析器 - ANTLR4 语法设计 - AST 数据结构 - AST Visitor - Parser 接口和格式化器 ✅ **Phase 3**: 类型系统 - 基础类型系统 - 类型检查器 - 类型推断 ✅ **Phase 4**: 上下文和变量管理 - Context 实现 - 作用域管理 - 变量管理（let/const） ✅ **Phase 5**: 函数系统 - 函数注册表 - 内置函数库（Math, String, Array, Object, Console） ✅ **Phase 6**: 求值器 - 表达式求值器 - 语句执行器 - Lambda 和闭包 ✅ **Phase 7**: 模块系统 - 模块加载器 - Import/Export 处理 - 模块缓存 ✅ **Phase 8**: 规则引擎 - Rule Engine 实现 - 规则执行器 ✅ **Phase 9**: 代码质量和文档 - 代码质量检查 - 完整文档 - 示例代码 ✅ **Phase 10**: 最终测试 - 所有单元测试 - 属性测试 - 性能测试 **统计数据**： - 总任务数：22 个 - 完成任务：22 个 - 完成率：100% - 测试覆盖率：> 80% - 性能超越目标：5.8x (解析) / 62.4x (执行) ## 📝 许可证 MIT License - 详见 [LICENSE](LICENSE) 文件 ## 🤝 贡献 欢迎提交 Issue 和 Pull Request！ ### 贡献指南 1. Fork 本仓库 2. 创建特性分支 (`git checkout -b feature/AmazingFeature`) 3. 提交更改 (`git commit -m 'Add some AmazingFeature'`) 4. 推送到分支 (`git push origin feature/AmazingFeature`) 5. 开启 Pull Request ### 代码规范 - 遵循 Go 代码规范 - 单个文件不超过 300 行 - 所有新功能必须包含测试 - 提交前运行 `go test ./...` 确保测试通过 ## 🗺️ 路线图 ### v1.0.0 (已完成) ✅ - ✅ 核心语法和解析器 - ✅ 类型系统 - ✅ 求值器和执行引擎 - ✅ 模块系统 - ✅ 内置函数库 - ✅ 完整测试套件 - ✅ 性能优化 ### v2.0.0 (计划中) 未来可能扩展的功能： - 🔄 编译器和字节码优化 - 🔄 事件系统 - 🔄 沙箱和资源限制 - 🔄 WorkflowDSL 扩展 - 🔄 持久化和缓存机制 - 🔄 监控和追踪 - 🔄 插件系统 - 🔄 更多内置函数 - 🔄 调试工具 ## 💬 联系方式 - 仓库地址：https://gitee.com/blizzard1413/dsl - Issue 追踪：https://gitee.com/blizzard1413/dsl/issues ## 🙏 致谢 感谢以下开源项目： - [ANTLR4](https://www.antlr.org/) - 强大的解析器生成器 - [gopter](https://github.com/leanovate/gopter) - Go 属性测试库 - [Go](https://go.dev/) - 优秀的编程语言 --- **Made with ❤️ by the DSL Core Team**