2 files changed, 1037 insertions, 145 deletions

diff --git a/doc/docs/doc/README.md b/doc/docs/doc/README.md
index c4518bf..f0d67a5 100755
--- a/doc/docs/doc/README.md
+++ b/doc/docs/doc/README.md
@@ -16,19 +16,29 @@ Yue (月) is the name of moon in Chinese and it's pronounced as [jyɛ].
 ### An Overview of YueScript
 ```moonscript
 -- import syntax
-import "yue" as :p, :to_lua
+import p, to_lua from "yue"
 
 -- object literals
 inventory =
   equipment:
-    * "sword"
-    * "shield"
+    - "sword"
+    - "shield"
   items:
-    * name: "potion"
+    - name: "potion"
       count: 10
-    * name: "bread"
+    - name: "bread"
       count: 3
 
+-- list comprehension
+map = (arr, action) ->
+  [action item for item in *arr]
+
+filter = (arr, cond) ->
+  [item for item in *arr when cond item]
+
+reduce = (arr, init, action): init ->
+  init = action init, item for item in *arr
+
 -- pipe operator
 [1, 2, 3]
   |> map (x) -> x * 2
@@ -51,19 +61,29 @@ export 🌛 = "月之脚本"
 <YueDisplay>
 <pre>
 -- import syntax
-import "yue" as :p, :to_lua
+import p, to_lua from "yue"
 
 -- object literals
 inventory =
   equipment:
-    * "sword"
-    * "shield"
+    - "sword"
+    - "shield"
   items:
-    * name: "potion"
+    - name: "potion"
       count: 10
-    * name: "bread"
+    - name: "bread"
       count: 3
 
+-- list comprehension
+map = (arr, action) ->
+  [action item for item in *arr]
+
+filter = (arr, cond) ->
+  [item for item in *arr when cond item]
+
+reduce = (arr, init, action): init ->
+  init = action init, item for item in *arr
+
 -- pipe operator
 [1, 2, 3]
   |> map (x) -> x * 2
@@ -132,14 +152,14 @@ export 🌛 = "月之脚本"
 
 &emsp;Use YueScript module in Lua:
 
-* **Case 1**  
+* **Case 1**
 Require "your_yuescript_entry.yue" in Lua.
 ```Lua
 require("yue")("your_yuescript_entry")
 ```
 &emsp;And this code still works when you compile "your_yuescript_entry.yue"  to "your_yuescript_entry.lua" in the same path. In the rest YueScript files just use the normal **require** or **import**. The code line numbers in error messages will also be handled correctly.
 
-* **Case 2**  
+* **Case 2**
 Require YueScript module and rewite message by hand.
 ```lua
 local yue = require("yue")
@@ -151,7 +171,7 @@ end, function(err)
 end)
 ```
 
-* **Case 3**  
+* **Case 3**
 Use the YueScript compiler function in Lua.
 ```lua
 local yue = require("yue")
@@ -203,12 +223,12 @@ Usage: yue [options|files|directories] ...
    Execute without options to enter REPL, type symbol '$'
    in a single line to start/stop multi-line mode
 ```
-&emsp;&emsp;Use cases:  
-&emsp;&emsp;Recursively compile every YueScript file with extension **.yue** under current path:  **yue .**  
-&emsp;&emsp;Compile and save results to a target path:  **yue -t /target/path/ .**  
-&emsp;&emsp;Compile and reserve debug info:  **yue -l .**  
-&emsp;&emsp;Compile and generate minified codes:  **yue -m .**  
-&emsp;&emsp;Execute raw codes:  **yue -e 'print 123'**  
+&emsp;&emsp;Use cases:
+&emsp;&emsp;Recursively compile every YueScript file with extension **.yue** under current path:  **yue .**
+&emsp;&emsp;Compile and save results to a target path:  **yue -t /target/path/ .**
+&emsp;&emsp;Compile and reserve debug info:  **yue -l .**
+&emsp;&emsp;Compile and generate minified codes:  **yue -m .**
+&emsp;&emsp;Execute raw codes:  **yue -e 'print 123'**
 &emsp;&emsp;Execute a YueScript file:  **yue -e main.yue**
 
 ## Macro
@@ -424,6 +444,54 @@ print "Valid enum type:", $BodyType Static
 </pre>
 </YueDisplay>
 
+### Argument Validation
+
+You can declare the expected AST node types in the argument list, and check whether the incoming macro arguments meet the expectations at compile time.
+
+```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>
+
+If you need more flexible argument checking, you can use the built-in `$is_ast` macro function to manually check at the appropriate place.
+
+```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>
+
+For more details about available AST nodes, please refer to the uppercased definitions in [yue_parser.cpp](https://github.com/IppClub/YueScript/blob/main/src/yuescript/yue_parser.cpp).
+
 ## Operator
 
 All of Lua's binary and unary operators are available. Additionally **!=** is as an alias for **~=**, and either **\\** or **::** can be used to write a chaining function call like `tb\func!` or `tb::func!`. And Yuescipt offers some other special operators to write more expressive codes.
@@ -566,11 +634,26 @@ merge = {...a, ...b}
 </pre>
 </YueDisplay>
 
+### Table Reversed Indexing
+
+You can use the **#** operator to get the last elements of a table.
+
+```moonscript
+last = data.items[#]
+second_last = data.items[#-1]
+```
+<YueDisplay>
+<pre>
+last = data.items[#]
+second_last = data.items[#-1]
+</pre>
+</YueDisplay>
+
 ### Metatable
 
 The **<>** operator can be used as a shortcut for metatable manipulation.
 
-* **Metatable Creation**  
+* **Metatable Creation**
 Create normal table with empty bracekets **<>** or metamethod key which is surrounded by **<>**.
 
 ```moonscript
@@ -606,7 +689,7 @@ close _ = &lt;close&gt;: -> print "out of scope"
 </pre>
 </YueDisplay>
 
-* **Metatable Accessing**  
+* **Metatable Accessing**
 Accessing metatable with **<>** or metamethod name surrounded by **<>** or writing some expression in **<>**.
 
 ```moonscript
@@ -630,7 +713,7 @@ print tb.item
 </pre>
 </YueDisplay>
 
-* **Metatable Destructure**  
+* **Metatable Destructure**
 Destruct metatable with metamethod key surrounded by **<>**.
 
 ```moonscript
@@ -732,34 +815,45 @@ a ??= false
 
 ### Implicit Object
 
-You can write a list of implicit structures that starts with the symbol **\*** inside a table block. If you are creating implicit object, the fields of the object must be with the same indent.
+You can write a list of implicit structures that starts with the symbol **\*** or **-** inside a table block. If you are creating implicit object, the fields of the object must be with the same indent.
+
 ```moonscript
+-- assignment with implicit object
 list =
   * 1
   * 2
   * 3
 
+-- function call with implicit object
 func
   * 1
   * 2
   * 3
 
+-- return with implicit object
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- table with implicit object
 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: { }
@@ -767,32 +861,42 @@ tb =
 ```
 <YueDisplay>
 <pre>
+-- assignment with implicit object
 list =
   * 1
   * 2
   * 3
 
+-- function call with implicit object
 func
   * 1
   * 2
   * 3
 
+-- return with implicit object
+f = ->
+  return
+    * 1
+    * 2
+    * 3
+
+-- table with implicit object
 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: { }
@@ -860,7 +964,7 @@ do
 
 The export statement offers a concise way to define modules.
 
-* **Named Export**  
+* **Named Export**
 Named export will define a local variable as well as adding a field in the exported table.
 
 ```moonscript
@@ -924,7 +1028,7 @@ export["a-b-c"] = 123
 </pre>
 </YueDisplay>
 
-* **Unnamed Export**  
+* **Unnamed Export**
 Unnamed export will add the target item into the array part of the exported table.
 
 ```moonscript
@@ -954,7 +1058,7 @@ export with tmp
 </pre>
 </YueDisplay>
 
-* **Default Export**  
+* **Default Export**
 Using the **default** keyword in export statement to replace the exported table with any thing.
 
 ```moonscript
@@ -1202,7 +1306,7 @@ If the destructuring statement is complicated, feel free to spread it out over a
 </pre>
 </YueDisplay>
 
-It’s common to extract values from at table and assign them the local variables that have the same name as the key. In order to avoid repetition we can use the **:** prefix operator:
+It's common to extract values from at table and assign them the local variables that have the same name as the key. In order to avoid repetition we can use the **:** prefix operator:
 
 ```moonscript
 {:concat, :insert} = table
@@ -1246,6 +1350,52 @@ You can use `_` as placeholder when doing a list destructuring:
 </pre>
 </YueDisplay>
 
+### Range Destructuring
+
+You can use the spread operator `...` in list destructuring to capture a range of values. This is useful when you want to extract specific elements from the beginning and end of a list while collecting the rest in between.
+
+```moonscript
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- prints: first
+print bulk   -- prints: {"second", "third", "fourth"}
+print last   -- prints: last
+```
+<YueDisplay>
+<pre>
+orders = ["first", "second", "third", "fourth", "last"]
+[first, ...bulk, last] = orders
+print first  -- prints: first
+print bulk   -- prints: {"second", "third", "fourth"}
+print last   -- prints: last
+</pre>
+</YueDisplay>
+
+The spread operator can be used in different positions to capture different ranges, and you can use `_` as a placeholder for the values you don't want to capture:
+
+```moonscript
+-- Capture everything after first element
+[first, ...rest] = orders
+
+-- Capture everything before last element
+[...start, last] = orders
+
+-- Capture things except the middle elements
+[first, ..._, last] = orders
+```
+<YueDisplay>
+<pre>
+-- Capture everything after first element
+[first, ...rest] = orders
+
+-- Capture everything before last element
+[...start, last] = orders
+
+-- Capture things except the middle elements
+[first, ..._, last] = orders
+</pre>
+</YueDisplay>
+
 ### Destructuring In Other Places
 
 Destructuring can also show up in places where an assignment implicitly takes place. An example of this is a for loop:
@@ -1475,6 +1625,47 @@ catch err
 </pre>
 </YueDisplay>
 
+### Try?
+
+`try?` is a simplified use for error handling syntax that omit the boolean status from the `try` statement, and it will return the result from the try block when success, return nil instead of error object otherwise.
+
+```moonscript
+a, b, c = try? func!
+
+-- with nil coalescing operator
+a = (try? func!) ?? "default"
+
+-- as function argument
+f try? func!
+
+-- with catch block
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+```
+<YueDisplay>
+<pre>
+a, b, c = try? func!
+
+-- with nil coalescing operator
+a = (try? func!) ?? "default"
+
+-- as function argument
+f try? func!
+
+-- with catch block
+f try?
+  print 123
+  func!
+catch e
+  print e
+  e
+</pre>
+</YueDisplay>
+
 ## Attributes
 
 Syntax support for Lua 5.4 attributes. And you can still use both the `const` and `close` declaration and get constant check and scoped callback working when targeting Lua versions below 5.4.
@@ -1503,6 +1694,19 @@ const {:a, :b, c, d} = tb
 </pre>
 </YueDisplay>
 
+You can also declare a global variable to be `const`.
+
+```moonscript
+global const Constant = 123
+-- Constant = 1
+```
+<YueDisplay>
+<pre>
+global const Constant = 123
+-- Constant = 1
+</pre>
+</YueDisplay>
+
 ## Literals
 
 All of the primitive literals in Lua can be used. This applies to numbers, strings, booleans, and **nil**.
@@ -1535,12 +1739,73 @@ You can use underscores in a number literal to increase readability.
 ```moonscript
 integer = 1_000_000
 hex = 0xEF_BB_BF
+binary = 0B10011
 ```
 <YueDisplay>
 
 <pre>
 integer = 1_000_000
 hex = 0xEF_BB_BF
+binary = 0B10011
+</pre>
+</YueDisplay>
+
+### YAML Multiline String
+
+The `|` prefix introduces a YAML-style multiline string literal:
+
+```moonscript
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+```
+<YueDisplay>
+<pre>
+str = |
+  key: value
+  list:
+    - item1
+    - #{expr}
+</pre>
+</YueDisplay>
+
+This allows writing structured multiline text conveniently. All line breaks and indentation are preserved relative to the first non-empty line, and expressions inside `#{...}` are interpolated automatically as `tostring(expr)`.
+
+YAML Multiline String automatically detects the common leading whitespace prefix (minimum indentation across all non-empty lines) and removes it from all lines. This makes it easy to indent your code visually without affecting the resulting string content.
+
+```moonscript
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+```
+<YueDisplay>
+<pre>
+fn = ->
+  str = |
+    foo:
+      bar: baz
+  return str
+</pre>
+</YueDisplay>
+
+Internal indentation is preserved relative to the removed common prefix, allowing clean nested structures.
+
+All special characters like quotes (`"`) and backslashes (`\`) in the YAMLMultiline block are automatically escaped so that the generated Lua string is syntactically valid and behaves as expected.
+
+```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>
 
@@ -1902,22 +2167,22 @@ x * 2
 </pre>
 </YueDisplay>
 
-If you wish to have further code after your backcalls, you can set them aside with a do statement.
+If you wish to have further code after your backcalls, you can set them aside with a do statement. And the parentheses can be omitted with non-fat arrow functions.
 
 ```moonscript
 result, msg = do
-  (data) <- readAsync "filename.txt"
+  data <- readAsync "filename.txt"
   print data
-  (info) <- processAsync data
+  info <- processAsync data
   check info
 print result, msg
 ```
 <YueDisplay>
 <pre>
 result, msg = do
-  (data) <- readAsync "filename.txt"
+  data <- readAsync "filename.txt"
   print data
-  (info) <- processAsync data
+  info <- processAsync data
   check info
 print result, msg
 </pre>
@@ -2248,6 +2513,45 @@ slice = [item for item in *items[,,2]]
 </pre>
 </YueDisplay>
 
+Both the minimum and maximum bounds can be negative, which means that the bounds are counted from the end of the table.
+
+```moonscript
+-- take the last 4 items
+slice = [item for item in *items[-4,-1]]
+```
+<YueDisplay>
+<pre>
+-- take the last 4 items
+slice = [item for item in *items[-4,-1]]
+</pre>
+</YueDisplay>
+
+The step size can also be negative, which means that the items are taken in reverse order.
+
+```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>
+
+#### Slicing Expression
+
+Slicing can also be used as an expression. This is useful for getting a sub-list of a table.
+
+```moonscript
+-- take the 2nd and 4th items as a new list
+sub_list = items[2, 4]
+```
+<YueDisplay>
+<pre>
+-- take the 2nd and 4th items as a new list
+sub_list = items[2, 4]
+</pre>
+</YueDisplay>
+
 ## For Loop
 
 There are two for loop forms, just like in Lua. A numeric one and a generic one:
@@ -2324,6 +2628,23 @@ doubled_evens = for i = 1, 20
 </pre>
 </YueDisplay>
 
+In addition, for loops support break with a return value, allowing the loop itself to be used as an expression that exits early with a meaningful result.
+
+For example, to find the first number greater than 10:
+
+```moonscript
+first_large = for n in *numbers
+  break n if n > 10
+```
+<YueDisplay>
+<pre>
+first_large = for n in *numbers
+  break n if n > 10
+</pre>
+</YueDisplay>
+
+This break-with-value syntax enables concise and expressive search or early-exit patterns directly within loop expressions.
+
 You can also filter values by combining the for loop expression with the continue statement.
 
 For loops at the end of a function body are not accumulated into a table for a return value (Instead the function will return nil). Either an explicit return statement can be used, or the loop can be converted into a list comprehension.
@@ -2345,7 +2666,7 @@ print func_b! -- prints table object
 </pre>
 </YueDisplay>
 
-This is done to avoid the needless creation of tables for functions that don’t need to return the results of the loop.
+This is done to avoid the needless creation of tables for functions that don't need to return the results of the loop.
 
 ## Repeat Loop
 
@@ -2624,28 +2945,26 @@ reader\parse_line! until reader\eof!
 
 ## Switch
 
-The switch statement is shorthand for writing a series of if statements that check against the same value. Note that the value is only evaluated once. Like if statements, switches can have an else block to handle no matches. Comparison is done with the == operator.
+The switch statement is shorthand for writing a series of if statements that check against the same value. Note that the value is only evaluated once. Like if statements, switches can have an else block to handle no matches. Comparison is done with the == operator. In switch statement, you can also use assignment expression to store temporary variable value.
 
 ```moonscript
-name = "Dan"
-switch name
+switch name := "Dan"
   when "Robert"
     print "You are Robert"
   when "Dan", "Daniel"
     print "Your name, it's Dan"
   else
-    print "I don't know about your name"
+    print "I don't know about you with name #{name}"
 ```
 <YueDisplay>
 <pre>
-name = "Dan"
-switch name
+switch name := "Dan"
   when "Robert"
     print "You are Robert"
   when "Dan", "Daniel"
     print "Your name, it's Dan"
   else
-    print "I don't know about your name"
+    print "I don't know about you with name #{name}"
 </pre>
 </YueDisplay>
 
@@ -2676,7 +2995,7 @@ next_number = switch b
 </pre>
 </YueDisplay>
 
-We can use the then keyword to write a switch’s when block on a single line. No extra keyword is needed to write the else block on a single line.
+We can use the then keyword to write a switch's when block on a single line. No extra keyword is needed to write the else block on a single line.
 
 ```moonscript
 msg = switch math.random(1, 5)
@@ -2722,7 +3041,7 @@ else
 </pre>
 </YueDisplay>
 
-It is worth noting the order of the case comparison expression. The case’s expression is on the left hand side. This can be useful if the case’s expression wants to overwrite how the comparison is done by defining an eq metamethod.
+It is worth noting the order of the case comparison expression. The case's expression is on the left hand side. This can be useful if the case's expression wants to overwrite how the comparison is done by defining an eq metamethod.
 
 ### Table Matching
 
@@ -2782,6 +3101,123 @@ switch item
 </pre>
 </YueDisplay>
 
+You can also match against array elements, table fields, and even nested structures with array or table literals.
+
+Match against array elements.
+
+```moonscript
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- b has a default value
+    print "1, 2, #{b}"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- b has a default value
+    print "1, 2, #{b}"
+</pre>
+</YueDisplay>
+
+Match against table fields with destructuring.
+
+```moonscript
+switch tb
+  when success: true, :result
+    print "success", result
+  when success: false
+    print "failed", result
+  else
+    print "invalid"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when success: true, :result
+    print "success", result
+  when success: false
+    print "failed", result
+  else
+    print "invalid"
+</pre>
+</YueDisplay>
+
+Match against nested table structures.
+
+```moonscript
+switch tb
+  when data: {type: "success", :content}
+    print "success", content
+  when data: {type: "error", :content}
+    print "failed", content
+  else
+    print "invalid"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when data: {type: "success", :content}
+    print "success", content
+  when data: {type: "error", :content}
+    print "failed", content
+  else
+    print "invalid"
+</pre>
+</YueDisplay>
+
+Match against array of tables.
+
+```moonscript
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "matched", fourth
+```
+<YueDisplay>
+<pre>
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "matched", fourth
+</pre>
+</YueDisplay>
+
+Match against a list and capture a range of elements.
+
+```moonscript
+segments = ["admin", "users", "logs", "view"]
+switch segments
+        when [...groups, resource, action]
+                print "Group:", groups -- prints: {"admin", "users"}
+                print "Resource:", resource -- prints: "logs"
+                print "Action:", action -- prints: "view"
+```
+<YueDisplay>
+<pre>
+segments = ["admin", "users", "logs", "view"]
+switch segments
+        when [...groups, resource, action]
+                print "Group:", groups -- prints: {"admin", "users"}
+                print "Resource:", resource -- prints: "logs"
+                print "Action:", action -- prints: "view"
+</pre>
+</YueDisplay>
+
 ## Object Oriented Programming
 
 In these examples, the generated Lua code may appear overwhelming. It is best to focus on the meaning of the YueScript code at first, then look into the Lua code if you wish to know the implementation details.
@@ -2913,7 +3349,7 @@ class BackPack extends Inventory
 
 Here we extend our Inventory class, and limit the amount of items it can carry.
 
-In this example, we don’t define a constructor on the subclass, so the parent class' constructor is called when we make a new instance. If we did define a constructor then we can use the super method to call the parent constructor.
+In this example, we don't define a constructor on the subclass, so the parent class' constructor is called when we make a new instance. If we did define a constructor then we can use the super method to call the parent constructor.
 
 Whenever a class inherits from another, it sends a message to the parent class by calling the method __inherited on the parent class if it exists. The function receives two arguments, the class that is being inherited and the child class.
 
@@ -3000,13 +3436,13 @@ print BackPack.size -- prints 10
 
 The class object is what we create when we use a class statement. The class object is stored in a variable of the same name of the class.
 
-The class object can be called like a function in order to create new instances. That’s how we created instances of classes in the examples above.
+The class object can be called like a function in order to create new instances. That's how we created instances of classes in the examples above.
 
 A class is made up of two tables. The class table itself, and the base table. The base is used as the metatable for all the instances. All properties listed in the class declaration are placed in the base.
 
-The class object’s metatable reads properties from the base if they don’t exist in the class object. This means we can access functions and properties directly from the class.
+The class object's metatable reads properties from the base if they don't exist in the class object. This means we can access functions and properties directly from the class.
 
-It is important to note that assigning to the class object does not assign into the base, so it’s not a valid way to add new methods to instances. Instead the base must explicitly be changed. See the __base field below.
+It is important to note that assigning to the class object does not assign into the base, so it's not a valid way to add new methods to instances. Instead the base must explicitly be changed. See the __base field below.
 
 The class object has a couple special properties:
 
@@ -3079,7 +3515,7 @@ print Counter.count -- prints 2
 </pre>
 </YueDisplay>
 
-The calling semantics of @@ are similar to @. Calling a @@ name will pass the class in as the first argument using Lua’s colon syntax.
+The calling semantics of @@ are similar to @. Calling a @@ name will pass the class in as the first argument using Lua's colon syntax.
 
 ```moonscript
 @@hello 1,2,3,4
@@ -3094,7 +3530,7 @@ The calling semantics of @@ are similar to @. Calling a @@ name will pass the cl
 
 In the body of a class declaration, we can have normal expressions in addition to key/value pairs. In this context, self is equal to the class object.
 
-Here is an alternative way to create a class variable compared to what’s described above:
+Here is an alternative way to create a class variable compared to what's described above:
 
 ```moonscript
 class Things
@@ -3360,19 +3796,19 @@ In this usage, with can be seen as a special form of the K combinator.
 The expression in the with statement can also be an assignment, if you want to give a name to the expression.
 
 ```moonscript
-with str = "Hello"
+with str := "Hello"
   print "original:", str
   print "upper:", \upper!
 ```
 <YueDisplay>
 <pre>
-with str = "Hello"
+with str := "Hello"
   print "original:", str
   print "upper:", \upper!
 </pre>
 </YueDisplay>
 
-Accessing special keys with `[]` in a `with` statement.
+You can access special keys with `[]` in a `with` statement.
 
 ```moonscript
 with tb
@@ -3395,6 +3831,18 @@ with tb
 </pre>
 </YueDisplay>
 
+`with?` is an enhanced version of `with` syntax, which introduces an existential check to safely access objects that may be nil without explicit null checks.
+
+```moonscript
+with? obj
+  print obj.name
+```
+<YueDisplay>
+<pre>
+with? obj
+  print obj.name
+</pre>
+</YueDisplay>
 
 ## Do
 
@@ -3415,7 +3863,7 @@ print var -- nil here
 </pre>
 </YueDisplay>
 
-YueScript’s **do** can also be used an expression . Allowing you to combine multiple lines into one. The result of the do expression is the last statement in its body.
+YueScript's **do** can also be used an expression . Allowing you to combine multiple lines into one. The result of the do expression is the last statement in its body.
 
 ```moonscript
 counter = do
@@ -3541,7 +3989,7 @@ print i -- will print 0
 </pre>
 </YueDisplay>
 
-In my_func, we've overwritten the value of i mistakenly. In this example it is quite obvious, but consider a large, or foreign code base where it isn’t clear what names have already been declared.
+In my_func, we've overwritten the value of i mistakenly. In this example it is quite obvious, but consider a large, or foreign code base where it isn't clear what names have already been declared.
 
 It would be helpful to say which variables from the enclosing scope we intend on change, in order to prevent us from changing others by accident.
 
diff --git a/doc/docs/zh/doc/README.md b/doc/docs/zh/doc/README.md
index 1a2da96..15f4768 100755
--- a/doc/docs/zh/doc/README.md
+++ b/doc/docs/zh/doc/README.md
@@ -16,19 +16,29 @@ 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
 
+-- 列表推导
+map = (arr, action) ->
+  [action item for item in *arr]
+
+filter = (arr, cond) ->
+  [item for item in *arr when cond item]
+
+reduce = (arr, init, action): init ->
+  init = action init, item for item in *arr
+
 -- 管道操作符
 [1, 2, 3]
   |> map (x) -> x * 2
@@ -51,19 +61,29 @@ 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
 
+-- 列表推导
+map = (arr, action) ->
+  [action item for item in *arr]
+
+filter = (arr, cond) ->
+  [item for item in *arr when cond item]
+
+reduce = (arr, init, action): init ->
+  init = action init, item for item in *arr
+
 -- 管道操作符
 [1, 2, 3]
   |> map (x) -> x * 2
@@ -122,7 +142,7 @@ export 🌛 = "月之脚本"
 
 * **下载预编译的二进制程序**
 
-&emsp;您可以下载预编译的二进制程序，包括兼容不同 Lua 版本的二进制可执行文件和库文件。
+&emsp;你可以下载预编译的二进制程序，包括兼容不同 Lua 版本的二进制可执行文件和库文件。
 
 &emsp;在[这里](https://github.com/IppClub/YueScript/releases)下载预编译的二进制程序。
 
@@ -132,14 +152,14 @@ export 🌛 = "月之脚本"
 
 在Lua中使用月之脚本模块：
 
-* **用法 1**  
+* **用法 1**
 在Lua中引入 "你的脚本入口文件.yue"。
 ```Lua
 require("yue")("你的脚本入口文件")
 ```
 当你在同一路径下把 "你的脚本入口文件.yue" 编译成了 "你的脚本入口文件.lua" 时，仍然可以使用这个代码加载 .lua 代码文件。在其余的月之脚本文件中，只需正常使用 **require** 或 **import**进行脚本引用即可。错误消息中的代码行号也会被正确处理。
 
-* **用法 2**  
+* **用法 2**
 手动引入月之脚本模块并重写错误消息来帮助调试。
 ```lua
 local yue = require("yue")
@@ -151,7 +171,7 @@ end, function(err)
 end)
 ```
 
-* **用法 3**  
+* **用法 3**
 在Lua中使用月之脚本编译器功能。
 ```lua
 local yue = require("yue")
@@ -202,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**
 
 ## 宏
@@ -333,7 +353,7 @@ end
 
 ### 导出宏
 
-宏函数可以从一个模块中导出，并在另一个模块中导入。您必须将导出的宏函数放在一个单独的文件中使用，而且只有宏定义、宏导入和宏展开可以放入这个宏导出模块中。
+宏函数可以从一个模块中导出，并在另一个模块中导入。你必须将导出的宏函数放在一个单独的文件中使用，而且只有宏定义、宏导入和宏展开可以放入这个宏导出模块中。
 ```moonscript
 -- 文件: utils.yue
 export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
@@ -422,6 +442,54 @@ 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!`。此外月之脚本还提供了一些其他特殊的操作符，以编写更具表达力的代码。
@@ -439,7 +507,7 @@ tb::func! if tb != nil
 
 ### 链式比较
 
-您可以在月之脚本中进行比较表达式的链式书写：
+你可以在月之脚本中进行比较表达式的链式书写：
 
 ```moonscript
 print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
@@ -528,7 +596,7 @@ tab[] = "Value"
 
 ### 表扩展
 
-您可以使用前置 `...` 操作符在Lua表中插入数组表或哈希表。
+你可以使用前置 `...` 操作符在Lua表中插入数组表或哈希表。
 
 ```moonscript
 parts =
@@ -565,11 +633,26 @@ merge = {...a, ...b}
 </pre>
 </YueDisplay>
 
+### 表反向索引
+
+你可以使用 **#** 操作符来反向索引表中的元素。
+
+```moonscript
+last = data.items[#]
+second_last = data.items[#-1]
+```
+<YueDisplay>
+<pre>
+last = data.items[#]
+second_last = data.items[#-1]
+</pre>
+</YueDisplay>
+
 ### 元表
 
 **<>** 操作符可提供元表操作的快捷方式。
 
-* **元表创建**  
+* **元表创建**
 使用空括号 **<>** 或被 **<>** 包围的元方法键创建普通的Lua表。
 
 ```moonscript
@@ -605,7 +688,7 @@ close _ = &lt;close&gt;: -> print "超出范围"
 </pre>
 </YueDisplay>
 
-* **元表访问**  
+* **元表访问**
 使用 **<>** 或被 **<>** 包围的元方法名或在 **<>** 中编写某些表达式来访问元表。
 
 ```moonscript
@@ -629,7 +712,7 @@ print tb.item
 </pre>
 </YueDisplay>
 
-* **元表解构**  
+* **元表解构**
 使用被 **<>** 包围的元方法键解构元表。
 
 ```moonscript
@@ -680,7 +763,7 @@ with? io.open "test.txt", "w"
 
 ### 管道
 
-与其使用一系列嵌套的函数调用，您还可以考虑使用运算符 **|>** 来传递值。
+与其使用一系列嵌套的函数调用，你还可以考虑使用运算符 **|>** 来传递值。
 
 ```moonscript
 "你好" |> print
@@ -731,67 +814,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: { }
@@ -859,7 +962,7 @@ do
 
 导出语句提供了一种简洁的方式来定义当前的模块。
 
-* **命名导出**  
+* **命名导出**
 带命名的导出将定义一个局部变量，并在导出的表中添加一个同名的字段。
 
 ```moonscript
@@ -923,7 +1026,7 @@ export["a-b-c"] = 123
 </pre>
 </YueDisplay>
 
-* **未命名导出**  
+* **未命名导出**
 未命名导出会将要导出的目标项目添加到导出表的数组部分。
 
 ```moonscript
@@ -953,7 +1056,7 @@ export with tmp
 </pre>
 </YueDisplay>
 
-* **默认导出**  
+* **默认导出**
 在导出语句中使用 **default** 关键字，来替换导出的表为一个目标的对象。
 
 ```moonscript
@@ -1223,7 +1326,7 @@ print first, second, color
 </pre>
 </YueDisplay>
 
-在进行解构时，您可以指定默认值，如：
+在进行解构时，你可以指定默认值，如：
 
 ```moonscript
 {:name = "nameless", :job = "jobless"} = person
@@ -1234,7 +1337,7 @@ print first, second, color
 </pre>
 </YueDisplay>
 
-在进行列表解构时，您可以使用`_`作为占位符：
+在进行列表解构时，你可以使用`_`作为占位符：
 
 ```moonscript
 [_, two, _, four] = items
@@ -1245,9 +1348,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>
+
+展开运算符可以用在不同的位置来捕获不同的范围，并且你可以使用 `_` 作为占位符来表示你想跳过对应范围的捕获：
+
+```moonscript
+-- 捕获第一个元素之后的所有元素
+[first, ...rest] = orders
+
+-- 捕获最后一个元素之前的所有元素
+[...start, last] = orders
+
+-- 跳过中间的元素，只捕获第一个和最后一个元素
+[first, ..._, last] = orders
+```
+<YueDisplay>
+<pre>
+-- 捕获第一个元素之后的所有元素
+[first, ...rest] = orders
+
+-- 捕获最后一个元素之前的所有元素
+[...start, last] = orders
+
+-- 跳过中间的元素，只捕获第一个和最后一个元素
+[first, ..._, last] = orders
+</pre>
+</YueDisplay>
+
+### 在其它地方的解构赋值
 
-解构也可以出现在其它隐式进行赋值的地方。一个例子是用在for循环：
+解构赋值也可以出现在其它隐式进行赋值的地方。一个例子是用在for循环中：
 
 ```moonscript
 tuples = [
@@ -1322,7 +1471,7 @@ print "好的"
 
 ### While 赋值
 
-您可以在 while 循环中同样使用赋值来获取循环条件的值。
+你可以在 while 循环中同样使用赋值来获取循环条件的值。
 ```moonscript
 while byte := stream\read_one!
   -- 对 byte 做一些操作
@@ -1338,7 +1487,7 @@ while byte := stream\read_one!
 
 ## 可变参数赋值
 
-您可以将函数返回的结果赋值给一个可变参数符号 `...`。然后使用Lua的方式访问其内容。
+你可以将函数返回的结果赋值给一个可变参数符号 `...`。然后使用Lua的方式访问其内容。
 ```moonscript
 list = [1, 2, 3, 4, 5]
 fn = (ok) -> ok, table.unpack list
@@ -1360,7 +1509,7 @@ print ok, count, first
 
 ## 空白
 
-月之脚本是一个对空白敏感的语言。您必须在相同的缩进中使用空格 **' '** 或制表符 **'\t'** 来编写一些代码块，如函数体、值列表和一些控制块。包含不同空白的表达式可能意味着不同的事情。制表符被视为4个空格，但最好不要混合使用空格和制表符。
+月之脚本是一个对空白敏感的语言。你必须在相同的缩进中使用空格 **' '** 或制表符 **'\t'** 来编写一些代码块，如函数体、值列表和一些控制块。包含不同空白的表达式可能意味着不同的事情。制表符被视为4个空格，但最好不要混合使用空格和制表符。
 
 ### 多行链式调用
 
@@ -1474,6 +1623,47 @@ 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`的属性声明语法，并获得常量检查和作用域回调的功能。
@@ -1502,6 +1692,19 @@ const {:a, :b, c, d} = tb
 </pre>
 </YueDisplay>
 
+你也可以声明全局变量为常量。
+
+```moonscript
+global const Constant = 123
+-- Constant = 1
+```
+<YueDisplay>
+<pre>
+global const Constant = 123
+-- Constant = 1
+</pre>
+</YueDisplay>
+
 ## 字面量
 
 Lua中的所有基本字面量都可以在月之脚本中使用。包括数字、字符串、布尔值和**nil**。
@@ -1529,17 +1732,78 @@ print "我有#{math.random! * 100}%的把握。"
 
 ### 数字字面量
 
-您可以在数字字面量中使用下划线来增加可读性。
+你可以在数字字面量中使用下划线来增加可读性。
 
 ```moonscript
 integer = 1_000_000
 hex = 0xEF_BB_BF
+binary = 0B10011
 ```
 <YueDisplay>
 
 <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>
 
@@ -1644,7 +1908,7 @@ print "数字的和是", sum 10, 20
 </pre>
 </YueDisplay>
 
-如果您需要做显式返回，可以使用return关键字：
+如果你需要做显式返回，可以使用return关键字：
 
 ```moonscript
 sum = (x, y) -> return x + y
@@ -1850,7 +2114,7 @@ print @value
 </pre>
 </YueDisplay>
 
-您可以通过一个占位符指定回调函数的传参位置。
+你可以通过一个占位符指定回调函数的传参位置。
 
 ```moonscript
 (x) <- map _, [1, 2, 3]
@@ -1863,22 +2127,22 @@ x * 2
 </pre>
 </YueDisplay>
 
-如果您希望在反向回调处理后继续编写更多其它的代码，您可以使用do语句将不归属反向回调的代码分开。
+如果你希望在反向回调处理后继续编写更多其它的代码，可以使用 do 语句将不属于反向回调的代码分隔开。对于非粗箭头函数的反向回调，回调返回值的括号也是可以省略的。
 
 ```moonscript
 result, msg = do
-  (data) <- readAsync "文件名.txt"
+  data <- readAsync "文件名.txt"
   print data
-  (info) <- processAsync data
+  info <- processAsync data
   check info
 print result, msg
 ```
 <YueDisplay>
 <pre>
 result, msg = do
-  (data) <- readAsync "文件名.txt"
+  data <- readAsync "文件名.txt"
   print data
-  (info) <- processAsync data
+  info <- processAsync data
   check info
 print result, msg
 </pre>
@@ -2037,7 +2301,7 @@ list_with_one_element = [ 1, ]
 
 ## 推导式
 
-推导式为我们提供了一种便捷的语法，通过遍历现有对象并对其值应用表达式来构造出新的表格。月之脚本有两种推导式：列表推导式和表格推导式。它们最终都是产生Lua表格；列表推导式将值累积到类似数组的表格中，而表格推导式允许您在每次遍历时设置新表格的键和值。
+推导式为我们提供了一种便捷的语法，通过遍历现有对象并对其值应用表达式来构造出新的表格。月之脚本有两种推导式：列表推导式和表格推导式。它们最终都是产生Lua表格；列表推导式将值累积到类似数组的表格中，而表格推导式允许你在每次遍历时设置新表格的键和值。
 
 ### 列表推导式
 
@@ -2057,13 +2321,11 @@ doubled = [item * 2 for i, item in ipairs items]
 可以使用when子句筛选新表中包含的项目：
 
 ```moonscript
-iter = ipairs items
-slice = [item for i, item in iter when i > 1 and i < 3]
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
 ```
 <YueDisplay>
 <pre>
-iter = ipairs items
-slice = [item for i, item in iter when i > 1 and i < 3]
+slice = [item for i, item in ipairs items when i > 1 and i < 3]
 </pre>
 </YueDisplay>
 
@@ -2212,6 +2474,45 @@ 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循环形式，数字型和通用型：
@@ -2288,9 +2589,24 @@ doubled_evens = for i = 1, 20
 </pre>
 </YueDisplay>
 
-您还可以结合for循环表达式与continue语句来过滤值。
+此外，for循环还支持带返回值的break语句，这样循环本身就可以作为一个表达式，在满足条件时提前退出并返回有意义的结果。
 
-注意出现在函数体末尾的for循环，不会被当作是一个表达式，并将循环结果累积到一个列表中作为返回值（相反，函数将返回nil）。如果要函数末尾的循环转换为列表表达式，可以使用返回语句加for循环表达式。
+例如，查找第一个大于10的数字：
+
+```moonscript
+first_large = for n in *numbers
+  break n if n > 10
+```
+<YueDisplay>
+<pre>
+first_large = for n in *numbers
+  break n if n > 10
+</pre>
+</YueDisplay>
+
+你还可以结合for循环表达式与continue语句来过滤值。
+
+注意出现在函数体末尾的for循环，不会被当作是一个表达式并将循环结果累积到一个列表中作为返回值（相反，函数将返回nil）。如果要函数末尾的循环转换为列表表达式，可以显式地使用返回语句加for循环表达式。
 
 ```moonscript
 func_a = -> for i = 1, 10 do print i
@@ -2515,7 +2831,7 @@ print "你真幸运！" unless math.random! > 0.1
 
 ### 范围表达式
 
-您可以使用范围表达式来编写进行范围检查的代码。
+你可以使用范围表达式来编写进行范围检查的代码。
 
 ```moonscript
 a = 5
@@ -2588,28 +2904,26 @@ 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>
 
@@ -2686,7 +3000,7 @@ else
 </pre>
 </YueDisplay>
 
-值得注意的是，在生成Lua代码时，我们要做检查的目标变量会放在==表达式的右侧。当您希望给when子句的比较对象定义一个\_\_eq元方法来重载判断逻辑时，可能会有用。
+值得注意的是，在生成Lua代码时，我们要做检查的目标变量会放在==表达式的右侧。当你希望给when子句的比较对象定义一个\_\_eq元方法来重载判断逻辑时，可能会有用。
 
 ### 表格匹配
 
@@ -2746,9 +3060,126 @@ switch item
 </pre>
 </YueDisplay>
 
+你也可以匹配数组元素、表格字段，甚至使用数组或表格字面量来匹配嵌套的结构。
+
+匹配数组元素。
+
+```moonscript
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- 变量b有默认值
+    print "1, 2, #{b}"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when [1, 2, 3]
+    print "1, 2, 3"
+  when [1, b, 3]
+    print "1, #{b}, 3"
+  when [1, 2, b = 3] -- 变量b有默认值
+    print "1, 2, #{b}"
+</pre>
+</YueDisplay>
+
+匹配表格字段。
+
+```moonscript
+switch tb
+  when success: true, :result
+    print "成功", result
+  when success: false
+    print "失败", result
+  else
+    print "无效值"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when success: true, :result
+    print "成功", result
+  when success: false
+    print "失败", result
+  else
+    print "无效值"
+</pre>
+</YueDisplay>
+
+匹配嵌套的表格结构。
+
+```moonscript
+switch tb
+  when data: {type: "success", :content}
+    print "成功", content
+  when data: {type: "error", :content}
+    print "失败", content
+  else
+    print "无效值"
+```
+<YueDisplay>
+<pre>
+switch tb
+  when data: {type: "success", :content}
+    print "成功", content
+  when data: {type: "error", :content}
+    print "失败", content
+  else
+    print "无效值"
+</pre>
+</YueDisplay>
+
+匹配表格数组。
+
+```moonscript
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "匹配成功", fourth
+```
+<YueDisplay>
+<pre>
+switch tb
+  when [
+      {a: 1, b: 2}
+      {a: 3, b: 4}
+      {a: 5, b: 6}
+      fourth
+    ]
+    print "匹配成功", fourth
+</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代码。
 
 一个简单的类：
 
@@ -3216,7 +3647,7 @@ x = class
 
 ### 类混合
 
-您可以通过使用 `using` 关键字来实现类混合。这意味着您可以从一个普通 Lua 表格或已定义的类对象中，复制函数到您创建的新类中。当您使用普通 Lua 表格进行类混合时，您有机会用自己的实现来重写类的索引方法（例如元方法 `__index`）。然而，当您从一个类对象做混合时，需要注意的是该类对象的元方法将不会被复制到新类。
+你可以通过使用 `using` 关键字来实现类混合。这意味着你可以从一个普通 Lua 表格或已定义的类对象中，复制函数到你创建的新类中。当你使用普通 Lua 表格进行类混合时，你有机会用自己的实现来重写类的索引方法（例如元方法 `__index`）。然而，当你从一个类对象做混合时，需要注意的是该类对象的元方法将不会被复制到新类。
 
 ```moonscript
 MyIndex = __index: var: 1
@@ -3318,22 +3749,22 @@ me = create_person "Leaf", [dad, mother, sister]
 
 在此用法中，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
@@ -3356,6 +3787,19 @@ 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中差不多。
@@ -3375,7 +3819,7 @@ print var -- 这里是nil
 </pre>
 </YueDisplay>
 
-月之脚本的 **do** 也可以用作表达式。允许您将多行代码的处理合并为一个表达式，并将do语句代码块的最后一个语句作为表达式返回的结果。
+月之脚本的 **do** 也可以用作表达式。允许你将多行代码的处理合并为一个表达式，并将do语句代码块的最后一个语句作为表达式返回的结果。
 
 ```moonscript
 counter = do
@@ -4334,8 +4778,8 @@ simplified: boolean
 
 版权 (c) 2017-2025 李瑾  \<dragon-fly@qq.com\>
 
-特此免费授予任何获得本软件副本和相关文档文件（下称“软件”）的人不受限制地处置该软件的权利，包括不受限制地使用、复制、修改、合并、发布、分发、转授许可和/或出售该软件副本，以及再授权被配发了本软件的人如上的权利，须在下列条件下：  
-上述版权声明和本许可声明应包含在该软件的所有副本或实质成分中。  
+特此免费授予任何获得本软件副本和相关文档文件（下称“软件”）的人不受限制地处置该软件的权利，包括不受限制地使用、复制、修改、合并、发布、分发、转授许可和/或出售该软件副本，以及再授权被配发了本软件的人如上的权利，须在下列条件下：
+上述版权声明和本许可声明应包含在该软件的所有副本或实质成分中。
 本软件是“如此”提供的，没有任何形式的明示或暗示的保证，包括但不限于对适销性、特定用途的适用性和不侵权的保证。在任何情况下，作者或版权持有人都不对任何索赔、损害或其他责任负责，无论这些追责来自合同、侵权或其它行为中，还是产生于、源于或有关于本软件以及本软件的使用或其它处置。
 
 <CompilerModal />