Io is a dynamic prototype-based programming language. The ideas in Io are mostly inspired by Smalltalk[1] (all values are objects), Self[2] (prototype-based), NewtonScript[3] (differential inheritance), Act1[4] (actors and futures for concurrency), Lisp[5] (code is a runtime inspectable / modifiable tree) and Lua[6] (small, embeddable).

The focus of programming language research for the last thirty years has been to combine the high level expressive power of Smalltalk and the performance of low level languages with little attention paid to advancing expressive power itself. Io’s purpose is to refocus attention on expressiveness by exploring higher level dynamic programming features with greater levels of runtime flexibility and simplified programming syntax and semantics.

 

In Io, all values are objects (of which, anything can change at runtime, including slots, methods and inheritance), all code is made up of expressions (which are runtime inspectable and modifiable) and all expressions are made up of dynamic message sends (including assignment and control structures). Execution contexts themselves are objects and activatable objects such as methods/blocks and functions are unified into blocks with assignable scope. Concurrency is made more easily manageable through actors and implemented using coroutines for scalability.

To be a language that is:

 

Io distributions are available at:

 

To build, from the top folder, run:

 

 

Binaries will be placed in the _build/binaries subfolder. To install:

 

 

or, if you’d like the install to simply link to your development folder:

 

 

and to run the unit tests:

 

Some of Io’s addons require libraries that may not be installed on your system already. To install these automatically, type either:

 

 

or:

 

 

or:

 

 

Depending on which package installer you use. Port is macports/darwinports (http://www.macports.org/) for OSX.

Io builds two executables and places them in the binaries folder. They are:

 

 

The io_static executable contains the vm with a minimal set of primitives all statically linked into the executable. The io executable contains just enough to load the iovm dynamically linked library and is able to dynamically load io addons when they are referenced.

An example of running a script:

 

 

There is no main() function or object that gets executed first in Io. Scripts are executed when compiled.

Running:

 

 

Or, if Io is installed, running:

 

 

will open the Io interpreter prompt.

 

You can evaluate code by entering it directly. Example:

 

 

Expressions are evaluated in the context of the Lobby:

 

 

If you have a .iorc file in your home folder, it will be evaled before the interactive prompt starts. Also, rlwrap can be used to add line history features:

 

You can get a list of the slots of an object like this:

 

 

To show them in sorted order:

 

 

A script can be run from the interactive mode using the doFile method:

 

 

The evaluation context of doFile is the receiver, which in this case would be the lobby. To evaluate the script in the context of some other object, simply send the doFile message to it:

 

 

The doString method can be used to evaluate a string:

 

 

And to evaluate a string in the context of a particular object:

 

Example of printing out command line arguments:

 

The Lobby "launchPath" slot is set to the location on the initial source file that is executed.

 

 

 

exp message arguments symbol terminator

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

 

 

 

 

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

 

 

Methods like map and select will typically apply the expression directly to the values if only the expression is provided:

 

 

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:

 

 

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:

 

 

This just gets compiled into the normal message:

 

 

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

 

 

Standard operators follow C's precedence order, so:

 

 

Is parsed as:

 

 

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

Io has two assignment messages, “:=” and “=”.

 

which compiles to:

 

 

which creates the slot in the current context. And:

 

which compiles to:

 

 

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.

 

The following are valid number formats:

 

 

Hex numbers are also supported (in any casing):

 

 

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

 

 

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

 

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

 

 

The "#" style is useful for unix scripts:

 

 

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.

 

 

 

Io’s guiding design principle is simplicity and power through conceptual unification.

 

concept prototypes messages blocks with assignable scope

unifies objects, classes, namespaces, locals functions, operators, calls, assignment, variable accesses methods, closures, functions

 

New objects are made by cloning existing ones. A clone is an empty object that has the parent in it’s list of protos. A new instance’s init slot will be activated which gives the object a chance to initialize itself. Like NewtonScript[3], slots in Io are create-on-write.

 

 

To add an instance variable or method, simply set it:

 

 

When an object is cloned, its "init" slot will be called if it has one.

 

Since there are no classes, there's no difference between a subclass and an instance. Here’s an example of creating a the equivalent of a subclass:

 

 

The above code sets the Lobby slot "Dog" to a clone of the Object object. Notice it only contains a protos list contains a reference to Object. Dog is now essentially a subclass of Object. Instance variables and methods are inherited from the proto. If a slot is set, it creates a new slot in our object instead of changing the proto:

 

You can add any number of protos to an object's protos list. When responding to a message, the lookup mechanism does a depth first search of the proto chain.

A method is an anonymous function which, when called, creates an object to store it's locals and sets the local’s proto pointer and it’s self slot to the target of the message. The Object method method() can be used to create methods. Example:

 

 

An example of using a method in an object:

 

 

The above code creates a new "subclass" of object named Dog and adds a bark slot containing a block that prints "woof!". Example of calling this method:

 

 

The default return value of a block is the  result of the last expression.

Methods can also be defined to take arguments. Example:

 

 

The general form is:

 

A block is the same as a method except it is lexically scoped. That is, variable lookups continue in the context of where the block was created instead of the target of the message which activated the block. A block can be created using the Object method block(). Example of creating a block:

 

This is sometimes a source of confusion so it's worth explaining in detail. Both methods and blocks create an object to hold their locals when they are called. The difference is what the "proto" and "self" slots of that locals object are set to. In a method, those slots are set to the target of the message. In a block, they're set to the locals object where the block was created. So a failed variable lookup in a block's locals continue in the locals where it was created. And a failed variable lookup in a method's locals continue in the object to which the message that activated it was sent.

When a locals object is created, it’s self slot is set (to the target of the message, in the case of a method, or to the creation context, in the case of a block) and it’s call slot is set to a Call object that can be used to access information about the block activation:

 

slot call sender call message call activated call slotContext call target

returns locals object of caller message used to call this method/block the activated method/block context in which slot was found current object

The “call message” slot in locals can be used to access the unevaluated argument messages. Example of implementing if() within Io:

 

 

The doMessage() method evaluates the argument in the context of the receiver.

 

A shorter way to express this is to use the evalArgAt() method on the call object:

 

 

 

If an object doesn't respond to a message, it will invoke its "forward" method if it has one. Here’s an example of how to print the information related lookup that failed:

 

Sends the current message to the receiver's proto with the context of self. Example:

 

 

will print:

 

 

For sending other messages to the receiver's proto, super is used.

Sometimes it's necessary to send a message directly to a proto. Example:

 

 

Both resend and super are implemented in Io.

Using the following methods you can introspect the entire Io namespace. There are also methods for modifying any and all of these attributes at runtime.

The slotNames method returns a list of the names of an object’s slots:

 

The protos method returns a list of the objects which an object inherits from:

 

 

 

 

 

Here, the target of the getSlot method is the locals object.

The arguments and expressions of methods are open to introspection. A useful convenience method is “code”, which returns a string representation of the source code of the method in a normalized form.

 

 

The standard comparison operations (==, !=, >=, <=, >, <) return either the true or false.

 

The Lobby contains the condition and loop methods. A condition looks like:

 

 

Example:

 

 

The else argument is optional. The condition is considered false if the condition expression evaluates to false or nil, and is considered true otherwise.

The result of the evaluated message is returned, so:

 

 

is the same as:

 

 

Conditions can also be used in this form (though not as efficiently):

 

 

Else-if is supported:

 

 

As well as Smalltalk style ifTrue, ifFalse, ifNil and ifNonNil methods:

 

 

Notice that the condition expression must have parenthesis surrounding it.

 

The loop method can be used for “infinite” loops:

 

Like conditions, loops are just messages. while() takes the arguments:

 

 

Example:

 

for() takes the arguments:

 

 

The start and end messages are only evaluated once, when the loop starts.

 

Example:

 

 

Example with a step:

 

 

Which would print:

 

 

To reverse the order of the loop, add a negative step:

 

 

Note: the first value will be the first value of the loop variable and the last will be the last value on the final pass through the loop. So a loop of 1 to 10 will loop 10 times and a loop of 0 to 10 will loop 11 times.

 

Example of using a block in a loop:

 

The Number repeat method is simpler and more efficient when a counter isn’t needed.

 

The flow control operations break and continue are supported in loops. For example:

 

 

Would print:

 

Any part of a block can return immediately using the return method. Example:

 

The Importer proto implements Io’s built-in auto importer feature. If you put each of your proto’s in their own file, and give the file the same name with and “.io” extension, the Importer will automatically import that file when the proto is first referenced. The Importer’s default search path is the current working directory, but can add search paths using it’s addSearchPath() method.

 

The Scheduler object is responsible for resuming coroutines that are yielding. The current scheduling system uses a simple first-in-first-out policy with no priorities.

An actor is an object with it's own thread (in our case, it’s own coroutine) which it uses to process it's queue of asynchronous messages. Any object in Io can be sent an asynchronous message by placing a @ or @@ before the message name. (think of the "a" in @ as standing for "asynchronous")

 

Example:

 

 

 

When an object receives an asynchronous message it puts the message in its queue and, if it doesn't already have one, starts a coroutine to process the messages in its queue. Queued messages are processed sequentially in a first-in-first-out order. Control can be yielded to other coroutines by calling "yield". Example:

 

 

This would print "112233".

 

Here's a more real world example:

 

 

An object will automatically yield between processing each of its asynchronous messages. The yield method only needs to be called if a yield is required during an asynchronous message execution.

It's also possible to pause and resume an object. See the concurrency methods of the Object primitive for details and related methods.

Io's futures are transparent. That is, when the result is ready, they become the result. If a message is sent to a future (besides the two methods it implements), it waits until it turns into the result before processing the message. Transparent futures are powerful because they allow programs minimize blocking while also freeing the programmer from managing the fine details of synchronization.

The @ or @@ before an asynchronous message is just a normal operator message. So:

 

 

Gets parsed as(and can be written as):

 

 

 

 

 

An exception can be raised by calling raise() on an exception proto.

 

 

There are three predefined children of the Exception proto: Error, Warning and Notification. Examples:

 

To catch an exception, the try() method of the Object proto is used. try() will catch any exceptions that occur within it and return the caught exception or nil if no exception is caught.

 

 

To catch a particular exception, the Exception catch() method can be used. Example:

 

 

The first argument to catch indicates which types of exceptions will be caught. catch() returns the exception if it doesn't match and nil if it does.

To re-raise an exception caught by try(), use the pass method. This is useful to pass the exception up to the next outer exception handler, usually after all catches failed to match the type of the current exception:

 

 

Custom exception types can be implemented by simply cloning an existing Exception type:

 

 

Primitives are objects built into Io whose methods are typically implemented in C and store some hidden data in their instances. For example, the Number primitive has a double precision floating point number as it's hidden data and it’s methods that do arithmetic operations are C functions. All Io primitives inherit from the Object prototype and are mutable. That is, their methods can be changed. The reference docs contain more info on primitives.

 

Sometimes it's desirable to conditionally call a method only if it exists (to avoid raising an exception). Example:

 

 

Putting a "?" before a message has the same effect:

 

A List is an array of references and supports all the standard array manipulation and enumeration methods. Examples:

 

Create an empty list:

 

 

 

 

Append an item:

 

 

Get the list size:

 

 

 

 

Note: List indexes begin at zero and nil is returned if the accessed index doesn’t exist.

 

 

 

 

Remove an item at a given index:

 

 

 

 

The foreach, map and select methods can be used in three forms:

 

 

 

 

The second form removes the index argument:

 

 

The third form removes the value argument and simply sends the expression as a message to each value:

 

Io's map and select (known as filter in some other languages) methods allow arbitrary expressions as the map/select predicates.

 

 

The map and select methods return new lists. To do the same operations in-place, you can use selectInPlace() and mapInPlace() methods.

Getting the length of a string:

 

 

Checking if a string contains a substring:

 

 

Getting the character (byte) at position N:

 

 

Slicing:

 

 

 

 

Stripping whitespace:

 

 

 

Converting to upper/lowercase:

 

 

Splitting a string:

 

 

 

Converting to number:

 

 

String interpolation:

 

 

Each object that can be used in Ranges needs to implement a "nextInSequence" method which takes a single optional argument (the number of items to skip in the sequence of objects), and return the next item after that skip value. The default skip value is 1. The skip value of 0 is undefined. An example:

 

 

With this method on Number (it’s already there in the standard libraries), you can then use Numbers in Ranges, as demonstrated below:

 

 

The above will print 1 through 5, each on its own line.

Tthe methods openForAppending, openForReading, or openForUpdating are used for opening files. To erase an existing file before opening a new open, the remove method can be used. Example:

 

Creating a directory object:

 

 

Get a list of file objects for all the files in a directory:

 

 

Get a list of both the file and directory objects in a directory:

 

 

 

Setting a Directory object to a certain directory and using it:

 

 

Testing for existance:

 

 

Getthing the current working directory:

 

Creating a new date instance:

 

 

Setting it to the current date/time:

 

 

Getting the date/time as a number, in seconds:

 

 

 

Getting individual parts of a Date object:

 

 

 

 

 

 

 

 

 

Find how long it takes to execute some code:

 

 

 

All of Io’s networking is done with asynchronous sockets underneath, but operations like reading and writing to a socket appear to be synchronous since the calling coroutine is unscheduled until the socket has completed the operation, or a timeout occurs. Note that you’ll need to first reference the associated addon in order to cause it to load before using it’s objects. In these examples, you’ll have to reference “Socket” to get the Socket addon to load first.

 

 

 

Fetching an URL:

 

Streaming a URL to a file:

 

 

A simple whois client:

 

 

A minimal web server:

 

Using the XML parser to find the links in a web page:

 

 

Io’s C code is written using object oriented style conventions where structures are treated as objects and functions as methods. Familiarity with these may help make the embedding APIs easier to understand.

Member names are words that begin with a lower case character with successive words each having their first character upper cased. Acronyms are capitalized. Structure names are words with their first character capitalized.

 

Example:

 

Function names begin with the name of structure they operate on followed by an underscore and the method name. Each structure has a new and free function.

 

Example:

 

 

All methods (except new) have the structure (the "object") as the first argument the variable is named "self". Method names are in keyword format. That is, for each argument, the method name has a description followed by an underscore. The casing of the descriptions follow that of structure member names.

 

Examples:

 

Each structure has it's own separate .h and .c files. The names of the files are the same as the name of the structure. These files contain all the functions(methods) that operate on the given structure.

 

 

An IoState can be thought of as an instance of an Io “virtual machine”, although “virtual machine” is a less appropriate term because it implies a particular type of implementation.

Io is multi-state, meaning that it is designed to support multiple state instances within the same process. These instances are isolated and share no memory so they can be safely accessed simultaneously by different os threads, though a given state should only be accessed by one os thread at a time.

Here’s a simple example of creating a state, evaluating a string in it, and freeing the state:

 

We can also get return values and look at their types and print them:

 

There are some macro short cuts to help with quick type checks:

 

 

Note that return values are always proper Io objects (as all values are objects in Io). You can find the C level methods (functions like IoList_rawSize()) for these objects in the header files in the folder Io/libs/iovm/source.

forthcoming..

 

 

 

Io is the product of all the talented folks who taken the time and interest to make a contribution. The complete list of contributors is difficult to keep track of, but some of the recent major contributors include; Jonathan Wright, Jeremy Tregunna, Mike Austin, Chris Double, Oliver Ansaldi, Baptist Heyman, Ken Kerahone, Christian Thater, Brian Mitchell, Zachary Bir and many more. The mailing list archives, repo inventory and release history are probably the best sources for a more complete record of individual contributions.

 

 

1       2       3       4       5       6

Goldberg, A et al. Smalltalk-80: The Language and Its Implementation Addison-Wesley, 1983   Ungar, D and Smith, RB. Self: The Power of Simplicity OOPSLA, 1987   Smith, W. Class-based NewtonScript Programming PIE Developers magazine, Jan 1994   Lieberman H. Concurrent Object-Oriented Programming in Act 1 MIT AI Lab, 1987   McCarthy, J et al. LISP I programmer's manual MIT Press, 1960   Ierusalimschy, R, et al.      Lua: an extensible extension language John Wiley & Sons, 1996

 

Copyright 2006 Steve Dekorte. All rights reserved.

 

Redistribution and use of this document with or without modification, are permitted provided that the copies reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

 

This documentation is provided "as is" and any express or implied warranties, including, but not limited to, the implied warranties of merchantability and fitness for a particular purpose are disclaimed. In no event shall the Io documentation project be liable for any direct, indirect, incidental, special, exemplary, or consequential damages (including, but not limited to, procurement of substitute goods or services; loss of use, data, or profits; or business interruption) however caused and on any theory of liability, whether in contract, strict liability, or tort (including negligence or otherwise) arising in any way out of the use of this documentation, even if advised of the possibility of such damage.