MoonScript Documentation

MoonScript is a programmer-friendly language that compiles into Lua. It provides a rich feature set while leveraging the performance of Lua. It is compatible with Lua 5.1 and above, including alternative runtimes like LuaJIT.

• Online Compiler: https://moonscript.org/compiler
• Official Website: https://moonscript.org

MoonScript is supported across several text editors via specific plugins or modes:

• Vim: moonscript-vim
• Textadept: moonscript-textadept
• Sublime/Textmate: moonscript-tmbundle
• Emacs: moonscript-mode

MoonScript files implicitly return the value of the last statement. To define a module, place a table containing your exported functions and constants as the final statement in the file. To allow forward declarations (accessing variables regardless of order), add local * to the top of the file.

MY_CONSTANT = "hello"

my_function = -> print "the function"

{ :my_function, :MY_CONSTANT}

MoonScript supports dynamic typing and multiple assignments.

• Local Variables: Assigning to an undeclared name creates a new local variable.
• Multiple Assignment: You can assign multiple names and values at once (e.g., a, b, c = 1, 2, 3).
• Global Variables: Use the export keyword to create a global variable.
• Forward Declaration/Shadowing: Use the local keyword to forward declare a variable or shadow an existing one.

hello = "world"
a,b,c = 1, 2, 3
hello = 123 -- uses the existing variable

export global_var = 10
local my_local = 5

To split a large argument list over multiple lines:

1. End the current line with a comma.
2. Indent the following line more than the current line.
3. All subsequent argument lines must share the same indentation level.

This indentation-based approach also works for nesting function calls and block-level statements like if.

my_func 5,4,3,
  8,9,10

cool_func 1,2,
  3,4,
  5,6,
  7,8

-- Nested calls
my_func 5,6,7,
  6, another_func 6,7,8,
    9,1,2,
  5,4

Precompiled versions of MoonScript are available for Windows users. You can find these under the win32- tags on the GitHub releases page.

https://github.com/leafo/moonscript/releases

MoonScript provides several ways to handle conditional logic:

• if/else: Standard conditional blocks. Can be used as expressions: print if condition then "a" else "b".
• unless: The inverse of if. Executes if the condition is false.
• Assignment in Conditionals: if and elseif can perform an assignment. The assigned variable is only in scope for the body of that conditional block.
• switch: A shorthand for multiple if checks against the same value. Supports multiple values per when clause (comma-separated) and an else block. Can also be used as an expression.
• Line Decorators: Single-statement conditionals can be placed at the end of a line: print "hi" if condition.

To run the MoonScript test suite, which handles the necessary compilation and environment setup for development, use the following make command:

make test

MoonScript is a whitespace-sensitive language. Instead of using delimiters like do/end or {/}, it uses line breaks and indentation to define code blocks.

• Indentation must be at least 1 space or 1 tab.
• You must be consistent with your indentation.
• A tab is treated as equivalent to 4 spaces.

When developing MoonScript, your system-installed version may take precedence over your local development version during testing. To ensure that require calls within your specs load the MoonScript modules from your current working directory instead of the system install, use the with_dev helper.

Important: with_dev replaces _G.require with a version that only loads .lua files. You must compile your local .moon files into .lua files before running tests with this helper.

import with_dev from require "spec.helpers"
describe "moonscript.base", ->
  with_dev!

  it "should load code", ->
    -- the local version is loaded
    moonscript = require "moonscript"
    moonscript.load "print 12"