-
Notifications
You must be signed in to change notification settings - Fork 191
Learn MoonScript in 15 Minutes
safazi edited this page Sep 20, 2019
·
20 revisions
-- Two dashes start a comment. Comments can go until the end of the line.
-- MoonScript transpiled to Lua does not keep comments.
-- As a note, MoonScript does not use 'do', 'then', or 'end' like Lua would and
-- instead uses an indented syntax, much like Python.
--------------------------------------------------
-- 1. Assignment
--------------------------------------------------
hello = "world"
a, b, c = 1, 2, 3
hello = 123 -- Overwrites `hello` from above.
x = 0
x += 10 -- x = x + 10
s = "hello "
s ..= "world" -- s = s .. "world"
b = false
b and= true or false -- b = b and (true or false)
--------------------------------------------------
-- 2. Literals and Operators
--------------------------------------------------
-- Literals work almost exactly as they would in Lua. Strings can be broken in
-- the middle of a line without requiring a \.
some_string = "exa
mple" -- local some_string = "exa\nmple"
-- Strings can also have interpolated values, or values that are evaluated and
-- then placed inside of a string.
some_string = "This is an #{some_string}" -- Becomes 'This is an exa\nmple'
--------------------------------------------------
-- 2.1. Function Literals
--------------------------------------------------
-- Functions are written using arrows:
my_function = -> -- compiles to `function() end`
my_function() -- calls an empty function
-- Functions can be called without using parenthesis. Parentheses may still be
-- used to have priority over other functions.
func_a = -> print "Hello World!"
func_b = ->
value = 100
print "The value: #{value}"
-- If a function needs no parameters, it can be called with either `()` or `!`.
func_a!
func_b()
-- Functions can use arguments by preceding the arrow with a list of argument
-- names bound by parentheses.
sum = (x, y)-> x + y -- The last expression is returned from the function.
print sum(5, 10)
-- Lua has an idiom of sending the first argument to a function as the object,
-- like a 'self' object. Using a fat arrow (=>) instead of a skinny arrow (->)
-- automatically creates a `self` variable. `@x` is a shorthand for `self.x`.
func = (num)=> @value + num
-- Default arguments can also be used with function literals:
a_function = (name = "something", height=100)->
print "Hello, I am #{name}.\nMy height is #{height}."
-- Because default arguments are calculated in the body of the function when
-- transpiled to Lua, you can reference previous arguments.
some_args = (x = 100, y = x + 1000)-> print(x + y)
--------------------------------------------------
-- Considerations
--------------------------------------------------
-- The minus sign plays two roles, a unary negation operator and a binary
-- subtraction operator. It is recommended to always use spaces between binary
-- operators to avoid the possible collision.
a = x - 10 -- a = x - 10
b = x-10 -- b = x - 10
c = x -y -- c = x(-y)
d = x- z -- d = x - z
-- When there is no space between a variable and string literal, the function
-- call takes priority over following expressions:
x = func"hello" + 100 -- func("hello") + 100
y = func "hello" + 100 -- func("hello" + 100)
-- Arguments to a function can span across multiple lines as long as the
-- arguments are indented. The indentation can be nested as well.
my_func 5, -- called as my_func(5, 8, another_func(6, 7, 9, 1, 2), 5, 4)
8, another_func 6, 7, -- called as
9, 1, 2, -- another_func(6, 7, 9, 1, 2)
5, 4
-- If a function is used at the start of a block, the indentation can be
-- different than the level of indentation used in a block:
if func 1, 2, 3, -- called as func(1, 2, 3, "hello", "world")
"hello",
"world"
print "hello"
--------------------------------------------------
-- 3. Tables
--------------------------------------------------
-- Tables are defined by curly braces, like Lua:
some_values = {1, 2, 3, 4}
-- Tables can use newlines instead of commas.
some_other_values = {
5, 6
7, 8
}
-- Assignment is done with `:` instead of `=`:
profile = {
name: "Bill"
age: 200
"favorite food": "rice"
}
-- Curly braces can be left off for `key: value` tables.
y = type: "dog", legs: 4, tails: 1
profile =
height: "4 feet",
shoe_size: 13,
favorite_foods: -- nested table
foo: "ice cream",
bar: "donuts"
my_function dance: "Tango", partner: "none" -- :( forever alone
-- Tables constructed from variables can use the same name as the variables
-- by using `:` as a prefix operator.
hair = "golden"
height = 200
person = {:hair, :height}
-- Like in Lua, keys can be non-string or non-numeric values by using `[]`.
t =
[1 + 2]: "hello"
"hello world": true -- Can use string literals without `[]`.
--------------------------------------------------
-- 3.1. Table Comprehensions
--------------------------------------------------
-- List Comprehensions
-- Creates a copy of a list but with all items doubled. Using a star before a
-- variable name or table can be used to iterate through the table's values.
items = {1, 2, 3, 4}
doubled = [item * 2 for item in *items]
-- Uses `when` to determine if a value should be included.
slice = [item for item in *items when i > 1 and i < 3]
-- `for` clauses inside of list comprehensions can be chained.
x_coords = {4, 5, 6, 7}
y_coords = {9, 2, 3}
points = [{x,y} for x in *x_coords for y in *y_coords]
-- Numeric for loops can also be used in comprehensions:
evens = [i for i=1, 100 when i % 2 == 0]
-- Table Comprehensions are very similar but use `{` and `}` and take two
-- values for each iteration.
thing = color: "red", name: "thing", width: 123
thing_copy = {k, v for k, v in pairs thing}
-- Tables can be "flattened" from key-value pairs in an array by using `unpack`
-- to return both values, using the first as the key and the second as the
-- value.
tuples = {{"hello", "world"}, {"foo", "bar"}}
table = {unpack tuple for tuple in *tuples}
-- Slicing can be done to iterate over only a certain section of an array. It
-- uses the `*` notation for iterating but appends `[start, end, step]`.
-- The next example also shows that this syntax can be used in a `for` loop as
-- well as any comprehensions.
for item in *points[1, 10, 2]
print unpack item
-- Any undesired values can be left off. The second comma is not required if
-- the step is not included.
words = {"these", "are", "some", "words"}
for word in *words[,3]
print word
--------------------------------------------------
-- 4. Control Structures
--------------------------------------------------
have_coins = false
if have_coins
print "Got coins"
else
print "No coins"
-- Use `then` for single-line `if`
if have_coins then "Got coins" else "No coins"
-- `unless` is the opposite of `if`
unless os.date("%A") == "Monday"
print "It is not Monday!"
-- `if` and `unless` can be used as expressions
is_tall = (name)-> if name == "Rob" then true else false
message = "I am #{if is_tall "Rob" then "very tall" else "not so tall"}"
print message -- "I am very tall"
-- `if`, `elseif`, and `unless` can evaluate assignment as well as expressions.
if x = possibly_nil! -- sets `x` to `possibly_nil()` and evaluates `x`
print x
-- Conditionals can be used after a statement as well as before. This is
-- called a "line decorator".
is_monday = os.date("%A") == "Monday"
print("It IS Monday!") if isMonday
print("It is not Monday..") unless isMonday
--print("It IS Monday!" if isMonday) -- Not a statement, does not work
--------------------------------------------------
-- 4.1 Loops
--------------------------------------------------
for i = 1, 10
print i
for i = 10, 1, -1 do print i -- Use `do` for single-line loops.
i = 0
while i < 10
continue if i % 2 == 0 -- Continue statement; skip the rest of the loop.
print i
-- Loops can be used as a line decorator, just like conditionals
print "item: #{item}" for item in *items
-- Using loops as an expression generates an array table. The last statement
-- in the block is coerced into an expression and added to the table.
my_numbers = for i = 1, 6 do i -- {1, 2, 3, 4, 5, 6}
-- use `continue` to filter out values
odds = for i in *my_numbers
continue if i % 2 == 0 -- acts opposite to `when` in comprehensions!
i -- Only added to return table if odd
-- A `for` loop returns `nil` when it is the last statement of a function
-- Use an explicit `return` to generate a table.
print_squared = (t) -> for x in *t do x*x -- returns `nil`
squared = (t) -> return for x in *t do x*x -- returns new table of squares
-- The following does the same as `(t) -> [i for i in *t when i % 2 == 0]`
-- But list comprehension generates better code and is more readable!
filter_odds = (t) ->
return for x in *t
if x % 2 == 0 then x else continue
evens = filter_odds(my_numbers) -- {2, 4, 6}
--------------------------------------------------
-- 4.2 Switch Statements
--------------------------------------------------
-- Switch statements are a shorthand way of writing multiple `if` statements
-- checking against the same value. The value is only evaluated once.
name = "Dan"
switch name
when "Dave"
print "You are Dave."
when "Dan"
print "You are not Dave, but Dan."
else
print "You are neither Dave nor Dan."
-- Switches can also be used as expressions, as well as compare multiple
-- values. The values can be on the same line as the `when` clause if they
-- are only one expression.
b = 4
next_even = switch b
when 1 then 2
when 2, 3 then 4
when 4, 5 then 6
else error "I can't count that high! D:"
--------------------------------------------------
-- 5. Object Oriented Programming
--------------------------------------------------
-- Classes are created using the `class` keyword followed by an identifier,
-- typically written using CamelCase. Values specific to a class can use @ as
-- the identifier instead of `self.value`.
class Inventory
new: => @items = {}
add_item: (name)=> -- note the use of fat arrow for classes!
@items[name] = 0 unless @items[name]
@items[name] += 1
-- The `new` function inside of a class is special because it is called when
-- an instance of the class is created.
-- Creating an instance of the class is as simple as calling the class as a
-- function. Calling functions inside of the class uses \ to separate the
-- instance from the function it is calling.
inv = Inventory!
inv\add_item "t-shirt"
inv\add_item "pants"
-- Values defined in the class - not the new() function - will be shared across
-- all instances of the class.
class Person
clothes: {}
give_item: (name)=>
table.insert @clothes, name
a = Person!
b = Person!
a\give_item "pants"
b\give_item "shirt"
-- prints out both "pants" and "shirt"
print item for item in *a.clothes
-- Class instances have a value `.__class` that are equal to the class object
-- that created the instance.
assert(b.__class == Person)
-- Variables declared in class body the using the `=` operator are locals,
-- so these "private" variables are only accessible within the current scope.
class SomeClass
x = 0
reveal: ->
x += 1
print x
a = SomeClass!
b = SomeClass!
print a.x -- nil
a.reveal! -- 1
b.reveal! -- 2
--------------------------------------------------
-- 5.1 Inheritance
--------------------------------------------------
-- The `extends` keyword can be used to inherit properties and methods from
-- another class.
class Backpack extends Inventory
size: 10
add_item: (name)=>
error "backpack is full" if #@items > @size
super name -- calls Inventory.add_item with `name`.
-- Because a `new` method was not added, the `new` method from `Inventory` will
-- be used instead. If we did want to use a constructor while still using the
-- constructor from `Inventory`, we could use the magical `super` function
-- during `new()`.
-- When a class extends another, it calls the method `__inherited` on the
-- parent class (if it exists). It is always called with the parent and the
-- child object.
class ParentClass
@__inherited: (child)=>
print "#{@__name} was inherited by #{child.__name}"
a_method: (a, b) => print a .. ' ' .. b
-- Will print 'ParentClass was inherited by MyClass'
class MyClass extends ParentClass
a_method: =>
super "hello world", "from MyClass!"
assert super == ParentClass
--------------------------------------------------
-- 6. Scope
--------------------------------------------------
-- All values are local by default. The `export` keyword can be used to
-- declare the variable as a global value.
export var_1, var_2
var_1, var_3 = "hello", "world" -- var_3 is local, var_1 is not.
export this_is_global_assignment = "Hi!"
-- Classes can also be prefixed with `export` to make them global classes.
-- Alternatively, all CamelCase variables can be exported automatically using
-- `export ^`, and all values can be exported using `export *`.
-- `do` lets you manually create a scope, for when you need local variables.
do
x = 5
print x -- nil
-- Here we use `do` as an expression to create a closure.
counter = do
i = 0
->
i += 1
return i
print counter! -- 1
print counter! -- 2
-- The `local` keyword can be used to define variables before they are assigned.
local var_4
if something
var_4 = 1
print var_4 -- works because `var_4` was set in this scope, not the `if` scope.
-- The `local` keyword can also be used to shadow an existing variable.
x = 10
if false
local x
x = 12
print x -- 10
-- Use `local *` to forward-declare all variables.
-- Alternatively, use `local ^` to forward-declare all CamelCase values.
local *
first = ->
second!
second = ->
print data
data = {}
--------------------------------------------------
-- 6.1 Import
--------------------------------------------------
-- Values from a table can be brought to the current scope using the `import`
-- and `from` keyword. Names in the `import` list can be preceded by `\` if
-- they are a module function.
import insert from table -- local insert = table.insert
import \add from state: 100, add: (value)=> @state + value
print add 22
-- Like tables, commas can be excluded from `import` lists to allow for longer
-- lists of imported items.
import
asdf, gh, jkl
antidisestablishmentarianism
from {}
--------------------------------------------------
-- 6.2 With
--------------------------------------------------
-- The `with` statement can be used to quickly call and assign values in an
-- instance of a class or object.
file = with File "lmsi15m.moon" -- `file` is the value of `set_encoding()`.
\set_encoding "utf8"
create_person = (name, relatives)->
with Person!
.name = name
\add_relative relative for relative in *relatives
me = create_person "Ryan", {"sister", "sister", "brother", "dad", "mother"}
with str = "Hello" -- assignment as expression! :D
print "original: #{str}"
print "upper: #{\upper!}"
--------------------------------------------------
-- 6.3 Destructuring
--------------------------------------------------
-- Destructuring can take arrays, tables, and nested tables and convert them
-- into local variables.
obj2 =
numbers: {1, 2, 3, 4}
properties:
color: "green"
height: 13.5
{numbers: {first, second}, properties: {:color}} = obj2
print first, second, color -- 1 2 green
-- `first` and `second` return [1] and [2] because they are as an array, but
-- `:color` is like `color: color` so it sets itself to the `color` value.
-- Destructuring can be used in place of `import`.
{:max, :min, random: rand} = math -- rename math.random to rand
-- Destructuring can be done anywhere assignment can be done.
for {left, right} in *{{"hello", "world"}, {"egg", "head"}}
print left, right