update doc.

3 files changed, 334 insertions, 317 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 995378f..031af18 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -20,7 +20,7 @@ ELSE(LUA_FOUND)
                         NAMES lua lua54 lua53 lua52 lua51 liblua liblua54 liblua53 liblua52 liblua51 liblua5.4 liblua5.3 liblua5.2 liblua5.1
                         PATHS ${LUA_LIBDIR}
                         NO_DEFAULT_PATH)
-        ENDIF(LUA_EXEC_NAME)
+        ENDIF(LUA_EXEC_NAME STREQUAL "luajit")
 ENDIF(LUA_FOUND)
 
 MESSAGE(STATUS "Lua: " ${LUA})
@@ -39,12 +39,12 @@ target_link_libraries(libyue ${LUA_LIBRARIES})
 find_package(Threads REQUIRED)
 add_executable(yue src/yuescript/ast.cpp src/yuescript/yue_compiler.cpp src/yuescript/yue_parser.cpp src/yuescript/yuescript.cpp src/yuescript/parser.cpp src/yue.cpp)
 target_link_libraries(yue ${LUA_LIBRARIES} Threads::Threads)
-if(CMAKE_DL_LIBS)
+IF(CMAKE_DL_LIBS)
         target_link_libraries(yue ${CMAKE_DL_LIBS})
-endif()
-if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+ENDIF(CMAKE_DL_LIBS)
+IF(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
         target_link_options(yue PRIVATE -lstdc++fs)
-endif()
+ENDIF(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 
 install(CODE "")
 
diff --git a/doc/docs/doc/README.md b/doc/docs/doc/README.md
index fcd7bba..5c43917 100755
--- a/doc/docs/doc/README.md
+++ b/doc/docs/doc/README.md
@@ -360,34 +360,17 @@ tb::func! if tb != nil
 </pre>
 </YueDisplay>
 
-### Incrementing and Decrementing
-
-Yuescript adds the **+=** operator for incrementing and **-=** operator for decrementing values.
-
-```moonscript
-i = 0
-i += 1
-i -= 1
-```
-<YueDisplay>
-<pre>
-i = 0
-i += 1
-i -= 1
-</pre>
-</YueDisplay>
-
-### Appending to tables
+### Appending to Tables
 The **[] =** operator is used to append values to tables.
 
 ```moonscript
-table = {}
-table[] = "Value"
+tab = {}
+tab[] = "Value"
 ```
 <YueDisplay>
 <pre>
-table = {}
-table[] = "Value"
+tab = {}
+tab[] = "Value"
 </pre>
 </YueDisplay>
 
@@ -756,119 +739,50 @@ export default ->
 </pre>
 </YueDisplay>
 
-## Try
-
-The syntax for Lua error handling in a common form.
-
-```moonscript
-try
-  func 1, 2, 3
-catch err
-  print yue.traceback err
-
-success, result = try
-  func 1, 2, 3
-catch err
-  yue.traceback err
-
-try func 1, 2, 3
-catch err
-  print yue.traceback err
-
-success, result = try func 1, 2, 3
-
-try
-  print "trying"
-  func 1, 2, 3
-```
-<YueDisplay>
-<pre>
-try
-  func 1, 2, 3
-catch err
-  print yue.traceback err
-
-success, result = try
-  func 1, 2, 3
-catch err
-  yue.traceback err
-
-try func 1, 2, 3
-catch err
-  print yue.traceback err
-
-success, result = try func 1, 2, 3
-
-try
-  print "trying"
-  func 1, 2, 3
-</pre>
-</YueDisplay>
-
-## Whitespace
-
-Yuescript is a whitespace significant language. You have to write some code block in the same indent with space **' '** or tab **'\t'** like function body, value list and some control blocks. And expressions containing different whitespaces might mean different things. Tab is treated like 4 space, but it's better not mix the use of spaces and tabs.
-
-### Multiline Chaining
-
-You can write multi-line chaining function calls with a same indent.
-```moonscript
-Rx.Observable
-  .fromRange 1, 8
-  \filter (x)-> x % 2 == 0
-  \concat Rx.Observable.of 'who do we appreciate'
-  \map (value)-> value .. '!'
-  \subscribe print
-```
-<YueDisplay>
-<pre>
-Rx.Observable
-  .fromRange 1, 8
-  \filter (x)-> x % 2 == 0
-  \concat Rx.Observable.of 'who do we appreciate'
-  \map (value)-> value .. '!'
-  \subscribe print
-</pre>
-</YueDisplay>
-
 ## Assignment
 
 The variable is dynamic typed and is defined as local by default. But you can change the scope of declaration by **local** and **global** statement.
 
-* **Common Use**
 ```moonscript
 hello = "world"
 a, b, c = 1, 2, 3
 hello = 123 -- uses the existing variable
-
--- update Assignment
-x = 0
-x += 10
-
-s = "hello "
-s ..= "world"
-
-arg or= "default value"
 ```
 <YueDisplay>
-
 <pre>
 hello = "world"
 a, b, c = 1, 2, 3
 hello = 123 -- uses the existing variable
+</pre>
+</YueDisplay>
 
--- update Assignment
-x = 0
-x += 10
-
-s = "hello "
-s ..= "world"
+### Perform Update
 
+You can perform update assignment with many binary operators.
+```moonscript
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- will add a new local if local variable is not exist
+arg or= "default value"
+```
+<YueDisplay>
+<pre>
+x = 1
+x += 1
+x -= 1
+x *= 10
+x /= 10
+x %= 10
+s ..= "world" -- will add a new local if local variable is not exist
 arg or= "default value"
 </pre>
 </YueDisplay>
 
-* **Explicit Locals**
+### Explicit Locals
 ```moonscript
 do
   local *
@@ -884,7 +798,6 @@ do
   B = 2
 ```
 <YueDisplay>
-
 <pre>
 do
   local *
@@ -901,7 +814,7 @@ do
 </pre>
 </YueDisplay>
 
-* **Explicit Globals**
+### Explicit Globals
 ```moonscript
 do
   global *
@@ -933,6 +846,242 @@ do
 </pre>
 </YueDisplay>
 
+## Destructuring Assignment
+
+Destructuring assignment is a way to quickly extract values from a table by their name or position in array based tables.
+
+Typically when you see a table literal, {1,2,3}, it is on the right hand side of an assignment because it is a value. Destructuring assignment swaps the role of the table literal, and puts it on the left hand side of an assign statement.
+
+This is best explained with examples. Here is how you would unpack the first two values from a table:
+
+```moonscript
+thing = {1, 2}
+
+{a, b} = thing
+print a, b
+```
+<YueDisplay>
+<pre>
+thing = {1, 2}
+
+{a, b} = thing
+print a, b
+</pre>
+</YueDisplay>
+
+In the destructuring table literal, the key represents the key to read from the right hand side, and the value represents the name the read value will be assigned to.
+
+```moonscript
+obj = {
+  hello: "world"
+  day: "tuesday"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- OK to do simple destructuring without braces
+```
+<YueDisplay>
+<pre>
+obj = {
+  hello: "world"
+  day: "tuesday"
+  length: 20
+}
+
+{hello: hello, day: the_day} = obj
+print hello, the_day
+
+:day = obj -- OK to do simple destructuring without braces
+</pre>
+</YueDisplay>
+
+This also works with nested data structures as well:
+
+```moonscript
+obj2 = {
+  numbers: {1,2,3,4}
+  properties: {
+    color: "green"
+    height: 13.5
+  }
+}
+
+{numbers: {first, second}} = obj2
+print first, second, color
+```
+<YueDisplay>
+<pre>
+obj2 = {
+  numbers: {1,2,3,4}
+  properties: {
+    color: "green"
+    height: 13.5
+  }
+}
+
+{numbers: {first, second}} = obj2
+print first, second, color
+</pre>
+</YueDisplay>
+
+If the destructuring statement is complicated, feel free to spread it out over a few lines. A slightly more complicated example:
+
+```moonscript
+{
+  numbers: {first, second}
+  properties: {
+    color: color
+  }
+} = obj2
+```
+<YueDisplay>
+<pre>
+{
+  numbers: {first, second}
+  properties: {
+    color: color
+  }
+} = obj2
+</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:
+
+```moonscript
+{:concat, :insert} = table
+```
+<YueDisplay>
+<pre>
+{:concat, :insert} = table
+</pre>
+</YueDisplay>
+
+This is effectively the same as import, but we can rename fields we want to extract by mixing the syntax:
+
+```moonscript
+{:mix, :max, random: rand} = math
+```
+<YueDisplay>
+<pre>
+{:mix, :max, random: rand} = math
+</pre>
+</YueDisplay>
+
+You can write default values while doing destructuring like:
+
+```moonscript
+{:name = "nameless", :job = "jobless"} = person
+```
+<YueDisplay>
+<pre>
+{:name = "nameless", :job = "jobless"} = person
+</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:
+
+```moonscript
+tuples = {
+  {"hello", "world"}
+  {"egg", "head"}
+}
+
+for {left, right} in *tuples
+  print left, right
+```
+<YueDisplay>
+<pre>
+tuples = {
+  {"hello", "world"}
+  {"egg", "head"}
+}
+
+for {left, right} in *tuples
+  print left, right
+</pre>
+</YueDisplay>
+
+We know each element in the array table is a two item tuple, so we can unpack it directly in the names clause of the for statement using a destructure.
+
+## If Assignment
+
+if and elseif blocks can take an assignment in place of a conditional expression. Upon evaluating the conditional, the assignment will take place and the value that was assigned to will be used as the conditional expression. The assigned variable is only in scope for the body of the conditional, meaning it is never available if the value is not truthy.
+
+```moonscript
+if user = database.find_user "moon"
+  print user.name
+```
+<YueDisplay>
+<pre>
+if user = database.find_user "moon"
+  print user.name
+</pre>
+</YueDisplay>
+
+```moonscript
+if hello = os.getenv "hello"
+  print "You have hello", hello
+elseif world = os.getenv "world"
+  print "you have world", world
+else
+  print "nothing :("
+```
+<YueDisplay>
+<pre>
+if hello = os.getenv "hello"
+  print "You have hello", hello
+elseif world = os.getenv "world"
+  print "you have world", world
+else
+  print "nothing :("
+</pre>
+</YueDisplay>
+
+If assignment with extra return values.
+```moonscript
+if success, result = pcall -> "get result without problems"
+  print result -- variable result is scoped
+print "OK"
+```
+<YueDisplay>
+<pre>
+if success, result = pcall -> "get result without problems"
+  print result -- variable result is scoped
+print "OK"
+</pre>
+</YueDisplay>
+
+## Whitespace
+
+Yuescript is a whitespace significant language. You have to write some code block in the same indent with space **' '** or tab **'\t'** like function body, value list and some control blocks. And expressions containing different whitespaces might mean different things. Tab is treated like 4 space, but it's better not mix the use of spaces and tabs.
+
+### Multiline Chaining
+
+You can write multi-line chaining function calls with a same indent.
+```moonscript
+Rx.Observable
+  .fromRange 1, 8
+  \filter (x)-> x % 2 == 0
+  \concat Rx.Observable.of 'who do we appreciate'
+  \map (value)-> value .. '!'
+  \subscribe print
+```
+<YueDisplay>
+<pre>
+Rx.Observable
+  .fromRange 1, 8
+  \filter (x)-> x % 2 == 0
+  \concat Rx.Observable.of 'who do we appreciate'
+  \map (value)-> value .. '!'
+  \subscribe print
+</pre>
+</YueDisplay>
+
 ## Comment
 
 ```moonscript
@@ -962,6 +1111,67 @@ func --[[port]] 3000, --[[ip]] "192.168.1.1"
 </pre>
 </YueDisplay>
 
+## Try
+
+The syntax for Lua error handling in a common form.
+
+```moonscript
+try
+  func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try
+  func 1, 2, 3
+catch err
+  yue.traceback err
+
+try func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try func 1, 2, 3
+
+try
+  print "trying"
+  func 1, 2, 3
+
+-- working with if assignment pattern
+if success, result = try func 1, 2, 3
+catch err
+    print yue.traceback err
+  print result
+```
+<YueDisplay>
+<pre>
+try
+  func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try
+  func 1, 2, 3
+catch err
+  yue.traceback err
+
+try func 1, 2, 3
+catch err
+  print yue.traceback err
+
+success, result = try func 1, 2, 3
+
+try
+  print "trying"
+  func 1, 2, 3
+
+-- working with if assignment pattern
+if success, result = try func 1, 2, 3
+catch err
+    print yue.traceback err
+  print result
+</pre>
+</YueDisplay>
+
 ::: warning NOTICE
 The rest of the document is describing mostly the same syntax taken from Moonscript. So you may as well refer to the [Moonscript Reference](http://moonscript.org/reference) to get the same explanation.
 :::
@@ -1882,40 +2092,6 @@ print "You're lucky!" unless math.random! > 0.1
 </pre>
 </YueDisplay>
 
-## If Assignment
-
-if and elseif blocks can take an assignment in place of a conditional expression. Upon evaluating the conditional, the assignment will take place and the value that was assigned to will be used as the conditional expression. The assigned variable is only in scope for the body of the conditional, meaning it is never available if the value is not truthy.
-
-```moonscript
-if user = database.find_user "moon"
-  print user.name
-```
-<YueDisplay>
-<pre>
-if user = database.find_user "moon"
-  print user.name
-</pre>
-</YueDisplay>
-
-```moonscript
-if hello = os.getenv "hello"
-  print "You have hello", hello
-elseif world = os.getenv "world"
-  print "you have world", world
-else
-  print "nothing :("
-```
-<YueDisplay>
-<pre>
-if hello = os.getenv "hello"
-  print "You have hello", hello
-elseif world = os.getenv "world"
-  print "you have world", world
-else
-  print "nothing :("
-</pre>
-</YueDisplay>
-
 ## Line Decorators
 
 For convenience, the for loop and if statement can be applied to single statements at the end of the line:
@@ -2575,165 +2751,6 @@ tbl = {
 </pre>
 </YueDisplay>
 
-## Destructuring Assignment
-
-Destructuring assignment is a way to quickly extract values from a table by their name or position in array based tables.
-
-Typically when you see a table literal, {1,2,3}, it is on the right hand side of an assignment because it is a value. Destructuring assignment swaps the role of the table literal, and puts it on the left hand side of an assign statement.
-
-This is best explained with examples. Here is how you would unpack the first two values from a table:
-
-```moonscript
-thing = {1, 2}
-
-{a, b} = thing
-print a, b
-```
-<YueDisplay>
-<pre>
-thing = {1, 2}
-
-{a, b} = thing
-print a, b
-</pre>
-</YueDisplay>
-
-In the destructuring table literal, the key represents the key to read from the right hand side, and the value represents the name the read value will be assigned to.
-
-```moonscript
-obj = {
-  hello: "world"
-  day: "tuesday"
-  length: 20
-}
-
-{hello: hello, day: the_day} = obj
-print hello, the_day
-```
-<YueDisplay>
-<pre>
-obj = {
-  hello: "world"
-  day: "tuesday"
-  length: 20
-}
-
-{hello: hello, day: the_day} = obj
-print hello, the_day
-</pre>
-</YueDisplay>
-
-This also works with nested data structures as well:
-
-```moonscript
-obj2 = {
-  numbers: {1,2,3,4}
-  properties: {
-    color: "green"
-    height: 13.5
-  }
-}
-
-{numbers: {first, second}} = obj2
-print first, second, color
-```
-<YueDisplay>
-<pre>
-obj2 = {
-  numbers: {1,2,3,4}
-  properties: {
-    color: "green"
-    height: 13.5
-  }
-}
-
-{numbers: {first, second}} = obj2
-print first, second, color
-</pre>
-</YueDisplay>
-
-If the destructuring statement is complicated, feel free to spread it out over a few lines. A slightly more complicated example:
-
-```moonscript
-{
-  numbers: {first, second}
-  properties: {
-    color: color
-  }
-} = obj2
-```
-<YueDisplay>
-<pre>
-{
-  numbers: {first, second}
-  properties: {
-    color: color
-  }
-} = obj2
-</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:
-
-```moonscript
-{:concat, :insert} = table
-```
-<YueDisplay>
-<pre>
-{:concat, :insert} = table
-</pre>
-</YueDisplay>
-
-This is effectively the same as import, but we can rename fields we want to extract by mixing the syntax:
-
-```moonscript
-{:mix, :max, random: rand} = math
-```
-<YueDisplay>
-<pre>
-{:mix, :max, random: rand} = math
-</pre>
-</YueDisplay>
-
-You can write default values while doing destructuring like:
-
-```moonscript
-{:name = "nameless", :job = "jobless"} = person
-```
-<YueDisplay>
-<pre>
-{:name = "nameless", :job = "jobless"} = person
-</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:
-
-```moonscript
-tuples = {
-  {"hello", "world"}
-  {"egg", "head"}
-}
-
-for {left, right} in *tuples
-  print left, right
-```
-<YueDisplay>
-<pre>
-tuples = {
-  {"hello", "world"}
-  {"egg", "head"}
-}
-
-for {left, right} in *tuples
-  print left, right
-</pre>
-</YueDisplay>
-
-We know each element in the array table is a two item tuple, so we can unpack it directly in the names clause of the for statement using a destructure.
-
 ## Function Stubs
 
 It is common to pass a function from an object around as a value, for example, passing an instance method into a function as a callback. If the function expects the object it is operating on as the first argument then you must somehow bundle that object with the function so it can be called properly.
diff --git a/yuescript-dev-1.rockspec b/yuescript-dev-1.rockspec
index 75835fc..a8d9eea 100644
--- a/yuescript-dev-1.rockspec
+++ b/yuescript-dev-1.rockspec
@@ -19,8 +19,8 @@ dependencies = {
 build = {
         type = "cmake",
         variables = {
-                LUA_INCDIR="$(LUA_INCDIR)",
-                LUA="$(LUA)",
+                LUA_INCDIR = "$(LUA_INCDIR)",
+                LUA = "$(LUA)",
         },
         install = {
                 lib = {