MoonScript is a dynamic scripting language that compiles into
Lua. It gives you the power of one of the fastest
scripting languages combined with a rich set of features.
do
local _class_0
local _base_0 = {
name = “unknown”
}
_base_0.__index = _base_0
_class_0 = setmetatable({
__init = function() end,
__base = _base_0,
__name = “Thing”
}, {
__index = _base_0,
__call = function(cls, …)
local _self_0 = setmetatable({}, _base_0)
cls.__init(_self_0, …)
return _self_0
end
})
_base_0.__class = _class_0
Thing = _class_0
end
local Person
do
local _class_0
local _parent_0 = Thing
local _base_0 = {
say_name = function(self)
return print(“Hello, I am “ .. tostring(self.name) .. “!”)
end
}
_base_0.__index = _base_0
setmetatable(_base_0, _parent_0.__base)
_class_0 = setmetatable({
__init = function(self, …)
return _class_0.__parent.__init(self, …)
end,
__base = _base_0,
__name = “Person”,
__parent = _parent_0
}, {
__index = function(cls, name)
local val = rawget(_base_0, name)
if val == nil then
local parent = rawget(cls, “__parent”)
if parent then
return parent[name]
end
else
return val
end
end,
__call = function(cls, …)
local _self_0 = setmetatable({}, _base_0)
cls.__init(_self_0, …)
return _self_0
end
})
_base_0.__class = _class_0
if _parent_0.__inherited then
_parent_0.__inherited(_parent_0, _class_0)
end
Person = _class_0
end
do
local _with_0 = Person()
_with_0.name = “MoonScript”
_with_0:say_name()
end“>
class Thing
name: "unknown"
class Person extends Thing
say_name: => print "Hello, I am #{@name}!"
with Person!
.name = "MoonScript"
say_name!
MoonScript can either be compiled into Lua and run at a later time, or it can
be dynamically compiled and run using the moonloader. It’s as simple as
require "moonscript" in order to have Lua understand how to load and run any
MoonScript file.
Because it compiles right into Lua code, it is completely compatible with
alternative Lua implementations like LuaJIT, and it is
also compatible with all existing Lua code and libraries.
The command line tools also let you run MoonScript directly from the
command line, like any first-class scripting language.
A comprehensive overview of the language can be found in the reference
manual, the rest of this page serves as an overview of the
language.
Overview
MoonScript provides a clean syntax using significant whitespace that avoids all
the keyword noise typically seen in a Lua script. Below is a sample of some
constructs found in the language.
local collection = {
height = 32434,
hats = {
“tophat”,
“bball”,
“bowler”
}
}
my_func = function(a)
return x + a
end
print(my_func(100))“>
export my_func
x = 2323
collection =
height: 32434
hats: {"tophat", "bball", "bowler"}
my_func = (a) -> x + a
print my_func 100
It also adds table comprehensions, implicit return on functions, classes,
inheritance, scope management statements import & export, and a convenient
object creation statement called with.
do
local _obj_0 = table
concat, insert = _obj_0.concat, _obj_0.insert
end
local double_args
double_args = function(…)
local _accum_0 = { }
local _len_0 = 1
local _list_0 = {
…
}
for _index_0 = 1, #_list_0 do
local x = _list_0[_index_0]
_accum_0[_len_0] = x * 2
_len_0 = _len_0 + 1
end
return _accum_0
end
local tuples
do
local _accum_0 = { }
local _len_0 = 1
for k, v in ipairs(my_table) do
_accum_0[_len_0] = {
k,
v
}
_len_0 = _len_0 + 1
end
tuples = _accum_0
end“>
import concat, insert from table
double_args = (...) ->
[x * 2 for x in *{...}]
tuples = [{k, v} for k,v in ipairs my_table]
It can be loaded directly from a Lua script without an intermediate
compile step. It even knows how to tell you
where errors occurred in the original file when
they happen.
Installation
Installing with LuaRocks
If you’re on Windows, then install the Windows binaries,
otherwise the easiest way to install is to use LuaRocks.
LuaRocks can be obtained here or from your package
manager.
After it is installed, run the following in a terminal:
$ luarocks install moonscript
This will provide the moon and moonc executables along with the
moonscript and moon Lua module.
Windows Binaries
Precompiled Windows binaries are available to avoid the trouble of compiling:
moonscript.zip
Extract the contents into your PATH. You can also use the included
moonscript.dll to require the module in.
This version has been compiled against Lua 5.1.
Optional
If you’re on Linux and use watch mode (which compiles .moon files to .lua
files as they are changed) you can install
linotify to use inotify instead of
polling.
Source
The source code to the project lives on GitHub:
https://github.com/leafo/moonscript
Issues with the tool can be reported on the issue tracker:
https://github.com/leafo/moonscript/issues
The latest development version can be installed with the dev rockspec:
$ luarocks install
https://luarocks.org/manifests/leafo/moonscript-dev-1.rockspec
Dependencies
In addition to Lua 5.1 or 5.2, the following Lua modules are
required to run the compiler and associated tools:
- LPeg
- LuaFileSystem
- alt-getopt
- and optionally on Linux linotify
All of the required ones can be retrieved
