Syntax
------

[Ludwig Mies van der Rohe]
_______________________________________
Less is more.
_______________________________________


Expressions
~~~~~~~~~~~

Io has no keywords or statements. Everything is an expression composed entirely of messages, each of which is a runtime accessible object. The informal BNF description:

---------------------------------------
exp          ::= { message | terminator }
message      ::= symbol [arguments]
arguments    ::= "(" [exp [ { "," exp } ]] ")"
symbol       ::= identifier | number | string
terminator   ::= "\n" | ";"
---------------------------------------

For performance reasons, String and Number literal messages have their results cached in their message objects.

Messages
~~~~~~~~

Message arguments are passed as expressions and evaluated by the receiver. Selective evaluation of arguments can be used to implement control flow. Examples:

---------------------------------------
for(i, 1, 10, i println)
a := if(b == 0, c + 1, d)
---------------------------------------

In the above code, "`for`" and "`if`" are just normal messages, not special forms or keywords.

Likewise, dynamic evaluation can be used with enumeration without the need to wrap the expression in a block. Examples:

---------------------------------------
people select(person, person age < 30)
names := people map(person, person name)
---------------------------------------

There is also some syntax sugar for operators (including assignment), which are handled by an Io macro executed on the expression after it is compiled into a message tree. Some sample source code:

---------------------------------------
Account := Object clone
Account balance := 0
Account deposit := method(amount,
    balance = balance + amount
)

account := Account clone
account deposit(10.00)
account balance println
---------------------------------------

Like Self <<self>>, Io’s syntax does not distinguish between accessing a slot containing a method from one containing a variable.


Operators
~~~~~~~~~

An operator is just a message whose name contains no alphanumeric characters (other than "`:`", "`_`", '`"`' or "`.`") or is one of the following words: `or`, `and`, `return`. Example:

---------------------------------------
1 + 2
---------------------------------------

This just gets compiled into the normal message:

---------------------------------------
1 +(2)
---------------------------------------

Which is the form you can use if you need to do grouping:

---------------------------------------
1 +(2 * 4)
---------------------------------------

Standard operators follow C's precedence order, so:

---------------------------------------
1 + 2 * 3 + 4
---------------------------------------

Is parsed as:

---------------------------------------
1 +(2 *(3)) +(4)
---------------------------------------

User defined operators (that don't have a standard operator name) are performed left to right.

Assignment
~~~~~~~~~~

Io has two assignment messages, "`:=`" and "`=`".

---------------------------------------
a := 1
---------------------------------------

which compiles to:

---------------------------------------
setSlot("a", 1)
---------------------------------------

which creates the slot in the current context. And:

---------------------------------------
a = 1
---------------------------------------

which compiles to:

---------------------------------------
updateSlot("a", 1)
---------------------------------------

which sets the slot if it is found in the lookup path or raises an exception otherwise. By overloading `updateSlot` and `forward` in the `Locals` prototype, `self` is made implicit in methods.

Numbers
~~~~~~~

The following are valid number formats:

---------------------------------------
123
123.456
0.456
.456
123e-4
123e4
123.456e-7
123.456e2
---------------------------------------

Hex numbers are also supported (in any casing):

---------------------------------------
0x0
0x0F
0XeE
---------------------------------------

Strings
~~~~~~~

Strings can be defined surrounded by a single set of double quotes with escaped quotes (and other escape characters) within.

---------------------------------------
s := "this is a \"test\".\nThis is only a test."
---------------------------------------

Or for strings with non-escaped characters and/or spanning many lines, triple quotes can be used.

---------------------------------------
s := """this is a "test".
This is only a test."""
---------------------------------------

Comments
~~~~~~~~

Comments of the `//`, `/**/` and `#` style are supported. Examples:

---------------------------------------
a := b // add a comment to a line

/* comment out a group
a := 1
b := 2
*/
---------------------------------------

The "#" style is useful for unix scripts:

---------------------------------------
#!/usr/local/bin/io
---------------------------------------

That's it! You now know everything there is to know about Io's syntax. Control flow, objects, methods, exceptions are expressed with the syntax and semantics described above.