-- Comments start with two dashes

-- Function calls look like this
function(arg0, arg1)

-- Instead of declaring variables, you attach names to expressions
a = function(arg0, arg1)

-- There's infix operators
a = 1 - 2

-- Blocks start with keywords and end with 'end' (like Ruby)
if something
  do(something)
end

-- But I can't decide if blocks should have significant indentation like Python. What do you think?
if something:
  do(something)

-- Or possibly curly brackets
if something {
  do(something)
}

-- This is a function definition.
-- The language is statically typed, so each argument has a type name.
def my_func(int a, int b)
  do(something)
end

-- This is a function that returns something, the return type is declared with ->
def my_func(int a, int b) -> int
  return a - b
end

-- But maybe the 'return' should be optional, and the function should just return the last expression?
def my_func(int a, int b) -> int
  a - b
end

-- Also there are different possible ways to specify the return type
def my_func(int a, int b) { a - b }  -- implicit return type
def my_func(int a, int b) :: Int { return a - b } -- two colons like Haskell
int my_func(int a, int b) { return a - b }  -- return type name in front, C style

-- Here's a real function which draws a filled rectangle
-- The 'gl' part at the beginning of gl:triangles is a namespace
-- The square brackets indicate a list
def fill_rect(Rect rect, Color color)
    "Draw a filled rectangle."
    nw = [rect.x1 rect.y1]
    ne = [rect.x2 rect.y1]
    sw = [rect.x1 rect.y2]
    se = [rect.x2 rect.y2]
    gl:triangles([nw ne se se sw nw] color)
end

-- The -> operator is used to feed the input on the left to the function on the right.
-- It's there so that the writer can list the sequence of calls in left-to-right order
-- instead of right-to-left.
some_function() -> print
-- is the same as:
print(some_function())

-- The @ operator is shorthand that takes a name, and rebinds the overall result to
-- that name. It's there to make it easier to write a chain of expressions that
-- all operate on a certain name. Does this suck?
add(@a, 2)
-- is the same as:
a = add(a, 2)