Syntax examples

-- Comments have two dashes in front of them.

-- Plain values look like this:
an_integer = 1
a_float = 5.0
a_string = "hello"
another_string = 'hi'
a_bool = true
a_hex_integer = 0xff00ff00

-- Function calls look like this:
sum = add(1,3)
print('hello')

-- Function arguments can be separated by commas, semicolons, or just spaces
s = add(1 2 3 4)
s2 = add(4; 3; 2; 1)
print('the result is: ' s+s2)

-- The -> operator is like a function call, it sends the term on the left as an input to
-- the function on the right
'hello' -> print

-- The @ operator is some syntactic sugar for rebinding an identifier to the result of the
-- overall statement.
-- These two lines do exactly the same thing:
my_number = max(my_number, 40)
max(@my_number, 40)

-- Lists are indicated by []s
-- List arguments also can be separated by commas or semicolons or spaces
names = ['Absalom','Bouffant','Chilton']
numbers = [1 2 3]
orders = [locate; evacuate; exterminate]

-- Compound types can be declared
type Point { float x, float y }

p = Point(2,3)

-- Named fields are accessed with a dot
p.x = p.y + 1

-- We can also reinterpret a list to have a given type, using the
-- colon operator. (Circa will check to make sure that the given
-- list fits this type)
untyped_list = [1 2]
untyped_list.x = 0  -- this doesn't work, we don't know which field 'x' is
as_point = untyped_list : Point
as_point.x = 0      -- this does work!

-- If blocks look like this.
-- (Blocks generally end with the 'end' keyword. Indentation is not significant)
if health < 20
  print('Warning!')
end

-- For loops iterate over a list
for x in range(10)
  print(x)
end

-- Functions can be declared
-- The return type is given by a trailing colon and type name
-- Values can be returned with the 'return' statement.
def sqr(float x): float
   return x*x
end

def polar2cartesian(float angle, float dist, Point center) : Point
  return [cos(angle), sin(angle)] * dist + center
end

-- Return types are optional
def log_warn(string msg)
  print('warn: ' msg)
end

-- When calling a function that expects a compound type, you can
-- be lazy and just write it as a list. The parser will give an error
-- if the list doesn't fit in that type.
p = polar2cartesian(PI, 1, [5 5])

-- "Stateful" values can be declared with the state keyword.
-- These values are preserved across iterations of a loop. They're also preserved
-- across a script reload.
state a = 5
state loc = [10 10] : Point

-- We also have the +=, -=, *=, /= operators
a += 2

-- That's pretty much it.