Io (programming language)
From Wikipedia, the free encyclopedia
 |
|
| Paradigm: | multi-paradigm: object-oriented, prototype-based |
|---|---|
| Appeared in: | 2002 |
| Designed by: | Steve Dekorte |
| Developer: | Steve Dekorte (and others) |
| Typing discipline: | strong, dynamic |
| Major implementations: | Io |
| Influenced by: | Smalltalk, NewtonScript, Self, Lua, Lisp, Act1 |
Io is a pure object-oriented programming language inspired by Smalltalk, Self, Lua, Lisp, Act1 and NewtonScript. 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 there is dynamic typing. Like Lisp, there are no statements, flow control is achieved using functions, and programs are just data trees. Io uses actors for concurrency, a technique rarely used in modern programming languages.
Remarkable features of Io are its efficiency, minimal size and openness to using external code resources. Io is executed by a small, portable virtual machine.
Contents |
[edit] History
The language was created by Steve Dekorte around March 7, 2002, after trying to help a friend optimize his language. He found out that he really didn't know much about how languages worked, and set out to write a tiny language to understand the problems better.
[edit] Philosophy
Io's goal is to explore conceptual unification and dynamic languages, so the tradeoffs tend to favor simplicity and flexibility over performance.
[edit] Features
- pure object-oriented based on prototypes
- exception handling
- Perl-like regular expressions
- incremental garbage collecting supporting weak links
- highly portable
- DLL/shared library dynamic loading on most platforms
- introspection, reflection and meta-programming
- Actor-based concurrency
- Coroutines
- small virtual machine
- higher-order functions
[edit] Syntax
The syntax of Io is almost non-existent. In its simplest form, it is composed of a single identifier:
doStuff
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:
doStuff(42)
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:
System version
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:
1 + 5 * 8 + 1
translates to:
1 +(5 *(8)) +(1)
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.
You should have noticed one other thing: operators were turned into method calls. In fact, all operators in Io are methods; (except for two oddities, the assignment operators ":=" and "=" which are gobbled up by the parser and translated into entirely different messages) the fact that they do not require explicit parentheses is a convenience.
[edit] Methods and blocks
In Io there are two ways of creating anonymous functions: methods and blocks. Between them, they are almost identical except for one thing: scope. While blocks have lexical scope, methods have dynamic scope.
Both methods and blocks are higher-order functions.
[edit] Examples
The ubiquitous Hello world program:
"Hello, world!" println
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 n to(1) foreach(i, res = res * i) res )
The above demonstrates the usage of ranges, and doesn't use a for() loop which is faster.
[edit] External links
