aboutsummaryrefslogtreecommitdiff
path: root/CHANGELOG.md
diff options
context:
space:
mode:
Diffstat (limited to 'CHANGELOG.md')
-rw-r--r--CHANGELOG.md427
1 files changed, 427 insertions, 0 deletions
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..5ec9a47
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,427 @@
1# Changelog
2
3The implementation for original Moonscript language 0.5.0 can be found in the `0.5.0` branch of MoonPlus. The Moonscript with fixes and new features is in the master branch of MoonPlus. Here are the changelogs for each MoonPlus version.
4
5
6
7## v0.3.7
8
9### Fixed Issues
10
11* Fix macro type mismatch issue.
12* Fix line break issue in macro, disable macro declaration outside the root scope.
13* Fix existential operator issue when used in operator-value list.
14
15
16
17### Added Features
18
19* Add support for macro system expanding to Lua codes directly.
20* Add goto statement support.
21* `moonp` now supports recursively traversing any directory and compiling any moon file in the path.
22* `moonp` now supports REPL functions for Moonscript.
23
24
25
26### Changed Hehaviors
27
28* Remove else clause support from if-else line decorator syntax which makes users confused.
29
30
31
32## v0.3.0
33
34### Added Features
35
36* Add macro functions.
37```Moonscript
38-- file 'macro.moon'
39export macro block config = (debugging = true)->
40 global debugMode = debugging == "true"
41 ""
42
43export macro block asserts = (cond)->
44 debugMode and "assert #{cond}" or ""
45
46export macro expr assert = (cond)->
47 debugMode and "assert #{cond}" or "#{cond}"
48
49$config!
50
51-- file 'main.moon'
52import 'macro' as {:$config, :$assert, :$asserts}
53
54macro expr and = (...)-> "#{ table.concat {...}, ' and ' }"
55
56$asserts item ~= nil
57$config false
58value = $assert item
59
60if $and f1!, f2!, f3!
61 print "OK"
62```
63 Compiles to:
64```Lua
65-- file 'macro.moon'
66local _module_0 = { }
67return _module_0
68
69-- file 'main.moon'
70assert(item ~= nil)
71local value = item
72if (f1() and f2() and f3()) then
73 print("OK")
74end
75```
76
77
78
79## v0.2.0
80
81### Fixed Issues
82
83* Fix some cases when using backcall with assignment.
84* Fix a case that complier crashes with empty code body.
85* Force forward declaration of variable for assigning local function.
86
87From original Moonscript compiler:
88
89* [#390](https://github.com/leafo/moonscript/issues/390) Many lists are not allowed to be multiline
90
91
92
93### Added Features
94
95* Allow value lists in for and local statement to be multiline.
96* `moonp` now compiles source files in multiple threads to speed up compilation.
97* Add placeholder support for backcall operator.
98* Add placeholder support for backcall statement.
99* Add fat arrow support for backcall statement.
100* Add option to compile MoonPlus as a Lua C lib. Got MoonPlus released to `Luarocks`.
101* Move old `export` statement functions to `global` statement to match the `local` statement.
102* Change `export` statement behavier to support module management. Moon codes with `export` statement can not explicit return values in root scope. And codes with `export default` can export only one value as the module content. Use cases:
103```Moonscript
104-- file 'Config.moon'
105export default {flag:1, value:"x"}
106
107-- file 'Utils.moon'
108export map = (items, func)-> [func item for item in *items]
109export filter = (items, func)-> [item for item in *items when func item]
110
111-- file 'main.moon'
112import 'Config' as {:flag, :value}
113import 'Utils' as {:map, :filter}
114```
115Compiles to:
116```Lua
117-- file 'Config.moon'
118local _module_0 = nil
119_module_0 = {
120 flag = 1,
121 value = "x"
122}
123return _module_0
124
125-- file 'Utils.moon'
126local _module_0 = { }
127local map
128map = function(items, func)
129 local _accum_0 = { }
130 local _len_0 = 1
131 for _index_0 = 1, #items do
132 local item = items[_index_0]
133 _accum_0[_len_0] = func(item)
134 _len_0 = _len_0 + 1
135 end
136 return _accum_0
137end
138_module_0["map"] = map
139local filter
140filter = function(items, func)
141 local _accum_0 = { }
142 local _len_0 = 1
143 for _index_0 = 1, #items do
144 local item = items[_index_0]
145 if func(item) then
146 _accum_0[_len_0] = item
147 _len_0 = _len_0 + 1
148 end
149 end
150 return _accum_0
151end
152_module_0["filter"] = filter
153return _module_0
154
155-- file 'main.moon'
156local flag, value
157do
158 local _obj_0 = require('Config')
159 flag, value = _obj_0.flag, _obj_0.value
160end
161local map, filter
162do
163 local _obj_0 = require('Utils')
164 map, filter = _obj_0.map, _obj_0.filter
165end
166```
167
168
169
170## v0.1.0
171
172### Fixed Issues
173
174Fix issues in original Moonscript compiler:
175* [#122](https://github.com/leafo/moonscript/issues/122) use of ? symbol
176* [#155](https://github.com/leafo/moonscript/issues/151) wish moon could support: function?()
177* [#156](https://github.com/leafo/moonscript/issues/156) About the 'import' statement
178* [#375](https://github.com/leafo/moonscript/issues/375) assignment in line decorators
179* [#384](https://github.com/leafo/moonscript/issues/384) The @ and @@ accessors do not escape Lua keywords
180
181
182
183### Added Features
184
185* Multi-line comment support.
186
187* Usage for symbol `\` to escape new line. Will compile codes:
188```Moonscript
189str = --[[
190 This is a multi line comment.
191 It's OK.
192]] strA \ -- comment 1
193 .. strB \ -- comment 2
194 .. strC
195
196func --[[ip]] "192.168.126.110", --[[port]] 3000
197```
198  to:
199```Lua
200local str = strA .. strB .. strC
201func("192.168.126.110", 3000)
202```
203
204* Back call features with new operator and syntax. For example:
205```Moonscript
206{1,2,3} \
207 |> map((x)-> x * 2) \
208 |> filter((x)-> x > 4) \
209 |> reduce(0, (a,b)-> a + b) \
210 |> print
211
212do
213 (data) <- http.get "ajaxtest"
214 body[".result"]\html data
215 (processed) <- http.post "ajaxprocess", data
216 body[".result"]\append processed
217 print "done"
218```
219&emsp;&emsp;will be compiled to:
220```Lua
221print(reduce(filter(map({
222 1,
223 2,
224 3
225}, function(x)
226 return x * 2
227end), function(x)
228 return x > 4
229end), 0, function(a, b)
230 return a + b
231end))
232do
233 http.get("ajaxtest", function(data)
234 body[".result"]:html(data)
235 return http.post("ajaxprocess", data, function(processed)
236 body[".result"]:append(processed)
237 return print("done")
238 end)
239 end)
240end
241```
242
243* Existential operator support. Generate codes from:
244```Moonscript
245func?!
246
247x = tab?.value
248
249print abc?["hello world"]?.xyz
250
251if print and x?
252 print x
253```
254&emsp;&emsp;to:
255```Lua
256if func ~= nil then
257 func()
258end
259local x
260if tab ~= nil then
261 x = tab.value
262end
263print((function()
264 if abc ~= nil then
265 local _obj_0 = abc["hello world"]
266 if _obj_0 ~= nil then
267 return _obj_0.xyz
268 end
269 return nil
270 end
271 return nil
272end)())
273if print and (x ~= nil) then
274 print(x)
275end
276```
277
278* More usages for `import` keyword. Will compile codes from:
279```Moonscript
280import 'module'
281import "module.part"
282import "d-a-s-h-e-s"
283import "player" as Player
284import "lpeg" as {:C, :Ct, :Cmt}
285```
286&emsp;&emsp;to:
287```Lua
288local module = require('module')
289local part = require("module.part")
290local d_a_s_h_e_s = require("d-a-s-h-e-s")
291local Player = require("player")
292local C, Ct, Cmt
293do
294 local _obj_0 = require("lpeg")
295 C, Ct, Cmt = _obj_0.C, _obj_0.Ct, _obj_0.Cmt
296end
297```
298
299* Can do slash call with Lua keywords. Generate codes from:
300```Moonscript
301c.repeat.if\then("xyz")\else res
302```
303&emsp;&emsp;to:
304```Lua
305local _call_3 = c["repeat"]["if"]
306local _call_4 = _call_3["then"](_call_3, "xyz")
307_call_4["else"](_call_4, res)
308```
309
310
311
312### Changed Hehaviors
313
314* Left part of update statement will now accept only one assignable expression.
315* Expression list appears in the middle of code block is not allowed. For codes like:
316
317```Moonscript
318-- Moonscript 0.5.0
319f = (x)->
320 "abc",123 -- valid meaningless codes
321 x + 1
322```
323
324in original Moonscript compiles to:
325
326```Lua
327local f
328f = function(x)
329 local _ = "abc", 123 -- report error in MoonPlus
330 return x + 1
331end
332```
333
334This feature may lead to some silenced errors. For example:
335
336```Moonscript
337-- expected codes
338tree\addChild with Node!
339 \addChild subNode
340
341-- in original Moonscript, codes will still run
342-- after adding a break by mistake
343tree\addChild
344with Node!
345 \addChild subNode
346```
347
348the original Moonscript will compile these codes to:
349
350```Lua
351-- expected codes
352tree:addChild((function()
353 do
354 local _with_0 = Node()
355 _with_0:addChild(subNode)
356 return _with_0
357 end
358end)())
359
360-- codes added with a break will still run
361local _ -- report error in MoonPlus instead of creating
362do -- an anonymous function to bind the object method
363 local _base_0 = tree
364 local _fn_0 = _base_0.addChild
365 _ = function(...)
366 return _fn_0(_base_0, ...)
367 end
368end
369do
370 local _with_0 = Node()
371 _with_0:addChild(subNode)
372end
373```
374
375* Reusing variables which helps generate reduced Lua codes.
376
377 For example, MoonPlus will generate codes from:
378
379```Moonscript
380with leaf
381 .world 1,2,3
382
383with leaf
384 g = .what.is.this
385 print g
386
387for x in *something
388 print x
389```
390
391&emsp;&emsp;to:
392
393```Lua
394leaf.world(1, 2, 3)
395do
396 local g = leaf.what.is.this
397 print(g)
398end
399for _index_0 = 1, #something do
400 local x = something[_index_0]
401 print(x)
402end
403```
404
405&emsp;&emsp;instead of:
406
407```lua
408do
409 local _with_0 = leaf
410 _with_0.world(1, 2, 3)
411end
412do
413 local _with_0 = leaf
414 local g = _with_0.what.is.this
415end
416local _list_0 = something
417for _index_0 = 1, #_list_0 do
418 local x = _list_0[_index_0]
419 print(x)
420end
421```
422
423
424
425## v0.0.1
426
427Implemented full features from Moonscript 0.5.0.