Io is a pure object-oriented programming language inspired by Smalltalk, Self, Lua, Lisp, Act1, and NewtonScript.[2] Io has a prototype-based object model similar to the ones in Self and NewtonScript, eliminating the distinction between instance and class. Like Smalltalk, everything is an object and it uses dynamic typing. Like Lisp, programs are just data trees. Io uses actors for concurrency.
| This article needs additional citations for verification. (August 2014) |
Quick Facts Paradigm, Designed by ...
Io |
| Paradigm | object-oriented prototype-based |
|---|
| Designed by | Steve Dekorte |
|---|
| Developer | Steve Dekorte, Jonathan Wright, Jeremy Tregunna |
|---|
| First appeared | 2002; 22 years ago (2002) |
|---|
|
| Stable release | 20170906
/ August 11, 2017 ; 6 years ago (2017-08-11)[1] |
|---|
|
|
| Typing discipline | dynamic, strong |
|---|
| Website | iolanguage.org |
|---|
|
| Io Io.NET |
|
| Smalltalk, NewtonScript, Self, Lua, Lisp, Python, Act1 |
|
| Ioke, Potion |
Close
Remarkable features of Io are its minimal size and openness to using external code resources. [3] Io is executed by a small, portable virtual machine.
In its simplest form, it is composed of a single identifier:[5]
Assuming the above doStuff is a method, it is being called with zero arguments and as a result, explicit parentheses are not required.
If doStuff had arguments, it would look like this:
Io is a message passing language, and since everything in Io is a message (excluding comments), each message is sent to a receiver. The above example demonstrates this well, but not fully. To describe this point better, let's look at the next example:
The above example demonstrates message passing in Io; the "version" message is sent to the "System" object.
Operators are a special case where the syntax is not as cut-and-dried as the above examples. The Io parser intercepts a set of operators defined by the interpreter, and translates them to method calls. For example, the following:
translates to:
All operators in Io are methods; the fact that they do not require explicit parentheses is a convenience. As you can see, there is also a little bit of operator precedence happening here, and the precedence levels are the same as with the C precedence levels.
Examples
The ubiquitous Hello world program:
New objects are created by cloning objects. In Io specifically, a new, empty object is created and only the differences between it and its parent are stored within the new object; this behavior is known as differential inheritance. An example of this behavior is shown:
A := Object clone // creates a new, empty object named "A"
A simple non-recursive factorial function, in Io:
factorial := method(n,
if(n == 0, return 1)
res := 1
Range 1 to(n) foreach(i, res = res * i)
)
Because assignment of res * i to res is the last action taken, the function implicitly returns the result and so an explicit return expression is not needed. The above demonstrates the usage of ranges, and doesn't use a for() loop, which would be faster.
