A singleton which on Apple computers can:

• get and set display and keyboard brightness
• read left and right ambient light sensors (laptops only)
• read accelerometer sensor (laptops only)

Example use;

	
sensors = AppleSensors clone
value := sensors getRightLightSensor

An object for encoding and decoding audio files (principally WAV and AIFF) using the Libsndfile library.

frames
sampleRate
channels
format
seekable

sampleRate
channels
format

sampleRate
channels
format

Encapsulates a audio file. Usefull for reading an audio file using LibSndFile.

A wrapper around the libogg ogg_packet object. No methods - used internally.

A wrapper around the libogg ogg_page object.

A wrapper around the libogg ogg_stream_state object.

A wrapper around the libogg ogg_sync_state object.

The AudioDevice object can used to write audio data as if directly to the audio buffer.

A minimal audio mixer.

A binding for libsamplerate useful for up or downconverting the sample rate of a raw audio stream. Streams are assumed to be in 32bit float interleaved stereo.

Used to change the tempo and/or pitch of an audio stream. Input and output are in 32 bit floats in 2 channels at a rate of 44100 samples per second.

Used to set meta data tags on the following audio formats:

ape
flac
mp3
mpc
mpeg
ogg

Supports reading and writing the following attributes:

title
artist
album
year
track
genre 

And reading the attributes:

bitRate
sampleRate
channels
length

Example use (load and modify a track genre):

t := TagLib clone setPath("foo.mp3") load
writeln("genre = ", t genre)
t setGenre("ambient")
t save

This object provides access the world of python.

An object that enables low level introspection into a running Io VM.

The LZO object can be used to compress and uncompress data using the Lempel-Ziv-Oberhumer (LZO) lossless data compression algorithm.

Example use;

compressedData := LZO compress(uncompressedData)
uncompressedData := LZO uncompress(compressedData)

The LZO object can be used to uncompress data using the Lempel-Ziv-Oberhumer (LZO) lossless data compression algorithm.

Example use;

	
z = LZODecoder clone
z beginProcessing
z inputBuffer appendSeq("this is a message")
z process
z endProcess
result := z outputBuffer 

The LZOEncoder object can be used to compress data using the Lempel-Ziv-Oberhumer (LZO) lossless data compression algorithm.

Example use;

	
z = LZOEncoder clone
z beginProcessing
z inputBuffer appendSeq("this is a message")
z process
z endProcess
result := z outputBuffer 

The Zlib object can be used to compress and uncompress data using the zlib lossless data compression algorithm.

Example use;

compressedData := Zlib compress(uncompressedData)
uncompressedData := Zlib uncompress(compressedData)

For Zlib uncompression. Example use;

	
z = ZlibDecoder clone
z beginProcessing
z inputBuffer appendSeq(inputData)
z process
z endProcess
result := z outputBuffer 

For Zlib compression. Example use:

	
z = ZlibEncoder clone
z beginProcessing
z inputBuffer appendSeq("this is a message")
z process
z endProcess
result := z outputBuffer

For native threads. Example use;

	
Thread createThread("1+1") // evals 1+1 in a new thread and an independent Io VM

Blocks are anonymous functions (messages with their own locals object). They are typically used to represent object methods.

A container for a pointer to a C function binding. CFunction's can only be defined from the C side and act like blocks in that when placed in a slot, are called when the slot is activated. The for, if, while and clone methods of the Lobby are examples of CFunctions. CFunctions are useful for implementing methods that require the speed of C or binding to a C library.

Call stores slots related to activation.

A singleton containing methods related to Io's garbage collector. Io currently uses a incremental, non-moving, generational collector based on the tri-color (black/gray/white) algorithm with a write-barrier.

Every N number of object allocs, the collector will walk some of the objects marked as gray, marking their connected white objects as gray and turning themselves black. Every M allocs, it will pause for a sweep where it makes sure all grays are marked black and io_frees all whites.

If the sweepsPerGeneration is set to zero, it will immediately mark all blacks as white again and mark the root objects as gray. Otherwise, it will wait until the sweepsPerGeneration count is reached to do this. By adjusting the allocsPerSweep and sweepsPerGeneration appropriately, the collector can be tuned efficiently for various usage cases. Generally, the more objects in your heap, the larger you'll want this number.

Contains methods related to the compiling code.

Coroutine is an primitive for Io's lightweight cooperative C-stack based threads.

Contains methods related to the IoVM debugger.

The Directory object supports accessing filesystem directories. A note on paths; if a path begins with a "/" it's the root, if it beings with a "./" it's the launch path, if not specified, "./" is assumed.""")

A DLL Loader by Kentaro A. Kurahone.

An object that contains error information and flow control based on errors.

The Exception proto is used for raising exceptions and instances are used to hold rexception related info.

Raise

An exception can be raised by calling raise() on an exception proto. Exception raise("generic foo exception")

Try and Catch

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.

e := try()

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

e := try(
    // ...
) 

e catch(Exception,
    writeln(e coroutine backtraceString)
)

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.

Pass

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:

e := try(
    // ...
) 

e catch(Error,
    // ...
) catch(Exception,
    // ...
) pass

Custom Exceptions

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

MyErrorType := Error clone

Encapsulates file i/o. Here's an example of opening a file, and reversing its lines:

	
file := File clone openForUpdating("/tmp/test")
lines := file readLines reverse
file rewind
lines foreach(line, file write(line, "\n"))
file close

	
aFile foreach(i, v, writeln("byte at ", i, " is ", v))
aFile foreach(v, writeln("byte ", v))

	
aFile foreachLine(i, v, writeln("Line ", i, ": ", v))
aFile foreach(v, writeln("Line: ", v))

A mutable array of values. The first index is 0.

list(1, 2, 3) foreach(i, v, writeln(i, " = ", v))
list(1, 2, 3) foreach(v, writeln(v))

A key/value dictionary appropriate for holding large key/value collections.

	aMap foreach(k, v, writeln(k, " = ", v))
aMap foreach(v, write(v))

	myBlock = block(k, v, write(k, " = ", v, "\n"))
aMap foreach(k, v, myBlock(k, v))

A Message object encapsulates the action of a message send. Blocks are composed of a Message and its children.

Terminology

Example:
  Io> msg := message(A B(C D); E F)
  ==> A B(C D); E F
  
In the above example:
  msg name            =>  A
  msg next            =>  B(C D); E F
  msg next arguments  =>  list(C D)
  msg next next name  =>  ;
  msg next next next  =>  E F

Important: Modifying the message tree of a block currently in use may cause a crash if a garbage collection cycle occurs. If the implementation were changed to retain every called message, this could be avoided. But the cost to performance seems to outweigh the need to cover this case for now.

	
Io> message(a) appendArg(message(b))
==> a(b)

Io> message(a(1,2)) appendArg(message(3))
==> a(1, 2, 3)

	
Io> message(a(1,2,3)) argCount
==> 3

Io> message(a) argCount
==> 0

  Io> message(a) union(message(b))
  ==> [unnamed](a, b)
  

A container for a double (a 64bit floating point number on most platforms).

1234.5678 asString(0, 2)

1234.57

An Object is a key/value dictionary with string keys and values of any type. The prototype Object contains a clone slot that is a CFuntion that creates new objects. When cloned, an Object will call its init slot (with no arguments).

	MyObject test // performs test
	MyObject ?test // performs test if MyObject has a slot named test
	

	Io> block(x, x*2) scope == thisContext
  ==> true
	

myObject foreach(n, v,
	writeln("slot ", n, " = ", v type)
)

myObject foreach(v,
	writeln("slot type ", v type)
)

  Io> thisContext foreachSlot(n, v, n println)
  Lobby
  Protos
  exit
  forward
  n
  v
  ==> false
  

myProxy forward = method(
	messageName := thisMessage name
	arguments := thisMessage arguments
	myObject doMessage(thisMessage)
)

  Io> m := inlineMethod(x := x*2)
  Io> x := 1
  ==> 1
  Io> m
  ==> 2
  Io> m
  ==> 4
  Io> m
  ==> 8
  

  Io> x := lazySlot("Evaluated!" println; 17)
  Io> x
  Evaluated!
  ==> 17
  Io> x
  ==> 17
  Io> x
  ==> 17
  

  Io> lazySlot("x", "Evaluated!" println; 17)
  Io> x
  Evaluated!
  ==> 17
  Io> x
  ==> 17
  Io> x
  ==> 17
  

  Dog := Mammal clone do(
    init := method(
  	  resend
    )
  )
  

  Io> Object clone do(x:=1) serialized
  ==> Object clone do(
  	x := 1
  )
  

  Io> slotSummary
  ==>  Object_0x30c590:
    Lobby            = Object_0x30c590
    Protos           = Object_0x30c880
    exit             = method(...)
    forward          = method(...)
  

	self test(1, 2)   // performs test(1, 2) on self
	super(test(1, 2)) // performs test(1, 2) on self proto but with the context of self
	

	
Io> a := method(x, x = x + 1; if(x > 10, return x); tailCall(x))
==> method(x, updateSlot("x", x +(1));
		if(x >(10), return(x));
		tailCall(x))
Io> a(1)
==> 11

  Io> Object uniqueId
  ==> 3146784
  Io> Object uniqueHexId
  ==> 0x300420
  

Basic support for profiling Io code execution.

Sandbox can be used to run separate instances of Io within the same process.

Io's coroutine scheduler.

A Sequence is a container for a list of data elements. Typically these elements are each 1 byte in size. A Sequence can be either mutable or immutable. When immutable, only the read-only methods can be used.

Terminology

• Buffer: A mutable Sequence of single byte elements, typically in a binary encoding
• Symbol or String: A unique immutable Sequence, typically in a character encoding

"cow@moo.com/Scandinavia" asJid

int8, int16, int32, int64
uint8, uint16, uint32, uint64
float32, float64 

pointObject := structPointSeq asStruct(list("float32", "x", "float32", "y"))

	
aSequence foreach(i, v, writeln("value at index ", i, " is ", v))
aSequence foreach(v, writeln("value ", v))

	
"Keep the tail" lstrip(" eKp")
==> "the tail"

  Io> "ABC" asMutable makeFirstCharacterLowercase
  ==> aBC
  

  Io> "abc" asMutable makeFirstCharacterUppercase
  ==> Abc
  

	
"Cut the tail off" rstrip(" afilot")
==> "Cut the"

	
"abc" size == 3

  Io> "" slicesBetween("<", ">")
  ==> list("a", "b", "/b", "/a")
  

	
"a b c d" split == list("a", "b", "c", "d")
"a*b*c*d" split("*") == list("a", "b", "c", "d")
"a*b|c,d" split("*", "|", ",") == list("a", "b", "c", "d")
"a   b  c d" split == list("a", "", "", "", "b", "", "", "c", "", "d")

	
"   Trim this string   \r\n" strip
==> "Trim this string"

int8, int16, int32, int64
uint8, uint16, uint32, uint64
float32, float64 

pointStructSeq := Sequence withStruct(list("float32", 1.2, "float32", 3.5))

Contains methods related to the IoVM.

	options := System getOptions(args)
	options foreach(k, v,
	  if(v type == List type,
		v foreach(i, j, writeln(\"Got unnamed argument with value: \" .. j))
		continue
	  )
	  writeln(\"Got option: \" .. k .. \" with value: \" .. v)
	)
	

A WeakLink is a primitive that can hold a reference to an object without preventing the garbage collector from collecting it. The link reference is set with the setLink() method. After the garbage collector collects an object, it informs any (uncollected) WeakLink objects whose link value pointed to that object by calling their "collectedLink" method.

A Message object encapsulates the action of a message send. Blocks are composed of a Message and its children.

Terminology

Example:
  Io> msg := message(A B(C D); E F)
  ==> A B(C D); E F
  
In the above example:
  msg name            =>  A
  msg next            =>  B(C D); E F
  msg next arguments  =>  list(C D)
  msg next next name  =>  ;
  msg next next next  =>  E F

Important: Modifying the message tree of a block currently in use may cause a crash if a garbage collection cycle occurs. If the implementation were changed to retain every called message, this could be avoided. But the cost to performance seems to outweigh the need to cover this case for now.

	
Io> message(a) appendArg(message(b))
==> a(b)

Io> message(a(1,2)) appendArg(message(3))
==> a(1, 2, 3)

	
Io> message(a(1,2,3)) argCount
==> 3

Io> message(a) argCount
==> 0

  Io> message(a) union(message(b))
  ==> [unnamed](a, b)
  

An NotificationCenter similar to the one found in Apple's FoundationKit.

Example use:

// in listener
listener := NotificationListener clone setTarget(self) setName("FeedDownloadedFile") start

// in sender
Notification clone setSender(self) setName("FeedDownloadedFile") post

// note: notifications can also be reused, and any extra data can be added in it's slots

// to stop listening
listener stop

listeners foreach(handleNotification(n))

Simple datastructure representing the items at and between two specific points.

// First method (operating on numbers)
1 to(10) foreach("iterating" print) // prints "iterating" 10 times
// Second method (operating on numbers)
1 to(10) foreach(v, v print) // prints each value
// Third method (operating on numbers)
1 to(10) foreach(i, v, writeln(i .. ": " .. v)) // prints "index: value"

# First method (operating on numbers)
1 to(10) map(*2) # multiply each value by two
# Second method (operating on numbers)
1 to(10) map(v, "#{v}" interpolate) # returns string representation of each value as list
# Third method (operating on numbers)
1 to(10) map(i, v, i*v) #  multiply each value by index

An object for wrapping libdbi to allow Io access to a multitude of database systems transparently.

An object that represents a DBI Connection.

A DBI Record. When utilizing `foreach' or `populate' methods of a DBIResult object, you can pass an optional Object cloned from DBIRecord. This object will be populated with the row contents making it possible to write objects that represent your SQL results. A simple example would be:

Person := DBIRecord clone do (fullName := method(firstName.." "..lastName))
q := conn query("SELECT id, firstName, lastName FROM people")
q foreach(Person, p, writeln("Name = ", p fullName))

As you can see, fullName was not in the SQL query, however, a dynamic method in your Person class. DBIRecord in and of itself provides no real functionality. It simply acts as an Object and stores the values from the SQL query into a Map. You can access the field information:

o := r populate(Person)
o firstName            // would retrieve the firstName value of the SQL query
o setFirstName("John") // would update the object's firstName value to be John

Do not confuse the above example as updating the actual database. The call to setFirstName only updates the objects representation of firstName.

A DBI Result created by a call to DBIConn query.

r := conn query("SELECT * FROM people")
r foreach(r, r at(1))

r := conn query("SELECT * FROM people")
r seek(4)
r foreach(r, r at (1))

memcached is a high-performance, distributed memory object caching system, generic in nature, but intended for use in speeding up dynamic web applications by alleviating database load. Memcached is an Io client library for memcached, based on C libmemcached.

MySQL is a fast, multi-threaded, multi-user SQL database server. IoMySQL is a MySQL binding for Io, by Min-hee Hong.

my := MySQL establish("localhost", "user", "password", "database")

# Get rows by Map
my queryThenMap("SELECT * FROM rel") foreach(at("col") println)
# Get rows by List
my query("SELECT * FROM rel") foreach(at(0) println)

my close

	db query("SELECT * FROM accounts") foreach(println)
	

A double key/value database with cursors on first key. Basis for PDB.

A network interface for Obsidian.

Starting a Server

oServer := ObsidianServer clone
oServer localObject setName("foo") open
oServer start

Example Client Code

client := MDOConnection clone setHost("127.0.0.1") setPort(8000) connect
client onAtPut("1", "aKey", "aSlot")
client onAtPut("1", "cKey", "cSlot")
client onAtPut("1", "bKey", "bSlot")
client first("1", 5) println
a := client onAt("1", "aKey")
writeln("a = ", a)
b := client onAt("1", "bKey")
writeln("b = ", b)
client close

The messages accepted by the Obsidian server include:

onAtPut(id, key, value)
onAt(id, key)
onRemoveAt(id, key)
onFirst(id, count)
onLast(id, count)
onAfter(id, key, count)
onBefore(id, key, count)

An arbitrary graph database with support for on-disk garbage collection. Example use:

Setup

PDB open
PDB root atPut("users", PMap clone)
PDB sync
PDB close

PMap is a Map/Dictionary whose keys are lazily loaded from the database. PDB root is the root PMap in the database and the root object used for PDB's garbage collector. PDB sync needs to be called to write any changes to the database.

Defining a Persistent Object

User := Object clone pSlots(name, email)

The pSlots(), declares which slots on the object should be persisted. The List, Date, Sequence and Number primitives already know how to persist themselves.

Inserting a Persistent Object

PDB open 
user := User clone setName("steve") setEmail("steve@foo.com")
PDB root users atPut("steve", user)
PDB sync
PDB close

Accessing a Persistent Object

user := PDB root users at("steve")
writeln("user name = ", user name, " email = ", user email)

Updating a Persistent Object

user setEmail("steve@newDomain.com")
PDB sync 

PDB sync will scan all persistent objects in the vm and save any with changes to their persistent slots. If the object was already in the database, only its updated slots will be written.

Removing an entry in a PMap

PDB root users removeAt("steve")

Removing a persistent object

This is never done explicitly, instead calling:

PDB collectGarbage

Will remove all objects unreachable by the reference graph from the root PMap.

Notes: Currently, PDB is a singleton.

PMap stores persistent data in a Map-like fashion and lazily loads available slots from the PDB backing store. Values stored or loaded are cached into local object slots.

An ordered key/value database that supports transactions and arbitrary kay and value sizes.

SQLite provides a embedded simple and fast (2x faster than PostgreSQL or MySQL) SQL database. See http://www.hwaci.com/sw/sqlite/ for details. It's SQL command set is described at http://www.hwaci.com/sw/sqlite/lang.html. SQLite was written by Dr. Richard Hipp who offers consulting services for custom modifications and support of SQLite. Example:

	
db := SQLite clone
db setPath("myDatabase.sqlite")
db open
db exec("CREATE TABLE Dbm (key, value)")
db exec("CREATE INDEX DbmIndex ON Dbm (key)")
db exec("INSERT INTO Dbm ('key', 'value') VALUES ('a', '123')")
db exec("INSERT INTO Dbm ('key', 'value') VALUES ('a', 'efg')")
rows := db exec("SELECT key, value FROM Dbm WHERE key='a'")
db exec("DELETE FROM Dbm WHERE key='a'")
rows := db exec("SELECT key, value FROM Dbm WHERE key='a'")
db close

SQLite provides a embedded simple and fast (2x faster than PostgreSQL or MySQL) SQL database. See http://www.hwaci.com/sw/sqlite/ for details. It's SQL command set is described at http://www.hwaci.com/sw/sqlite/lang.html. SQLite was written by Dr. Richard Hipp who offers consulting services for custom modifications and support of SQLite. Example:

	
db := SQLite clone
db setPath("myDatabase.sqlite")
db open
db exec("CREATE TABLE Dbm (key, value)")
db exec("CREATE INDEX DbmIndex ON Dbm (key)")
db exec("INSERT INTO Dbm ('key', 'value') VALUES ('a', '123')")
db exec("INSERT INTO Dbm ('key', 'value') VALUES ('a', 'efg')")
rows := db exec("SELECT key, value FROM Dbm WHERE key='a'")
db exec("DELETE FROM Dbm WHERE key='a'")
rows := db exec("SELECT key, value FROM Dbm WHERE key='a'")
db close

An ordered key/value database implemented using a skiplist data structure.

An iterator object for a SkipDB.

SkipDB is a skip-list based key-value database. SkipDBM manages any number of skipdbs within the same file. The root skipdb can be accessed using the root method.

Binding for tagdb - a tagging database usefull for flickr-like tag searches.

Example use:

tdb := TagDB clone

tdb setPath("test")
tdb open

writeln("size = ", tdb size)
tdb atKeyPutTags("f430 for sale", list("red", "ferrari"))
tdb atKeyPutTags("lotus esprit", list("lotus", "esprit"))
writeln("size = ", tdb size)
keys := tdb keysForTags(list("lotus"))
writeln("keys = ", tdb symbolForId(keys at(0)))
tdb close
tdb delete

An ordered key/value database that supports transactions and arbitrary key and value sizes.

A database cursor.

A database cursor.

An object for calculating MD5 hashes. Each hash calculation should instantiate its own MD5 instance.

Example:

digest := MD5 clone
digest appendSeq("this is a message")
out := digest md5String

An object for calculating SHA1 hashes. Each hash calculation should instantiate its own SHA1 instance.

Example:

digest := SHA1 clone
digest appendSeq("this is a message")
out := digest md5String

Generates Universally Unique Identifiers (UUID/GUID).

The Blowfish object can be used to do encryption and decryption using the Blowfish keyed, symmetric block cipher.

Example encryption and decription;

	
key := "secret"
data := "this is a message"

encryptedData := Blowfish clone setKey(key) encrypt(data)
decryptedData := Blowfish clone setKey(key) decrypt(encryptedData)

Or using the stream API:

	
key := "secret"
data := "this is a message"

cipher = Blowfish clone
cipher setIsEncrypting(true)
cipher setKey(key)
cipher beginProcessing
cipher inputBuffer appendSeq(data)
cipher process
cipher endProcess
encryptedData := cipher outputBuffer

cipher = Blowfish clone
cipher setIsEncrypting(false)
cipher setKey(key)
cipher beginProcessing
cipher inputBuffer appendSeq(encryptedData)
cipher process
cipher endProcess
decryptedData := cipher outputBuffer

Used for doing asynchronous file i/o. When this addon is loaded, it will override the File proto's readToBufferLength, readBufferOfLength and write methods to automatically use AsyncRequests.

Note: This addon is only needed for async file requests - all socket ops are already asynchronous in Io.

A primitive for fast operations on rectangles.

Cairo is a 2D graphics library. http://cairographics.org/

The Font object can be used to load and render TypeTrype fonts. Example use;

	
// within a GLUT display callback...

timesFont = Font clone open(\"times.ttf\")
if (timesFont error, write(\"Error loading font: \", timesFont error, \"\n\"); return)
timesFont setPointSize(16)
glColor(0,0,0,1)
timesFont draw(\"This is a test.\")

Rendering fonts using OpenGL textures

Smaller fonts (those having a point size around 30 or smaller, depending on the font) will automatically be cached in and rendered from a texture. This technique is very fast and should support rendering speeds as fast (or faster than) those of typical desktop font rendering systems. Larger font sizes(due to texture memory constraints) will be rendered to a pixelmap when displayed. Thanks to Mike Austin for implementing the font texturing system.

	
glEnable(GL_BLEND)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

The Image object can read and draw images and provide the image data as a buffer. Example use:

	
image = Image clone open("curly.png")
image draw
image scaleTo(image width / 2, image height / 2)
image save("curly.tiff")

When loading an attempt will be made to convert the image into whichever of the following formats it is closest to: L8, LA8, RGB8, RGBA8.

Currently supported formats include PNG(which supports alpha), JPG and TIFF.

A primitive for fast operations on rectangles.

A wrapper for GNU MP Bignum (arbitrary precision math) library. Warning: GMP uses the restrictive GNU license which can be a problem if you are hard linking it into a distributed application.

?

A high quality and reasonably fast random number generator based on Makoto Matsumoto, Takuji Nishimura, and Eric Landry's implementation of the Mersenne Twister algorithm. The default seed is a xor of the ANSI C time() and clock() return values.

beanstalkd is a fast, distributed, in-memory workqueue service. See http://xph.us/software/beanstalkd/
An example from http://xph.us/software/beanstalkd/:
First, have one process put a job into the queue:

producer := Beanstalk clone connect("127.0.0.1:11300")
producer put("hello")

Then start another process to take jobs out of the queue and run them:

worker := Beanstalk clone connect("127.0.0.1:11300")
loop(
	job := worker reserve
	job body println # prints "hello"
	job delete
)

See Beanstalk.io code and protocol description (http://github.com/kr/beanstalkd/tree/master/doc/protocol.txt) for details. Both are short and easy to read.
Stat commands depend on YAML.

CGI supports accessing CGI parameters passed in environment variables or standard input by a web servers like Apache. Example use:

#!./ioServer

cgi = CGI clone

redirect = cgi getParameters at("redirurl")
if (redirect and redirect != "",
	redirect clipAfterStartOfSeq("\r")
	redirect clipAfterStartOfSeq("\n")
	cgi redirect(redirect)
	System exit(0)
 )

cgi header("Content-type", "text/html")

cgi write("<html><head><title>test</title><body>")
cgi write("GET Parameters:")
cgi getParameters foreach(k, v,
	cgi write(k .. " = " .. v .. ","))
)

cgi write("POST Parameters:")
cgi postParameters foreach(k, v,
	cgi write(k .. " = " .. v .. ","))
)

cgi write("COOKIES:")
cgi cookies foreach(k, v,
	cgi write(k .. " = " .. v .. ",")
)

fileName
content (raw content of file as Sequence)
contentType
contentEncoding
size (in characters/bytes)
asString (pretty string of name, type, size)

The DOConnection object is useful for communicating with remote servers in a way that makes it look just like the sending of local messages. Proxies are automatically created on either side for passed objects, with the exception of strings and numbers, which are passed by value. Example:

con := DOConnection clone setHost("127.0.0.1") setPort(8456) connect
result := con serverObject test(1)
writeln(result)
r := result at(0)
writeln(r)
r := result at(1)
writeln(r)

Implementation Notes:

The format of the Distributed Objects message is a list of NullCharacter terminated strings in one of these two formats:

Send message format:

s NullCharacter targetId NullCharacter messageName NullCharacter argCount NullCharacter argType NullCharacter argValue NullCharacter (next arg type and value, etc)

Reply message format:

r NullCharacter argType NullCharacter argvalue NullCharacter

If the argument is not a String, Number or nil then: If it is local to the sender, the type is RemoteObject. If it is a proxy to a remote object, the type is LocalObject. This isn't optimized yet.

An experimental distributed objects server. Example;

Test := Object clone
Test test := method(v, 
	write("got test '", v, "'\n")
	return List clone append(1)
)

doServer := DOServer clone
doServer setRootObject(Test clone)
doServer setPort(8456)
doServer start

A Minimal Distributed Objects connection. Example;

dateServerCon := MDOConnection clone setHost("127.0.0.1") setPort(8123) connect
writeln("date from date server: ", Date fromNumber(dateServerCon currentDate))
dateServerCon close

See the docs for MDOServer for the DateServer code.

A MDOConnection will pause calling coroutines until the response is received. Mutliple requests can be sent before a single request returns if they are sent from separate coroutines.

A Minimal Distributed Objects server. Example;

DateServer := Object clone do(
	acceptedMessageNames := list("currentDate")
	currentDate := method(Date clone asNumber)
)

mdoServer := MDOServer clone 
mdoServer setHost("127.0.0.1")  setPort(8123) 
mdoServer setLocalObject(DateServer clone)
mdoServer start

Object representing one page of search results.

Object for performing web searches via Google. Example:

GoogleSearch clone setSearchTerm("iolanguage") find links foreach(println)
while(Coroutine yieldingCoros size > 1, yield)

Sends an HCRequest using the HTTP protcol and stores the response in an HCResponse

State describing an HTTP request to be sent by an HCConnection

Stores the result of sending an HCRequest using an HCConnection

Handles parsing response received during an HCConnection

Object for representing JIDs.

  j := JID with("cow@moo.com/Alpes")
  j username == "cow"
  j host == "moo.com"
  j resource == "Alpes"
  j asString == "cow@moo.com/Alpes"

Loudmouth is an async XMPP library written in C. Example usage:

acc := Loudmouth with("user@server.com", "super password") do(
  handleConnect = method(
    "Connected!" println)

  handleMessage = method(msg
    "#{msg from} > #{msg plainBody}" println
    body :=  msg plainBody

    if(body indexOf("#") == 0,
      body = doString(body) asString)

    # This way you can manipulate
    # XML nodes with SGML addon
    XmppChatMessage create\
      setPlainBody(body)\
      setTo(msg from)\
      sendVia(self)

    # or simply send the message (must be a Sequence)
    # (this is obviously faster)
    #self send(msg from, body))
)

acc connect
# Any Io code after this line won't be executed
# (unless called as Loudmouth callback or run in separate thread)
Loudmouth startMainLoop

  Loudmouth with("username@server.com", "password") do(
    handleConnect = method(
      self setPresence(Loudmouth types AVAILABLE), "Drinking lemonade...")
  )
  

LoudmouthMessage provides SGML interface and convience methods for manipulation of XMPP messages.

Interface to network adapter functionality.

Read-only interface to SSL X509 certificates.

Interface to secure network communication. A SecureClient is a wrapper on an OpenSSL SSL_CTX object and supports both TLSv1 and DTLSv1.

Interface to secure network communication. A SecureServer is a wrapper on an OpenSSL SSL_CTX object and supports both TLSv1 and DTLSv1. Example:

//...

Utility methods related to Domain Name Service lookups.

An object representing an individual DNS query.

An object representing a DNSServer which DNS requests can be sent to.

Networking Event.

Networking Event.

Networking Event.

Object for libevent (kqueue/epoll/poll/select) library. Usefull for getting notifications for descriptor (a socket or file) events. Events include read (the descriptor has unread data or timeout) and write (the descriptor wrote some data or timeout). Also, timer and signal events are supported.

Object representation of an Internet Protocol Address.

Object for read events.

The Server object provides a simple interface for running a server. You just need to set the port and define a handleSocket method. Here's an example of an echo server:

Echo := Object clone
Echo handleSocketFromServer := method(aSocket, aServer,
  write("[Got echo connection from ", aSocket host, "]\n")
  while(aSocket isOpen,
   if(aSocket read, aSocket write(aSocket readBuffer asString))
   aSocket readBuffer empty
  )
  write("[Closed ", aSocket host, "]\n")
)

write("[Starting echo server on port 8456]\n")
server := Server clone setPort(8456)
server handleSocket := method(aSocket,
  Echo clone @handleSocketFromServer(aSocket, self)
)
server start

Notes

Io's use of lightweight threading and select for dealing with sockets makes for servers that are much more efficient (both memory and cpu wise) than those written with kernel threads and socket polling.

Object for signal events.

Interface to network communication. Sockets will auto yield to other coroutines while waiting on a request. All blocking operations use the timeout settings of the socket. Reads are appended to the socket's read buffer which can be accessed using the readBuffer method. Example:

	
socket := Socket clone setHost("www.yahoo.com") setPort(80) connect
if(socket error) then( write(socket error, "\n"); exit)

socket write("GET /\n\n")

while(socket read, Nop)
if(socket error) then(write(socket error, "\n"); exit)

write("read ", socket readBuffer length, " bytes\n")

Object for timer events.

Object for write events.

Object representing a twitter account.

Object representing a twitter account profile.

Inherits from TwitterFriendsFollowersCursor. requestType is "asFollowerIds".

Inherits from TwitterFriendsFollowersCursor. requestType is "asFriendIds".

Represents a Twitter API request and contains its results.

A simplified version of HttpServer

The fnmatch add on adds support for the unix fnmatch function. (See fnmatch man page for details). Note: not all options are supported on all platforms.

The Regex addon adds support for Perl regular expressions using the PCRE library by Philip Hazel.

Example 1

	
Io> re := "is.*a" asRegex
Io> "This is a test. This is also a test." \
    allMatchesOfRegex("is.*a") replaceAllWith("is not a")
==> "This is not a test. This is not a test.

Example 2

	
Io> "11aabb" allMatchesOfRegex("aa*")
==> list("a", "a")

Io> re := "(wom)(bat)" asRegex
Io> "wombats are cuddly" matchesOfRegex(re) replaceAllWith("$2$1!")
==> batwom!s are cuddly

	
	Io> "WORD" matchesRegex("[a-z]+")
	==> false

	Io> "WORD" matchesRegex("[a-z]+" asRegex caseless)
	==> true
	

	
	Io> "A\nB" matchesOfRegex(".+") next string
	==> A

	Io> "A\nB" matchesOfRegex(".+" asRegex dotAll) next string
	==> A\nB
	

	
	Io> "A\nB\nC" allMatchesForRegex("^.")
	==> list("A")

	Io> "A\nB\nC" allMatchesForRegex("^." asRegex multiline)
	==> list("A", "B", "C")
	

Contains the result of a regular expression match operation. It acts as a read-only list of captured strings. The first item is the entire matched string. Each item after that is a captured sub pattern (anything inbetween parenthesis in the pattern).

Io> match := "37signals" findRegex("([0-9]+)([a-z]+)(!!)?")
==> RegexMatch: "37signals" 

# Item 0 is the entire matched string:
Io> match at(0)
==> 37signals

# Item 1 is the first capture ("[0-9]+"):
Io> match at(1)
==> 37

# Item 2 is the second capture ("[a-z]+"):
Io> match at(2)
==> signals

# The third sub pattern wasn't part of the match, so item 3 is nil:
Io> match at(3)
==> nil

# You can access captures by name:
Io> match at("number")
==> 37
Io> match at("word")
==> signals