1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
# MoonPlus
MoonPlus is a compiler with features from [Moonscript language](https://github.com/leafo/moonscript) 0.5.0 and could be faster than the original Moonscript compiler.
## Features
* No other dependencies needed except modified **parserlib** library from Achilleas Margaritis with some performance enhancement. **lpeg** library is no longer needed.
* Written in C++17.
* Support full Moonscript language features, generate the same Lua codes with original compiler.
* Reserve line numbers from source Moonscript codes in compiled Lua codes to help with debugging.
## Changes
The original Moonscript language 0.5.0 support can be found in the `0.5.0` branch. Moonscript with new features is in the master branch. Here are the new features introduced in MoonPlus
* Multi-line comment.
* Usage for symbol `\` to escape new line. Will compile codes:
```Moonscript
str = --[[
This is a multi line comment.
It's OK.
]] strA \ -- comment 1
.. strB \ -- comment 2
.. strC
func --[[ip]] "192.168.126.110", --[[port]] 3000
```
  to:
```Lua
local str = strA .. strB .. strC
func("192.168.126.110", 3000)
```
* Back call features with new operator and syntax. For example:
```Moonscript
{1,2,3} \
|> map((x)-> x * 2) \
|> filter((x)-> x > 4) \
|> reduce(0, (a,b)-> a + b) \
|> print
do
(data) <- http.get "ajaxtest"
body[".result"]\html data
(processed) <- http.post "ajaxprocess", data
body[".result"]\append processed
print "done"
```
  will be compiled to:
```Lua
print(reduce(filter(map({
1,
2,
3
}, function(x)
return x * 2
end), function(x)
return x > 4
end), 0, function(a, b)
return a + b
end))
do
http.get("ajaxtest", function(data)
body[".result"]:html(data)
return http.post("ajaxprocess", data, function(processed)
body[".result"]:append(processed)
return print("done")
end)
end)
end
```
* Existential operator support. Generate codes from:
```Moonscript
func?!
x = tab?.value
print abc?["hello world"]?.xyz
if print and x?
print x
```
  to:
```Lua
if func ~= nil then
func()
end
local x
if tab ~= nil then
x = tab.value
end
print((function()
if abc ~= nil then
local _obj_0 = abc["hello world"]
if _obj_0 ~= nil then
return _obj_0.xyz
end
return nil
end
return nil
end)())
if print and (x ~= nil) then
print(x)
end
```
* More usages for `import` keyword. Will compile codes from:
```Moonscript
import 'module'
import "module.part"
import "d-a-s-h-e-s"
import "player" as Player
import "lpeg" as {:C, :Ct, :Cmt}
```
  to:
```Lua
local module = require('module')
local part = require("module.part")
local d_a_s_h_e_s = require("d-a-s-h-e-s")
local Player = require("player")
local C, Ct, Cmt
do
local _obj_0 = require("lpeg")
C, Ct, Cmt = _obj_0.C, _obj_0.Ct, _obj_0.Cmt
end
```
* Can do slash call with Lua keywords. Generate codes from:
```Moonscript
c.repeat.if\then("xyz")\else res
```
  to:
```Lua
local _call_3 = c["repeat"]["if"]
local _call_4 = _call_3["then"](_call_3, "xyz")
_call_4["else"](_call_4, res)
```
* Feature of `Reusing variable` which helps generate reduced Lua codes. For example, MoonPlus will generate codes from:
```Moonscript
with leaf
.world 1,2,3
with leaf
g = .what.is.this
print g
for x in *something
print x
```
  to:
```Lua
leaf.world(1, 2, 3)
do
local g = leaf.what.is.this
print(g)
end
for _index_0 = 1, #something do
local x = something[_index_0]
print(x)
end
```
  instead of:
```lua
do
local _with_0 = leaf
_with_0.world(1, 2, 3)
end
do
local _with_0 = leaf
local g = _with_0.what.is.this
end
local _list_0 = something
for _index_0 = 1, #_list_0 do
local x = _list_0[_index_0]
print(x)
end
```
## Standalone Compiler Usage
Test compiler with `make test`.
Run `moonp` complier in project folder with:
```shell
make
./moonp -h
```
## License
MIT
|
