2 files changed, 724 insertions, 201 deletions

diff --git a/doc/docs/zh/README.md b/doc/docs/zh/README.md
index f5c9811..05b2069 100755
--- a/doc/docs/zh/README.md
+++ b/doc/docs/zh/README.md
@@ -3,6 +3,6 @@ home: true
 heroImage: /image/yuescript.svg
 actionText: 快速上手 →
 actionLink: /zh/doc/
-footer: MIT Licensed | Copyright © 2017-2025 Li Jin
+footer: MIT Licensed | Copyright © 2017-2026 Li Jin
 ---
 
diff --git a/doc/docs/zh/doc/README.md b/doc/docs/zh/doc/README.md
index 2968f6e..de5dff1 100755
--- a/doc/docs/zh/doc/README.md
+++ b/doc/docs/zh/doc/README.md
@@ -9,24 +9,24 @@ title: 参考手册
 
 ## 介绍
 
-月之脚本（YueScript）是一种动态语言，可以编译为Lua。它是[MoonScript](https://github.com/leafo/moonscript)的方言。用月之脚本编写的代码既有表现力又非常简洁。它适合编写一些更易于维护的代码，并在嵌入 Lua 的环境中运行，如游戏或网站服务器。
+月之脚本（YueScript）是一种动态语言，可以编译为 Lua。它是 [MoonScript](https://github.com/leafo/moonscript) 的方言。用月之脚本编写的代码既有表现力又非常简洁。它适合编写一些更易于维护的代码，并在嵌入 Lua 的环境中运行，如游戏或网站服务器。
 
 Yue（月）是中文中“月亮”的名称。
 
 ### 月之脚本概览
 ```moonscript
 -- 导入语法
-import "yue" as :p, :to_lua
+import p, to_lua from "yue"
 
 -- 隐式对象
 inventory =
   equipment:
-    * "sword"
-    * "shield"
+    - "sword"
+    - "shield"
   items:
-    * name: "potion"
+    - name: "potion"
       count: 10
-    * name: "bread"
+    - name: "bread"
       count: 3
 
 -- 列表推导
@@ -61,17 +61,17 @@ export 🌛 = "月之脚本"
 <YueDisplay>
 <pre>
 -- 导入语法
-import "yue" as :p, :to_lua
+import p, to_lua from "yue"
 
 -- 隐式对象
 inventory =
   equipment:
-    * "sword"
-    * "shield"
+    - "sword"
+    - "shield"
   items:
-    * name: "potion"
+    - name: "potion"
       count: 10
-    * name: "bread"
+    - name: "bread"
       count: 3
 
 -- 列表推导
@@ -109,7 +109,7 @@ export 🌛 = "月之脚本"
 
 * **Lua 模块**
 
-&emsp;安装 [luarocks](https://luarocks.org)，一个Lua模块的包管理器。然后作为Lua模块和可执行文件安装它：
+&emsp;安装 [luarocks](https://luarocks.org)，一个 Lua 模块的包管理器。然后作为 Lua 模块和可执行文件安装它：
 
 ```
 > luarocks install yuescript
@@ -150,14 +150,14 @@ export 🌛 = "月之脚本"
 
 ### Lua 模块
 
-在Lua中使用月之脚本模块：
+在 Lua 中使用月之脚本模块：
 
 * **用法 1**
-在Lua中引入 "你的脚本入口文件.yue"。
+在 Lua 中引入 "你的脚本入口文件.yue"。
 ```Lua
 require("yue")("你的脚本入口文件")
 ```
-当你在同一路径下把 "你的脚本入口文件.yue" 编译成了 "你的脚本入口文件.lua" 时，仍然可以使用这个代码加载 .lua 代码文件。在其余的月之脚本文件中，只需正常使用 **require** 或 **import**进行脚本引用即可。错误消息中的代码行号也会被正确处理。
+当你在同一路径下把 "你的脚本入口文件.yue" 编译成了 "你的脚本入口文件.lua" 时，仍然可以使用这个代码加载 .lua 代码文件。在其余的月之脚本文件中，只需正常使用 **require** 或 **import** 进行脚本引用即可。错误消息中的代码行号也会被正确处理。
 
 * **用法 2**
 手动引入月之脚本模块并重写错误消息来帮助调试。
@@ -172,7 +172,7 @@ end)
 ```
 
 * **用法 3**
-在Lua中使用月之脚本编译器功能。
+在 Lua 中使用月之脚本编译器功能。
 ```lua
 local yue = require("yue")
 local codes, err, globals = yue.to_lua([[
@@ -222,12 +222,12 @@ f!
    不添加任何选项执行命令可以进入REPL模式，
    在单行输入符号 '$' 并换行后，可以开始或是停止多行输入模式
 ```
-&emsp;&emsp;使用案例：
-&emsp;&emsp;递归编译当前路径下扩展名为 **.yue** 的每个月之脚本文件： **yue .**
-&emsp;&emsp;编译并将结果保存到目标路径： **yue -t /target/path/ .**
-&emsp;&emsp;编译并保留调试信息： **yue -l .**
-&emsp;&emsp;编译并生成压缩代码： **yue -m .**
-&emsp;&emsp;直接执行代码： **yue -e 'print 123'**
+&emsp;&emsp;使用案例：  
+&emsp;&emsp;递归编译当前路径下扩展名为 **.yue** 的每个月之脚本文件： **yue .**  
+&emsp;&emsp;编译并将结果保存到目标路径： **yue -t /target/path/ .**  
+&emsp;&emsp;编译并保留调试信息： **yue -l .**  
+&emsp;&emsp;编译并生成压缩代码： **yue -m .**  
+&emsp;&emsp;直接执行代码： **yue -e 'print 123'**  
 &emsp;&emsp;执行一个月之脚本文件： **yue -e main.yue**
 
 ## 宏
@@ -407,16 +407,16 @@ print $LINE -- 获取当前代码行数：2
 
 ```moonscript
 macro Enum = (...) ->
-        items = {...}
-        itemSet = {item, true for item in *items}
-        (item) ->
-                error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
-                "\"#{item}\""
+  items = {...}
+  itemSet = {item, true for item in *items}
+  (item) ->
+    error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
+    "\"#{item}\""
 
 macro BodyType = $Enum(
-        Static
-        Dynamic
-        Kinematic
+  Static
+  Dynamic
+  Kinematic
 )
 
 print "有效的枚举类型:", $BodyType Static
@@ -425,16 +425,16 @@ print "有效的枚举类型:", $BodyType Static
 <YueDisplay>
 <pre>
 macro Enum = (...) ->
-        items = {...}
-        itemSet = {item, true for item in *items}
-        (item) ->
-                error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
-                "\"#{item}\""
+  items = {...}
+  itemSet = {item, true for item in *items}
+  (item) ->
+    error "got \"#{item}\", expecting one of #{table.concat items, ', '}" unless itemSet[item]
+    "\"#{item}\""
 
 macro BodyType = $Enum(
-        Static
-        Dynamic
-        Kinematic
+  Static
+  Dynamic
+  Kinematic
 )
 
 print "有效的枚举类型:", $BodyType Static
@@ -442,9 +442,57 @@ print "有效的枚举类型:", $BodyType Static
 </pre>
 </YueDisplay>
 
+### 宏参数检查
+
+可以直接在参数列表中声明期望的 AST 节点类型，并在编译时检查传入的宏参数是否符合预期。
+
+```moonscript
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+
+$printNumAndStr 123, "hello"
+```
+<YueDisplay>
+<pre>
+macro printNumAndStr = (num `Num, str `String) -> |
+  print(
+    #{num}
+    #{str}
+  )
+
+$printNumAndStr 123, "hello"
+</pre>
+</YueDisplay>
+
+如果需要做更加灵活的参数检查操作，可以使用内置的 `$is_ast` 宏函数在合适的位置进行手动检查。
+
+```moonscript
+macro printNumAndStr = (num, str) ->
+  error "expected Num as first argument" unless $is_ast Num, num
+  error "expected String as second argument" unless $is_ast String, str
+  "print(#{num}, #{str})"
+
+$printNumAndStr 123, "hello"
+```
+<YueDisplay>
+<pre>
+macro printNumAndStr = (num, str) ->
+  error "expected Num as first argument" unless $is_ast Num, num
+  error "expected String as second argument" unless $is_ast String, str
+  "print(#{num}, #{str})"
+
+$printNumAndStr 123, "hello"
+</pre>
+</YueDisplay>
+
+更多关于可用 AST 节点的详细信息，请参考 [yue_parser.cpp](https://github.com/IppClub/YueScript/blob/main/src/yuescript/yue_parser.cpp) 中大写的规则定义。
+
 ## 操作符
 
-Lua的所有二元和一元操作符在月之脚本中都是可用的。此外，**!=** 符号是 **~=** 的别名，而 **\\** 或 **::** 均可用于编写链式函数调用，如写作 `tb\func!` 或 `tb::func!`。此外月之脚本还提供了一些其他特殊的操作符，以编写更具表达力的代码。
+Lua 的所有二元和一元操作符在月之脚本中都是可用的。此外，**!=** 符号是 **~=** 的别名，而 **\\** 或 **::** 均可用于编写链式函数调用，如写作 `tb\func!` 或 `tb::func!`。此外月之脚本还提供了一些其他特殊的操作符，以编写更具表达力的代码。
 
 ```moonscript
 tb\func! if tb ~= nil
@@ -484,56 +532,56 @@ print 1 <= a <= 10
 
 ```moonscript
 v = (x) ->
-        print x
-        x
+  print x
+  x
 
 print v(1) < v(2) <= v(3)
 --[[
-        输出：
-        2
-        1
-        3
-        true
+  输出：
+  2
+  1
+  3
+  true
 ]]
 
 print v(1) > v(2) <= v(3)
 --[[
-        输出：
-        2
-        1
-        false
+  输出：
+  2
+  1
+  false
 ]]
 ```
 <YueDisplay>
 <pre>
 v = (x) ->
-        print x
-        x
+  print x
+  x
 
 print v(1) < v(2) <= v(3)
 --[[
-        输出：
-        2
-        1
-        3
-        true
+  输出：
+  2
+  1
+  3
+  true
 ]]
 
 print v(1) > v(2) <= v(3)
 --[[
-        输出：
-        2
-        1
-        false
+  输出：
+  2
+  1
+  false
 ]]
 </pre>
 </YueDisplay>
 
-在上面的例子里，中间的表达式`v(2)`仅被计算一次，如果把表达式写成`v(1) < v(2) and v(2) <= v(3)`的方式，中间的`v(2)`才会被计算两次。在链式比较中，求值的顺序往往是未定义的。所以强烈建议不要在链式比较中使用具有副作用（比如做打印操作）的表达式。如果需要使用有副作用的函数，应明确使用短路 `and` 运算符来做连接。
+在上面的例子里，中间的表达式 `v(2)` 仅被计算一次，如果把表达式写成 `v(1) < v(2) and v(2) <= v(3)` 的方式，中间的 `v(2)` 才会被计算两次。在链式比较中，求值的顺序往往是未定义的。所以强烈建议不要在链式比较中使用具有副作用（比如做打印操作）的表达式。如果需要使用有副作用的函数，应明确使用短路 `and` 运算符来做连接。
 
 ### 表追加
 
-**[] =** 操作符用于向Lua表的最后插入值。
+**[] =** 操作符用于向 Lua 表的最后插入值。
 
 ```moonscript
 tab = []
@@ -546,19 +594,36 @@ tab[] = "Value"
 </pre>
 </YueDisplay>
 
+你还可以使用展开操作符 `...` 来将一个列表中的所有元素追加到另一个列表中：
+
+```moonscript
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA 现在为 [1, 2, 3, 4, 5, 6]
+```
+<YueDisplay>
+<pre>
+tbA = [1, 2, 3]
+tbB = [4, 5, 6]
+tbA[] = ...tbB
+-- tbA 现在为 [1, 2, 3, 4, 5, 6]
+</pre>
+</YueDisplay>
+
 ### 表扩展
 
-你可以使用前置 `...` 操作符在Lua表中插入数组表或哈希表。
+你可以使用前置 `...` 操作符在 Lua 表中插入数组表或哈希表。
 
 ```moonscript
 parts =
-        * "shoulders"
-        * "knees"
+  * "shoulders"
+  * "knees"
 lyrics =
-        * "head"
-        * ...parts
-        * "and"
-        * "toes"
+  * "head"
+  * ...parts
+  * "and"
+  * "toes"
 
 copy = {...other}
 
@@ -569,13 +634,13 @@ merge = {...a, ...b}
 <YueDisplay>
 <pre>
 parts =
-        * "shoulders"
-        * "knees"
+  * "shoulders"
+  * "knees"
 lyrics =
-        * "head"
-        * ...parts
-        * "and"
-        * "toes"
+  * "head"
+  * ...parts
+  * "and"
+  * "toes"
 
 copy = {...other}
 
@@ -585,12 +650,29 @@ merge = {...a, ...b}
 </pre>
 </YueDisplay>
 
+### 表反向索引
+
+你可以使用 **#** 操作符来反向索引表中的元素。
+
+```moonscript
+last = data.items[#]
+second_last = data.items[#-1]
+data.items[#] = 1
+```
+<YueDisplay>
+<pre>
+last = data.items[#]
+second_last = data.items[#-1]
+data.items[#] = 1
+</pre>
+</YueDisplay>
+
 ### 元表
 
 **<>** 操作符可提供元表操作的快捷方式。
 
 * **元表创建**
-使用空括号 **<>** 或被 **<>** 包围的元方法键创建普通的Lua表。
+使用空括号 **<>** 或被 **<>** 包围的元方法键创建普通的 Lua 表。
 
 ```moonscript
 mt = {}
@@ -732,7 +814,7 @@ readFile "example.txt"
 
 ### 空值合并
 
-如果其左操作数不是**nil**，则nil合并运算符 **??** 返回其左操作数的值；否则，它将计算右操作数并返回其结果。如果左操作数计算结果为非nil的值，**??** 运算符将不再计算其右操作数。
+如果其左操作数不是 **nil**，则nil合并运算符 **??** 返回其左操作数的值；否则，它将计算右操作数并返回其结果。如果左操作数计算结果为非 nil 的值，**??** 运算符将不再计算其右操作数。
 ```moonscript
 local a, b, c, d
 a = b ?? c ?? d
@@ -751,67 +833,87 @@ a ??= false
 
 ### 隐式对象
 
-你可以在表格块内使用符号 **\*** 开始编写一系列隐式结构。如果你正在创建隐式对象，对象的字段必须具有相同的缩进。
+你可以在表格块内使用符号 **\*** 或是 **-** 开始编写一系列隐式结构。如果你正在创建隐式对象，对象的字段必须具有相同的缩进。
+
 ```moonscript
+-- 赋值时使用隐式对象
 list =
   * 1
   * 2
   * 3
 
+-- 函数调用时使用隐式对象
 func
   * 1
   * 2
   * 3
 
+-- 返回时使用隐式对象
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- 表格时使用隐式对象
 tb =
   name: "abc"
 
   values:
-    * "a"
-    * "b"
-    * "c"
+    - "a"
+    - "b"
+    - "c"
 
   objects:
-    * name: "a"
+    - name: "a"
       value: 1
       func: => @value + 1
       tb:
         fieldA: 1
 
-    * name: "b"
+    - name: "b"
       value: 2
       func: => @value + 2
       tb: { }
-
 ```
 <YueDisplay>
 <pre>
+-- 赋值时使用隐式对象
 list =
   * 1
   * 2
   * 3
 
+-- 函数调用时使用隐式对象
 func
   * 1
   * 2
   * 3
 
+-- 返回时使用隐式对象
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- 表格时使用隐式对象
 tb =
   name: "abc"
 
   values:
-    * "a"
-    * "b"
-    * "c"
+    - "a"
+    - "b"
+    - "c"
 
   objects:
-    * name: "a"
+    - name: "a"
       value: 1
       func: => @value + 1
       tb:
         fieldA: 1
 
-    * name: "b"
+    - name: "b"
       value: 2
       func: => @value + 2
       tb: { }
@@ -991,7 +1093,7 @@ export default ->
 
 ## 赋值
 
-月之脚本中定义的变量是动态类型的，并默认为局部变量。但你可以通过**local**和**global**声明来改变声明变量的作用范围。
+月之脚本中定义的变量是动态类型的，并默认为局部变量。但你可以通过 **local** 和 **global** 声明来改变声明变量的作用范围。
 
 ```moonscript
 hello = "world"
@@ -1120,9 +1222,9 @@ do
 
 ## 解构赋值
 
-解构赋值是一种快速从Lua表中按名称或基于数组中的位置提取值的方法。
+解构赋值是一种快速从 Lua 表中按名称或基于数组中的位置提取值的方法。
 
-通常当你看到一个字面量的Lua表，比如{1,2,3}，它位于赋值的右侧，因为它是一个值。解构赋值语句的写法就是交换了字面量Lua表的角色，并将其放在赋值语句的左侧。
+通常当你看到一个字面量的 Lua 表，比如 `{1,2,3}`，它位于赋值的右侧，因为它是一个值。解构赋值语句的写法就是交换了字面量 Lua 表的角色，并将其放在赋值语句的左侧。
 
 最好是通过示例来解释。以下是如何从表格中解包前两个值的方法：
 
@@ -1221,7 +1323,7 @@ print first, second, color
 </pre>
 </YueDisplay>
 
-有时候我们会需要从Lua表中提取值并将它们赋给与键同名的局部变量。为了避免编写重复代码，我们可以使用 **:** 前缀操作符：
+有时候我们会需要从 Lua 表中提取值并将它们赋给与键同名的局部变量。为了避免编写重复代码，我们可以使用 **:** 前缀操作符：
 
 ```moonscript
 {:concat, :insert} = table
@@ -1265,9 +1367,55 @@ print first, second, color
 </pre>
 </YueDisplay>
 
-### 在其它地方的解构
+### 范围解构
+
+你可以使用展开运算符 `...` 在列表解构中来捕获一个范围的值到子列表中。这在当你想要从列表的开头和结尾提取特定元素，同时收集中间的元素时非常有用。
+
+```moonscript
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- 打印: first
+print bulk   -- 打印: {"second", "third", "fourth"}
+print last   -- 打印: last
+```
+<YueDisplay>
+<pre>
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- 打印: first
+print bulk   -- 打印: {"second", "third", "fourth"}
+print last   -- 打印: last
+</pre>
+</YueDisplay>
 
-解构也可以出现在其它隐式进行赋值的地方。一个例子是用在for循环：
+展开运算符可以用在不同的位置来捕获不同的范围，并且你可以使用 `_` 作为占位符来表示你想跳过对应范围的捕获：
+
+```moonscript
+-- 捕获第一个元素之后的所有元素
+[first, ...rest] = orders
+
+-- 捕获最后一个元素之前的所有元素
+[...start, last] = orders
+
+-- 跳过中间的元素，只捕获第一个和最后一个元素
+[first, ..._, last] = orders
+```
+<YueDisplay>
+<pre>
+-- 捕获第一个元素之后的所有元素
+[first, ...rest] = orders
+
+-- 捕获最后一个元素之前的所有元素
+[...start, last] = orders
+
+-- 跳过中间的元素，只捕获第一个和最后一个元素
+[first, ..._, last] = orders
+</pre>
+</YueDisplay>
+
+### 在其它地方的解构赋值
+
+解构赋值也可以出现在其它隐式进行赋值的地方。一个例子是用在 for 循环中：
 
 ```moonscript
 tuples = [
@@ -1290,7 +1438,7 @@ for [left, right] in *tuples
 </pre>
 </YueDisplay>
 
-我们知道数组表中的每个元素都是一个两项的元组，所以我们可以直接在for语句的名称子句中使用解构来解包它。
+我们知道数组表中的每个元素都是一个两项的元组，所以我们可以直接在 for 语句的名称子句中使用解构来解包它。
 
 ## If 赋值
 
@@ -1358,7 +1506,7 @@ while byte := stream\read_one!
 
 ## 可变参数赋值
 
-你可以将函数返回的结果赋值给一个可变参数符号 `...`。然后使用Lua的方式访问其内容。
+你可以将函数返回的结果赋值给一个可变参数符号 `...`。然后使用 Lua 的方式访问其内容。
 ```moonscript
 list = [1, 2, 3, 4, 5]
 fn = (ok) -> ok, table.unpack list
@@ -1435,7 +1583,7 @@ func --[[端口]] 3000, --[[ip]] "192.168.1.1"
 
 ## 错误处理
 
-用于统一进行Lua错误处理的便捷语法。
+用于统一进行 Lua 错误处理的便捷语法。
 
 ```moonscript
 try
@@ -1494,9 +1642,50 @@ catch err
 </pre>
 </YueDisplay>
 
+### 错误处理简化
+
+`try?` 是 `try` 的功能简化语法，它不再返回 `try` 语句的布尔状态，并在成功时直接返回 `try` 代码块的结果，失败时返回 `nil` 值而非错误对象。
+
+```moonscript
+a, b, c = try? func!
+
+-- 与空值合并运算符一起使用
+a = (try? func!) ?? "default"
+
+-- 作为函数参数
+f try? func!
+
+-- 带 catch 块的 try!
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+<YueDisplay>
+<pre>
+a, b, c = try? func!
+
+-- 与空值合并运算符一起使用
+a = (try? func!) ?? "default"
+
+-- 作为函数参数
+f try? func!
+
+-- 带 catch 块的 try!
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+</pre>
+</YueDisplay>
+
 ## 属性
 
-月之脚本现在提供了Lua 5.4新增的叫做属性的语法支持。在月之脚本编译到的Lua目标版本低于5.4时，你仍然可以同时使用`const`和`close`的属性声明语法，并获得常量检查和作用域回调的功能。
+月之脚本现在提供了 Lua 5.4 新增的叫做属性的语法支持。在月之脚本编译到的 Lua 目标版本低于 5.4 时，你仍然可以同时使用`const` 和 `close` 的属性声明语法，并获得常量检查和作用域回调的功能。
 
 ```moonscript
 const a = 123
@@ -1537,9 +1726,9 @@ global const Constant = 123
 
 ## 字面量
 
-Lua中的所有基本字面量都可以在月之脚本中使用。包括数字、字符串、布尔值和**nil**。
+Lua 中的所有基本字面量都可以在月之脚本中使用。包括数字、字符串、布尔值和 **nil**。
 
-但与Lua不同的是，单引号和双引号字符串内部允许有换行：
+但与 Lua 不同的是，单引号和双引号字符串内部允许有换行：
 
 ```moonscript
 some_string = "这是一个字符串
@@ -1574,6 +1763,66 @@ binary = 0B10011
 <pre>
 integer = 1_000_000
 hex = 0xEF_BB_BF
+binary = 0B10011
+</pre>
+</YueDisplay>
+
+### YAML 风格字符串
+
+使用 `|` 前缀标记一个多行 YAML 风格字符串：
+
+```moonscript
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+<YueDisplay>
+<pre>
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+</pre>
+</YueDisplay>
+
+其效果类似于原生 Lua 的多行拼接，所有文本（含换行）将被保留下来，并支持 `#{...}` 语法，通过 `tostring(expr)` 插入表达式结果。
+
+YAML 风格的多行字符串会自动检测首行后最小的公共缩进，并从所有行中删除该前缀空白字符。这让你可以在代码中对齐文本，但输出字符串不会带多余缩进。
+
+```moonscript
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+<YueDisplay>
+<pre>
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+</pre>
+</YueDisplay>
+
+输出字符串中的 foo: 对齐到行首，不会带有函数缩进空格。保留内部缩进的相对结构，适合书写结构化嵌套样式的内容。
+
+支持自动处理字符中的引号、反斜杠等特殊符号，无需手动转义：
+
+```moonscript
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
+```
+<YueDisplay>
+<pre>
+str = |
+  path: "C:\Program Files\App"
+  note: 'He said: "#{Hello}!"'
 </pre>
 </YueDisplay>
 
@@ -1678,7 +1927,7 @@ print "数字的和是", sum 10, 20
 </pre>
 </YueDisplay>
 
-如果你需要做显式返回，可以使用return关键字：
+如果你需要做显式返回，可以使用 return 关键字：
 
 ```moonscript
 sum = (x, y) -> return x + y
@@ -1704,7 +1953,7 @@ a, b = mystery 10, 20
 
 ### 粗箭头
 
-因为在Lua中调用方法时，经常习惯将对象作为第一个参数传入，所以月之脚本提供了一种特殊的语法来创建自动包含self参数的函数。
+因为在 Lua 中调用方法时，经常习惯将对象作为第一个参数传入，所以月之脚本提供了一种特殊的语法来创建自动包含 self 参数的函数。
 
 ```moonscript
 func = (num) => @value + num
@@ -1717,7 +1966,7 @@ func = (num) => @value + num
 
 ### 参数默认值
 
-可以为函数的参数提供默认值。如果参数的值为nil，则确定该参数为空。任何具有默认值的nil参数在函数体运行之前都会被替换。
+可以为函数的参数提供默认值。如果参数的值为 nil，则确定该参数为空。任何具有默认值的 nil 参数在函数体运行之前都会被替换。
 
 ```moonscript
 my_function = (name = "某物", height = 100) ->
@@ -1789,7 +2038,7 @@ my_func 5, 6, 7,
 </pre>
 </YueDisplay>
 
-因为Lua表也使用逗号作为分隔符，这种缩进语法有助于让值成为参数列表的一部分，而不是Lua表的一部分。
+因为 Lua 表也使用逗号作为分隔符，这种缩进语法有助于让值成为参数列表的一部分，而不是 Lua 表的一部分。
 
 ```moonscript
 x = [
@@ -1856,6 +2105,138 @@ if func 1, 2, 3,
 </pre>
 </YueDisplay>
 
+### 参数解构
+
+月之脚本支持在函数形参位置对传入对象进行解构。适用两类解构表子面量：
+
+- 使用 {} 包裹的字面量/对象形参，支持提供获得空字段时的默认值（例如 {:a, :b}、{a: a1 = 123}）。
+
+- 无 {} 包裹、以键值/简写键序列开头，直至遇到其它表达式终止（例如 :a, b: b1, :c），表示从同一个对象中解构多个字段。
+
+```moonscript
+f1 = (:a, :b, :c) ->
+  print a, b, c
+
+f1 a: 1, b: "2", c: {}
+
+f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
+  print a1, b, c
+
+arg1 = {a: 0}
+f2 arg1, arg2
+```
+<YueDisplay>
+<pre>
+f1 = (:a, :b, :c) ->
+  print a, b, c
+
+f1 a: 1, b: "2", c: {}
+
+f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
+  print a1, b, c
+
+arg1 = {a: 0}
+f2 arg1, arg2
+</pre>
+</YueDisplay>
+
+### 前置返回表达式
+
+在深度嵌套的函数体中，为了提升返回值的可读性及编写便利性，我们新增了 “前置返回表达式” 语法。其形式如下：
+
+```moon
+findFirstEven = (list): nil ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+```
+<YueDisplay>
+<pre>
+findFirstEven = (list): nil ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+</pre>
+</YueDisplay>
+
+这个写法等价于：
+
+```moon
+findFirstEven = (list) ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+  nil
+```
+<YueDisplay>
+<pre>
+findFirstEven = (list) ->
+  for item in *list
+    if type(item) == "table"
+      for sub in *item
+        if sub % 2 == 0
+          return sub
+  nil
+</pre>
+</YueDisplay>
+
+唯一的区别在于：你可以将函数的返回值表达式提前写在 `->` 或 `=>` 前，用以指示该函数应隐式返回该表达式的值。这样即使在多层循环或条件判断的场景下，也无需编写尾行悬挂的返回表达式，逻辑结构会更加直观清晰。
+
+### 命名变长参数
+
+你可以使用 `(...t) ->` 语法来将变长参数自动存储到一个命名表中。这个表会包含所有传入的参数（包括 `nil` 值），并且会在表的 `n` 字段中存储实际传入的参数个数（包括 `nil` 值在内的个数）。
+
+```moonscript
+f = (...t) ->
+  print "参数个数:", t.n
+  print "表长度:", #t
+  for i = 1, t.n
+    print t[i]
+
+f 1, 2, 3
+f "a", "b", "c", "d"
+f!
+
+-- 处理包含 nil 的情况
+process = (...args) ->
+  sum = 0
+  for i = 1, args.n
+    if args[i] != nil and type(args[i]) == "number"
+      sum += args[i]
+  sum
+
+process 1, nil, 3, nil, 5
+```
+<YueDisplay>
+<pre>
+f = (...t) ->
+  print "参数个数:", t.n
+  print "表长度:", #t
+  for i = 1, t.n
+    print t[i]
+
+f 1, 2, 3
+f "a", "b", "c", "d"
+f!
+
+-- 处理包含 nil 的情况
+process = (...args) ->
+  sum = 0
+  for i = 1, args.n
+    if args[i] != nil and type(args[i]) == "number"
+      sum += args[i]
+  sum
+
+process 1, nil, 3, nil, 5
+</pre>
+</YueDisplay>
+
 ## 反向回调
 
 反向回调用于减少函数回调的嵌套。它们使用指向左侧的箭头，并且默认会被定义为传入后续函数调用的最后一个参数。它的语法大部分与常规箭头函数相同，只是它指向另一方向，并且后续的函数体不需要进行缩进。
@@ -1920,7 +2301,7 @@ print result, msg
 
 ## 表格字面量
 
-和Lua一样，表格可以通过花括号进行定义。
+和 Lua 一样，表格可以通过花括号进行定义。
 
 ```moonscript
 some_values = [1, 2, 3, 4]
@@ -2003,7 +2384,7 @@ y = type: "狗", legs: 4, tails: 1
 </pre>
 </YueDisplay>
 
-表格字面量的键可以使用Lua语言的关键字，而无需转义：
+表格字面量的键可以使用 Lua 语言的关键字，而无需转义：
 
 ```moonscript
 tbl = {
@@ -2039,7 +2420,7 @@ print_table :hair, :height
 </pre>
 </YueDisplay>
 
-如果你希望表中字段的键是某个表达式的结果，那么可以用 **[ ]** 包裹它，就像在Lua中一样。如果键中有任何特殊字符，也可以直接使用字符串字面量作为键，省略方括号。
+如果你希望表中字段的键是某个表达式的结果，那么可以用 **[ ]** 包裹它，就像在 Lua 中一样。如果键中有任何特殊字符，也可以直接使用字符串字面量作为键，省略方括号。
 
 ```moonscript
 t = {
@@ -2056,7 +2437,7 @@ t = {
 </pre>
 </YueDisplay>
 
-Lua的表同时具有数组部分和哈希部分，但有时候你会希望在书写Lua表时，对Lua表做数组和哈希不同用法的语义区分。然后你可以用 **[ ]** 而不是 **{ }** 来编写表示数组的 Lua 表，并且不允许在数组 Lua 表中写入任何键值对。
+Lua 的表同时具有数组部分和哈希部分，但有时候你会希望在书写 Lua 表时，对 Lua 表做数组和哈希不同用法的语义区分。然后你可以用 **[ ]** 而不是 **{ }** 来编写表示数组的 Lua 表，并且不允许在数组 Lua 表中写入任何键值对。
 
 ```moonscript
 some_values = [ 1, 2, 3, 4 ]
@@ -2071,11 +2452,11 @@ list_with_one_element = [ 1, ]
 
 ## 推导式
 
-推导式为我们提供了一种便捷的语法，通过遍历现有对象并对其值应用表达式来构造出新的表格。月之脚本有两种推导式：列表推导式和表格推导式。它们最终都是产生Lua表格；列表推导式将值累积到类似数组的表格中，而表格推导式允许你在每次遍历时设置新表格的键和值。
+推导式为我们提供了一种便捷的语法，通过遍历现有对象并对其值应用表达式来构造出新的表格。月之脚本有两种推导式：列表推导式和表格推导式。它们最终都是产生 Lua 表格；列表推导式将值累积到类似数组的表格中，而表格推导式允许你在每次遍历时设置新表格的键和值。
 
 ### 列表推导式
 
-以下操作创建了一个items表的副本，但所有包含的值都翻倍了。
+以下操作创建了一个 items 表的副本，但所有包含的值都翻倍了。
 
 ```moonscript
 items = [1, 2, 3, 4]
@@ -2088,7 +2469,7 @@ doubled = [item * 2 for i, item in ipairs items]
 </pre>
 </YueDisplay>
 
-可以使用when子句筛选新表中包含的项目：
+可以使用 `when` 子句筛选新表中包含的项目：
 
 ```moonscript
 slice = [item for i, item in ipairs items when i > 1 and i < 3]
@@ -2099,7 +2480,7 @@ slice = [item for i, item in ipairs items when i > 1 and i < 3]
 </pre>
 </YueDisplay>
 
-因为我们常常需要迭代数值索引表的值，所以引入了 **\*** 操作符来做语法简化。doubled示例可以重写为：
+因为我们常常需要迭代数值索引表的值，所以引入了 **\*** 操作符来做语法简化。doubled 示例可以重写为：
 
 ```moonscript
 doubled = [item * 2 for item in *items]
@@ -2110,9 +2491,30 @@ doubled = [item * 2 for item in *items]
 </pre>
 </YueDisplay>
 
-for和when子句可以根据需要进行链式操作。唯一的要求是推导式中至少要有一个for子句。
+在列表推导式中，你还可以使用展开操作符 `...` 来实现对列表嵌套层级进行扁平化的处理：
+
+```moonscript
+data =
+  a: [1, 2, 3]
+  b: [4, 5, 6]
+
+flat = [...v for k,v in pairs data]
+-- flat 现在为 [1, 2, 3, 4, 5, 6]
+```
+<YueDisplay>
+<pre>
+data =
+  a: [1, 2, 3]
+  b: [4, 5, 6]
+
+flat = [...v for k,v in pairs data]
+-- flat 现在为 [1, 2, 3, 4, 5, 6]
+</pre>
+</YueDisplay>
+
+for 和 when 子句可以根据需要进行链式操作。唯一的要求是推导式中至少要有一个 for 子句。
 
-使用多个for子句与使用多重循环的效果相同：
+使用多个 for 子句与使用多重循环的效果相同：
 
 ```moonscript
 x_coords = [4, 5, 6, 7]
@@ -2131,7 +2533,7 @@ for y in *y_coords]
 </pre>
 </YueDisplay>
 
-在推导式中也可以使用简单的数值for循环：
+在推导式中也可以使用简单的数值 for 循环：
 
 ```moonscript
 evens = [i for i = 1, 100 when i % 2 == 0]
@@ -2146,7 +2548,7 @@ evens = [i for i = 1, 100 when i % 2 == 0]
 
 表格推导式和列表推导式的语法非常相似，只是要使用 **{** 和 **}** 并从每次迭代中取两个值。
 
-以下示例生成了表格thing的副本：
+以下示例生成了表格 thing 的副本：
 
 ```moonscript
 thing = {
@@ -2208,9 +2610,9 @@ tbl = {unpack tuple for tuple in *tuples}
 
 ### 切片
 
-当使用 **\*** 操作符时，月之脚本还提供了一种特殊的语法来限制要遍历的列表范围。这个语法也相当于在for循环中设置迭代边界和步长。
+当使用 **\*** 操作符时，月之脚本还提供了一种特殊的语法来限制要遍历的列表范围。这个语法也相当于在 for 循环中设置迭代边界和步长。
 
-下面的案例中，我们在切片中设置最小和最大边界，取索引在1到5之间（包括1和5）的所有项目：
+下面的案例中，我们在切片中设置最小和最大边界，取索引在 1 到 5 之间（包括 1 和 5）的所有项目：
 
 ```moonscript
 slice = [item for item in *items[1, 5]]
@@ -2232,7 +2634,7 @@ slice = [item for item in *items[2,]]
 </pre>
 </YueDisplay>
 
-如果省略了最小边界，便默认会设置为1。这里我们只提供一个步长，并留下其他边界为空。这样会使得代码取出所有奇数索引的项目：(1, 3, 5, …)
+如果省略了最小边界，便默认会设置为 1。这里我们只提供一个步长，并留下其他边界为空。这样会使得代码取出所有奇数索引的项目：(1, 3, 5, …)
 
 ```moonscript
 slice = [item for item in *items[,,2]]
@@ -2244,9 +2646,48 @@ slice = [item for item in *items[,,2]]
 </pre>
 </YueDisplay>
 
+最小和最大边界都可以是负数，使用负数意味着边界是从表的末尾开始计算的。
+
+```moonscript
+-- 取最后4个元素
+slice = [item for item in *items[-4,-1]]
+```
+<YueDisplay>
+<pre>
+-- 取最后4个元素
+slice = [item for item in *items[-4,-1]]
+</pre>
+</YueDisplay>
+
+切片的步长也可以是负数，这意味着元素会以相反的顺序被取出。
+
+```moonscript
+reverse_slice = [item for item in *items[-1,1,-1]]
+```
+<YueDisplay>
+<pre>
+reverse_slice = [item for item in *items[-1,1,-1]]
+</pre>
+</YueDisplay>
+
+#### 切片表达式
+
+切片也可以作为表达式来使用。可以用于获取一个表包含的子列表。
+
+```moonscript
+-- 取第2和第4个元素作为新的列表
+sub_list = items[2, 4]
+```
+<YueDisplay>
+<pre>
+-- 取第2和第4个元素作为新的列表
+sub_list = items[2, 4]
+</pre>
+</YueDisplay>
+
 ## for 循环
 
-Lua中有两种for循环形式，数字型和通用型：
+Lua 中有两种 for 循环形式，数字型和通用型：
 
 ```moonscript
 for i = 10, 20
@@ -2299,7 +2740,7 @@ for j = 1, 10, 3 do print j
 </pre>
 </YueDisplay>
 
-for循环也可以用作表达式。for循环主体中的最后一条语句会被强制转换为一个返回值的表达式，并会将表达式计算结果的值追加到一个作为结果的数组表中。
+for 循环也可以用作表达式。for 循环主体中的最后一条语句会被强制转换为一个返回值的表达式，并会将表达式计算结果的值追加到一个作为结果的数组表中。
 
 将每个偶数加倍：
 
@@ -2320,9 +2761,9 @@ doubled_evens = for i = 1, 20
 </pre>
 </YueDisplay>
 
-此外，for循环还支持带返回值的break语句，这样循环本身就可以作为一个表达式，在满足条件时提前退出并返回有意义的结果。
+此外，for 循环还支持带返回值的 break 语句，这样循环本身就可以作为一个表达式，在满足条件时提前退出并返回有意义的结果。
 
-例如，查找第一个大于10的数字：
+例如，查找第一个大于 10 的数字：
 
 ```moonscript
 first_large = for n in *numbers
@@ -2335,9 +2776,9 @@ first_large = for n in *numbers
 </pre>
 </YueDisplay>
 
-你还可以结合for循环表达式与continue语句来过滤值。
+你还可以结合 for 循环表达式与 continue 语句来过滤值。
 
-注意出现在函数体末尾的for循环，不会被当作是一个表达式并将循环结果累积到一个列表中作为返回值（相反，函数将返回nil）。如果要函数末尾的循环转换为列表表达式，可以显式地使用返回语句加for循环表达式。
+注意出现在函数体末尾的 for 循环，不会被当作是一个表达式并将循环结果累积到一个列表中作为返回值（相反，函数将返回 nil）。如果要函数末尾的循环转换为列表表达式，可以显式地使用返回语句加 for 循环表达式。
 
 ```moonscript
 func_a = -> for i = 1, 10 do print i
@@ -2360,7 +2801,7 @@ print func_b! -- 打印 table 对象
 
 ## repeat 循环
 
-repeat循环是从Lua语言中搬过来的相似语法：
+repeat 循环是从 Lua 语言中搬过来的相似语法：
 
 ```moonscript
 i = 10
@@ -2381,7 +2822,7 @@ until i == 0
 
 ## while 循环
 
-在月之脚本中的while循环有四种写法：
+在月之脚本中的 while 循环有四种写法：
 
 ```moonscript
 i = 10
@@ -2420,7 +2861,7 @@ until running == false do my_function!
 </pre>
 </YueDisplay>
 
-像for循环的语法一样，while循环也可以作为一个表达式使用。为了使函数返回while循环的累积列表值，必须明确使用返回语句返回while循环表达式。
+像 for 循环的语法一样，while 循环也可以作为一个表达式使用。为了使函数返回 while 循环的累积列表值，必须明确使用返回语句返回 while 循环表达式。
 
 ## 继续
 
@@ -2538,13 +2979,14 @@ print message -- 打印: 我很高
 </pre>
 </YueDisplay>
 
-if的反义词是unless（相当于if not，如果 vs 除非）：
+if 的反义词是 unless（相当于 if not，正如“如果”对应“除非”）：
 
 ```moonscript
 unless os.date("%A") == "Monday"
   print "今天不是星期一！"
 ```
 <YueDisplay>
+
 <pre>
 unless os.date("%A") == "Monday"
   print "今天不是星期一！"
@@ -2596,7 +3038,7 @@ print "你很幸运!" unless math.random! > 0.1
 
 ## 代码行修饰符
 
-为了方便编写代码，循环语句和if语句可以应用于单行代码语句的末尾：
+为了方便编写代码，循环语句和 if 语句可以应用于单行代码语句的末尾：
 
 ```moonscript
 print "你好，世界" if name == "Rob"
@@ -2607,7 +3049,7 @@ print "你好，世界" if name == "Rob"
 </pre>
 </YueDisplay>
 
-修饰for循环的示例：
+修饰 for 循环的示例：
 
 ```moonscript
 print "项目: ", item for item in *items
@@ -2618,7 +3060,7 @@ print "项目: ", item for item in *items
 </pre>
 </YueDisplay>
 
-修饰while循环的示例：
+修饰 while 循环的示例：
 
 ```moonscript
 game\update! while game\isRunning!
@@ -2635,34 +3077,32 @@ reader\parse_line! until reader\eof!
 
 ## switch 语句
 
-switch语句是为了简化检查一系列相同值的if语句而提供的简写语法。要注意用于比较检查的目标值只会计算一次。和if语句一样，switch语句在最后可以接一个else代码块来处理没有匹配的情况。在生成的Lua代码中，进行比较是使用==操作符完成的。
+switch 语句是为了简化检查一系列相同值的if语句而提供的简写语法。要注意用于比较检查的目标值只会计算一次。和 if 语句一样，switch 语句在最后可以接一个 else 代码块来处理没有匹配的情况。在生成的 Lua 代码中，进行比较是使用 == 操作符完成的。switch 语句中也可以使用赋值表达式来储存临时变量值。
 
 ```moonscript
-name = "Dan"
-switch name
+switch name := "Dan"
   when "Robert"
     print "你是Robert"
   when "Dan", "Daniel"
     print "你的名字是Dan"
   else
-    print "我不知道你的名字"
+    print "我不认识你，你的名字是#{name}"
 ```
 <YueDisplay>
 <pre>
-name = "Dan"
-switch name
+switch name := "Dan"
   when "Robert"
     print "你是Robert"
   when "Dan", "Daniel"
     print "你的名字是Dan"
   else
-    print "我不知道你的名字"
+    print "我不认识你，你的名字是#{name}"
 </pre>
 </YueDisplay>
 
-switch语句的when子句中可以通过使用逗号分隔的列表来匹配多个值。
+switch 语句的 when 子句中可以通过使用逗号分隔的列表来匹配多个值。
 
-switch语句也可以作为表达式使用，下面我们可以将switch语句返回的结果分配给一个变量：
+switch 语句也可以作为表达式使用，下面我们可以将 switch 语句返回的结果分配给一个变量：
 
 ```moonscript
 b = 1
@@ -2687,7 +3127,7 @@ next_number = switch b
 </pre>
 </YueDisplay>
 
-我们可以使用then关键字在when子句的同一行上编写处理代码。else代码块的后续代码中要写在同一行上不需要额外的关键字。
+我们可以使用 then 关键字在 when 子句的同一行上编写处理代码。else 代码块的后续代码中要写在同一行上不需要额外的关键字。
 
 ```moonscript
 msg = switch math.random(1, 5)
@@ -2704,7 +3144,7 @@ msg = switch math.random(1, 5)
 </pre>
 </YueDisplay>
 
-如果在编写switch语句时希望少写一个缩进，那么你可以把第一个when子句放在switch开始语句的第一行，然后后续的子语句就都可以都少写一个缩进。
+如果在编写 switch 语句时希望少写一个缩进，那么你可以把第一个 when 子句放在 switch 开始语句的第一行，然后后续的子语句就都可以都少写一个缩进。
 
 ```moonscript
 switch math.random(1, 5)
@@ -2733,11 +3173,11 @@ else
 </pre>
 </YueDisplay>
 
-值得注意的是，在生成Lua代码时，我们要做检查的目标变量会放在==表达式的右侧。当你希望给when子句的比较对象定义一个\_\_eq元方法来重载判断逻辑时，可能会有用。
+值得注意的是，在生成 Lua 代码时，我们要做检查的目标变量会放在 == 表达式的右侧。当你希望给 when 子句的比较对象定义一个 \_\_eq 元方法来重载判断逻辑时，可能会有用。
 
 ### 表格匹配
 
-在switch的when子句中，如果期待检查目标是一个表格，且可以通过特定的结构进行解构并获得非nil值，那么你可以尝试使用表格匹配的语法。
+在 switch 的 when 子句中，如果期待检查目标是一个表格，且可以通过特定的结构进行解构并获得非 nil 值，那么你可以尝试使用表格匹配的语法。
 
 ```moonscript
 items =
@@ -2889,9 +3329,30 @@ switch tb
 </pre>
 </YueDisplay>
 
+匹配一个列表并捕获特定范围内的元素。
+
+```moonscript
+segments = ["admin", "users", "logs", "view"]
+switch segments
+  when [...groups, resource, action]
+    print "Group:", groups -- 打印: {"admin", "users"}
+    print "Resource:", resource -- 打印: "logs"
+    print "Action:", action -- 打印: "view"
+```
+<YueDisplay>
+<pre>
+segments = ["admin", "users", "logs", "view"]
+switch segments
+  when [...groups, resource, action]
+    print "Group:", groups -- 打印: {"admin", "users"}
+    print "Resource:", resource -- 打印: "logs"
+    print "Action:", action -- 打印: "view"
+</pre>
+</YueDisplay>
+
 ## 面向对象编程
 
-在以下的示例中，月之脚本生成的Lua代码可能看起来会很复杂。所以最好主要关注月之脚本代码层面的意义，然后如果你想知道关于面向对象功能的实现细节，再查看Lua代码。
+在以下的示例中，月之脚本生成的 Lua 代码可能看起来会很复杂。所以最好主要关注月之脚本代码层面的意义，然后如果你想知道关于面向对象功能的实现细节，再查看 Lua 代码。
 
 一个简单的类：
 
@@ -2920,11 +3381,11 @@ class Inventory
 </pre>
 </YueDisplay>
 
-在月之脚本中采用面向对象的编程方式时，通常会使用类声明语句结合Lua表格字面量来做类定义。这个类的定义包含了它的所有方法和属性。在这种结构中，键名为“new”的成员扮演了一个重要的角色，是作为构造函数来使用。
+在月之脚本中采用面向对象的编程方式时，通常会使用类声明语句结合 Lua 表格字面量来做类定义。这个类的定义包含了它的所有方法和属性。在这种结构中，键名为 “new” 的成员扮演了一个重要的角色，是作为构造函数来使用。
 
-值得注意的是，类中的方法都采用了粗箭头函数语法。当在类的实例上调用方法时，该实例会自动作为第一个参数被传入，因此粗箭头函数用于生成一个名为“self”的参数。
+值得注意的是，类中的方法都采用了粗箭头函数语法。当在类的实例上调用方法时，该实例会自动作为第一个参数被传入，因此粗箭头函数用于生成一个名为 “self” 的参数。
 
-此外，“@”前缀在变量名上起到了简化作用，代表“self”。例如，`@items` 就等同于 `self.items`。
+此外，“@” 前缀在变量名上起到了简化作用，代表 “self”。例如，`@items` 就等同于 `self.items`。
 
 为了创建类的一个新实例，可以将类名当作一个函数来调用，这样就可以生成并返回一个新的实例。
 
@@ -2946,7 +3407,7 @@ inv\add_item "pants"
 
 需要特别注意的是，类的所有属性在其实例之间是共享的。这对于函数类型的成员属性通常不会造成问题，但对于其他类型的属性，可能会导致意外的结果。
 
-例如，在下面的示例中，clothes属性在所有实例之间共享。因此，对这个属性在一个实例中的修改，将会影响到其他所有实例。
+例如，在下面的示例中，clothes 属性在所有实例之间共享。因此，对这个属性在一个实例中的修改，将会影响到其他所有实例。
 
 ```moonscript
 class Person
@@ -2998,7 +3459,7 @@ class Person
 
 ### 继承
 
-`extends`关键字可以在类声明中使用，以继承另一个类的属性和方法。
+`extends` 关键字可以在类声明中使用，以继承另一个类的属性和方法。
 
 ```moonscript
 class BackPack extends Inventory
@@ -3018,11 +3479,11 @@ class BackPack extends Inventory
 </YueDisplay>
 
 
-在这一部分，我们对月之脚本中的`Inventory`类进行了扩展，加入了对可以携带物品数量的限制。
+在这一部分，我们对月之脚本中的 `Inventory` 类进行了扩展，加入了对可以携带物品数量的限制。
 
-在这个特定的例子中，子类并没有定义自己的构造函数。因此，当创建一个新的实例时，系统会默认调用父类的构造函数。但如果我们在子类中定义了构造函数，我们可以利用`super`方法来调用并执行父类的构造函数。
+在这个特定的例子中，子类并没有定义自己的构造函数。因此，当创建一个新的实例时，系统会默认调用父类的构造函数。但如果我们在子类中定义了构造函数，我们可以利用 `super` 方法来调用并执行父类的构造函数。
 
-此外，当一个类继承自另一个类时，它会尝试调用父类上的`__inherited`方法（如果这个方法存在的话），以此来向父类发送通知。这个`__inherited`函数接受两个参数：被继承的父类和继承的子类。
+此外，当一个类继承自另一个类时，它会尝试调用父类上的 `__inherited` 方法（如果这个方法存在的话），以此来向父类发送通知。这个 `__inherited` 函数接受两个参数：被继承的父类和继承的子类。
 
 ```moonscript
 class Shelf
@@ -3045,15 +3506,15 @@ class Cupboard extends Shelf
 
 ### super 关键字
 
-`super`是一个特别的关键字，它有两种不同的使用方式：既可以当作一个对象来看待，也可以像调用函数那样使用。它仅在类的内部使用时具有特殊的功能。
+`super` 是一个特别的关键字，它有两种不同的使用方式：既可以当作一个对象来看待，也可以像调用函数那样使用。它仅在类的内部使用时具有特殊的功能。
 
-当`super`被作为一个函数调用时，它将调用父类中与之同名的函数。此时，当前的`self`会自动作为第一个参数传递，正如上面提到的继承示例所展示的那样。
+当 `super` 被作为一个函数调用时，它将调用父类中与之同名的函数。此时，当前的 `self` 会自动作为第一个参数传递，正如上面提到的继承示例所展示的那样。
 
-在将`super`当作普通值使用时，它实际上是对父类对象的引用。通过这种方式，我们可以访问父类中可能被子类覆盖的值，就像访问任何普通对象一样。
+在将 `super` 当作普通值使用时，它实际上是对父类对象的引用。通过这种方式，我们可以访问父类中可能被子类覆盖的值，就像访问任何普通对象一样。
 
-此外，当使用`\`操作符与`super`一起使用时，`self`将被插入为第一个参数，而不是使用`super`本身的值。而在使用`.`操作符来检索函数时，则会返回父类中的原始函数。
+此外，当使用 `\` 操作符与 `super` 一起使用时，`self`将被插入为第一个参数，而不是使用 `super` 本身的值。而在使用`.`操作符来检索函数时，则会返回父类中的原始函数。
 
-下面是一些使用`super`的不同方法的示例：
+下面是一些使用 `super` 的不同方法的示例：
 
 ```moonscript
 class MyClass extends ParentClass
@@ -3112,9 +3573,9 @@ print BackPack.size -- 打印 10
 
 如果在类对象的元表中找不到某个属性，系统会从基表中检索该属性。这就意味着我们可以直接从类本身访问到其方法和属性。
 
-需要特别注意的是，对类对象的赋值并不会影响到基表，因此这不是向实例添加新方法的正确方式。相反，需要直接修改基表。关于这点，可以参考下面的“__base”字段。
+需要特别注意的是，对类对象的赋值并不会影响到基表，因此这不是向实例添加新方法的正确方式。相反，需要直接修改基表。关于这点，可以参考下面的 “__base” 字段。
 
-此外，类对象包含几个特殊的属性：当类被声明时，类的名称会作为一个字符串存储在类对象的“__name”字段中。
+此外，类对象包含几个特殊的属性：当类被声明时，类的名称会作为一个字符串存储在类对象的 “__name” 字段中。
 
 ```moonscript
 print BackPack.__name -- 打印 Backpack
@@ -3196,7 +3657,7 @@ print Counter.count -- 输出 2
 
 ### 类声明语句
 
-在类声明的主体中，除了键/值对外，我们还可以编写普通的表达式。在这种类声明体中的普通代码的上下文中，self等于类对象，而不是实例对象。
+在类声明的主体中，除了键/值对外，我们还可以编写普通的表达式。在这种类声明体中的普通代码的上下文中，self 等于类对象，而不是实例对象。
 
 以下是创建类变量的另一种方法：
 
@@ -3236,9 +3697,9 @@ class MoreThings
 
 ### @ 和 @@ 值
 
-当@和@@前缀在一个名字前时，它们分别代表在self和self.\_\_class中访问的那个名字。
+当 @ 和 @@ 前缀在一个名字前时，它们分别代表在 self 和 self.\_\_class 中访问的那个名字。
 
-如果它们单独使用，它们是self和self.\_\_class的别名。
+如果它们单独使用，它们是 self 和 self.\_\_class 的别名。
 
 ```moonscript
 assert @ == self
@@ -3251,7 +3712,7 @@ assert @@ == self.__class
 </pre>
 </YueDisplay>
 
-例如，使用@@从实例方法快速创建同一类的新实例的方法：
+例如，使用 @@ 从实例方法快速创建同一类的新实例的方法：
 
 ```moonscript
 some_instance_method = (...) => @@ ...
@@ -3329,7 +3790,7 @@ x = class Bucket
 
 ### 匿名类
 
-声明类时可以省略名称。如果类的表达式不在赋值语句中，\_\_name属性将为nil。如果出现在赋值语句中，赋值操作左侧的名称将代替nil。
+声明类时可以省略名称。如果类的表达式不在赋值语句中，\_\_name 属性将为 nil。如果出现在赋值语句中，赋值操作左侧的名称将代替 nil。
 
 ```moonscript
 BigBucket = class extends Bucket
@@ -3400,11 +3861,11 @@ assert y.__class.__parent ~= X -- X 不是 Y 的父类
 
 ## with 语句
 
-在编写Lua代码时，我们在创建对象后的常见操作是立即调用这个对象一系列操作函数并设置一系列属性。
+在编写 Lua 代码时，我们在创建对象后的常见操作是立即调用这个对象一系列操作函数并设置一系列属性。
 
 这导致在代码中多次重复引用对象的名称，增加了不必要的文本噪音。一个常见的解决方案是在创建对象时，在构造函数传入一个表，该表包含要覆盖设置的键和值的集合。这样做的缺点是该对象的构造函数必须支持这种初始化形式。
 
-with块有助于简化编写这样的代码。在with块内，我们可以使用以.或\开头的特殊语句，这些语句代表我们正在使用的对象的操作。
+with 块有助于简化编写这样的代码。在 with 块内，我们可以使用以 . 或 \ 开头的特殊语句，这些语句代表我们正在使用的对象的操作。
 
 例如，我们可以这样处理一个新创建的对象：
 
@@ -3425,7 +3886,7 @@ with Person!
 </pre>
 </YueDisplay>
 
-with语句也可以用作一个表达式，并返回它的代码块正在处理的对象。
+with 语句也可以用作一个表达式，并返回它的代码块正在处理的对象。
 
 ```moonscript
 file = with File "favorite_foods.txt"
@@ -3459,24 +3920,24 @@ me = create_person "Leaf", [dad, mother, sister]
 </pre>
 </YueDisplay>
 
-在此用法中，with可以被视为K组合子（k-combinator）的一种特殊形式。
+在此用法中，with 可以被视为K组合子（k-combinator）的一种特殊形式。
 
-如果你想给表达式另外起一个名称的话，with语句中的表达式也可以是一个赋值语句。
+如果你想给表达式另外起一个名称的话，with 语句中的表达式也可以是一个赋值语句。
 
 ```moonscript
-with str = "你好"
+with str := "你好"
   print "原始:", str
   print "大写:", \upper!
 ```
 <YueDisplay>
 <pre>
-with str = "你好"
+with str := "你好"
   print "原始:", str
   print "大写:", \upper!
 </pre>
 </YueDisplay>
 
-在with语句中可������用`[]`访问特殊键。
+你���以��� `with` 语句中使用 `[]` 访问特殊键。
 
 ```moonscript
 with tb
@@ -3499,9 +3960,22 @@ with tb
 </pre>
 </YueDisplay>
 
+`with?` 是 `with` 语法的一个增强版本，引入了存在性检查，用于在不显式判空的情况下安全访问可能为 nil 的对象。
+
+```moonscript
+with? obj
+  print obj.name
+```
+<YueDisplay>
+<pre>
+with? obj
+  print obj.name
+</pre>
+</YueDisplay>
+
 ## do 语句
 
-当用作语句时，do语句的作用就像在Lua中差不多。
+当用作语句时，do 语句的作用就像在 Lua 中差不多。
 
 ```moonscript
 do
@@ -3518,7 +3992,7 @@ print var -- 这里是nil
 </pre>
 </YueDisplay>
 
-月之脚本的 **do** 也可以用作表达式。允许你将多行代码的处理合并为一个表达式，并将do语句代码块的最后一个语句作为表达式返回的结果。
+月之脚本的 **do** 也可以用作表达式。允许你将多行代码的处理合并为一个表达式，并将 do 语句代码块的最后一个语句作为表达式返回的结果。
 
 ```moonscript
 counter = do
@@ -3702,7 +4176,7 @@ print i, k -- 这些已经被更新
 
 ## 月之脚本语言库
 
-使用`require("yue")`来访问。
+使用 `require("yue")` 来访问。
 
 ### yue
 
@@ -3760,9 +4234,9 @@ yue_compiled: {string: string}
 **签名：**
 ```lua
 to_lua: function(code: string, config?: Config):
-                --[[codes]] string | nil,
-                --[[error]] string | nil,
-                --[[globals]] {{string, integer, integer}} | nil
+    --[[codes]] string | nil,
+    --[[error]] string | nil,
+    --[[globals]] {{string, integer, integer}} | nil
 ```
 
 **参数：**
@@ -3885,8 +4359,8 @@ remove_loader: function(): boolean
 **签名：**
 ```lua
 loadstring: function(input: string, chunkname: string, env: table, config?: Config):
-                --[[loaded function]] nil | function(...: any): (any...),
-                --[[error]] string | nil
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
 ```
 
 **参数：**
@@ -3916,8 +4390,8 @@ loadstring: function(input: string, chunkname: string, env: table, config?: Conf
 **签名：**
 ```lua
 loadstring: function(input: string, chunkname: string, config?: Config):
-                --[[loaded function]] nil | function(...: any): (any...),
-                --[[error]] string | nil
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
 ```
 
 **参数：**
@@ -3946,8 +4420,8 @@ loadstring: function(input: string, chunkname: string, config?: Config):
 **签名：**
 ```lua
 loadstring: function(input: string, config?: Config):
-                --[[loaded function]] nil | function(...: any): (any...),
-                --[[error]] string | nil
+    --[[loaded function]] nil | function(...: any): (any...),
+    --[[error]] string | nil
 ```
 
 **参数：**
@@ -3975,8 +4449,8 @@ loadstring: function(input: string, config?: Config):
 **签名：**
 ```lua
 loadfile: function(filename: string, env: table, config?: Config):
-                nil | function(...: any): (any...),
-                string | nil
+    nil | function(...: any): (any...),
+    string | nil
 ```
 
 **参数：**
@@ -4005,8 +4479,8 @@ loadfile: function(filename: string, env: table, config?: Config):
 **签名：**
 ```lua
 loadfile: function(filename: string, config?: Config):
-                nil | function(...: any): (any...),
-                string | nil
+    nil | function(...: any): (any...),
+    string | nil
 ```
 
 **参数：**
@@ -4261,9 +4735,9 @@ type AST = {string, integer, integer, any}
 
 **签名：**
 ```lua
-to_ast: function(code: string, flattenLevel?: number, astName?: string):
-                --[[AST]] AST | nil,
-                --[[error]] nil | string
+to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
+    --[[AST]] AST | nil,
+    --[[error]] nil | string
 ```
 
 **参数：**
@@ -4272,6 +4746,42 @@ to_ast: function(code: string, flattenLevel?: number, astName?: string):
 | --- | --- | --- |
 | code | string | 代码。 |
 | flattenLevel | integer | [可选] 扁平化级别。级别越高，会消除更多的 AST 结构的嵌套。默认为 0。最大为 2。 |
+| astName | string | [可选] AST 名称。默认为 "File"。 |
+| reserveComment | boolean | [可选] 是否保留原始注释。默认为 false。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| AST \| nil | AST，如果转换失败则为 nil。 |
+| string \| nil | 错误消息，如果转换成功则为 nil。 |
+
+#### format
+
+**类型：** 函数。
+
+**描述：**
+
+格式化 YueScript 代码。
+
+**签名：**
+```lua
+format: function(code: string, tabSize?: number, reserveComment?: boolean): string
+```
+
+**参数：**
+
+| 参数名 | 类型 | 描述 |
+| --- | --- | --- |
+| code | string | 代码。 |
+| tabSize | integer | [可选] 制表符大小。默认为 4。 |
+| reserveComment | boolean | [可选] 是否保留原始注释。默认为 true。 |
+
+**返回值：**
+
+| 返回类型 | 描述 |
+| --- | --- |
+| string | 格式化后的代码。 |
 
 #### __call
 
@@ -4344,6 +4854,19 @@ implicit_return_root: boolean
 reserve_line_number: boolean
 ```
 
+#### reserve_comment
+
+**类型：** 成员变量。
+
+**描述：**
+
+编译器是否应该在编译后的代码中保留原始注释。
+
+**签名：**
+```lua
+reserve_comment: boolean
+```
+
 #### space_over_tab
 
 **类型：** 成员变量。
@@ -4394,11 +4917,11 @@ line_offset: integer
 **签名：**
 ```lua
 enum LuaTarget
-        "5.1"
-        "5.2"
-        "5.3"
-        "5.4"
-        "5.5"
+  "5.1"
+  "5.2"
+  "5.3"
+  "5.4"
+  "5.5"
 end
 ```