ObjectTalk Classes

Below is the reference documentation for all classes included in the ObjectTalk runtime.

Object Class

ObjectTalk uses single inheritance to simplify the language and every class must be derived from another class. The only exception to this rule is the Object class as it provides the foundation for all objects. As such, all ObjectTalk classes are derived (directly or indirectly) from Object. The Object class is the only class without a parent class.

Given that the Object class is very abstract, it is not very meaningful to instantiate it. Off course there is an exception here as well as the default global context creates a null object that can be used to denote a value that does not exist.

var a = null;
var b = Object();
assert(a == b);

In the example above, both a and b have the same (non) value.

All ObjectTalk objects have a special mechanism to store members that can be accessed with the dot (member) operator. Members are not preserved beyond the running of a script and should therefore not be used as a dictionary. For that, please of the Dict class. Members are powerful as any data can be attached to an object.

When members are retrieved, the ObjectTalk engine for looks at the members attached to the object and if it can't be found, it's class and parent classes are searched. This is actually the mechanism by which class member functions are found.

var a = -1;
a.flag = true;            // attach member to object a
assert(a.flag == true);
assert(a.abs() == 1);     // abs member function from Integer class

Integer.flag2 = false;    // set member on Integer class
assert(a.flag2 == false); // find member in Integer object

This power however comes with a disadvantage as you can create really obscure code. Here is an example:

var a = "test";
var b = "test";
a.flag = true;            // only set member on object a

a.dosomething = function(this) {
	return "I did it";
};                        // store a function as a member

assert(a.flag == true);
assert(a.dosomething() == "I did it");

var result = false;
var c = "";

try {
	c = b.dosomething();  // this won't work as b does not have members
}

catch error {
	result = true;        // we expected this error
}

assert(result == true);
assert(c == "");

String.flag2 = true;      // add member to String class

String.dosomething = function(this) {
	return "I did it";
};                        // add function to String class

// now the member is available on all String objects
assert(a.flag2 == true);
assert(b.flag2 == true);
assert(a.dosomething() == "I did it");
assert(b.dosomething() == "I did it");

Member Functions

Primitive Class

The Primitive class is an abstract class without any functionality derived from Object. The purpose of it in ObjectTalk is simply to group all primitive classes and to provide a common base class for them.

Booleans, Integers, Reals, Strings and Functions are derived from this class.

Boolean Class

Booleans in ObjectTalk can only hold two values: true and false. The default global language context defines the variables true and false as a convenience.

Member Functions

Overrides

The Boolean class overrides the following member functions from the Object class:

• boolean
• integer
• real
• string
• __eq__
• __ne__

Integer Class

Integers in ObjectTalk represent negative and positive whole numbers. On most systems, this number is implemented as a 64-bit number meaning that the extremes are -9,223,372,036,854,775,808 and 9,223,372,036,854,775,807 (inclusive).

Member Functions

Overrides

The Integer class overrides the following member functions from the Object class:

• boolean
• integer
• real
• string
• __eq__
• __ne__

Real Class

Reals in ObjectTalk are double-precision floating point numbers. On most systems, Reals are implemented using 8 bytes and have a range of 1.7E +/- 308 (15 digits).

Member Functions

Overrides

The Real class overrides the following member functions from the Object class:

• boolean
• integer
• real
• string
• __eq__
• __ne__

String Class

Strings in ObjectTalk are sequences of characters and are captured in double quotes and can span multiple lines. Strings may contain UTF-8 characters (like "€") or use JSON style encoding like "Most Europeans like the \u00C4.\n".

Member Functions

Overrides

The String class overrides the following member functions from the Object class:

• boolean
• integer
• real
• string
• json
• __eq__
• __ne__

Function Class

Functions in ObjectTalk are primitive values. This means that we can pass a function around like any other primitive. Function are first class citizens in ObjectTalk.

In ObjectTalk, there are two types of functions: those that are mapped to machine level C or C++ code and those that are written in ObjectTalk. From a usage perspective there is no difference and both are called the same way, stored the same way and can be passed as arguments. The two examples below create the same result. In the first case, you see a traditional function declaration where as in the second case, an anonymous (lambda) function is assigned a variable.

function test() {
}

var test = function() {
};

Class member functions or "methods" in ObjectTalk are regular functions and the ObjectTalk compiler translates a perceived method call into a function call. In the example below the test member of an object is called with object as the first parameter. This is why member functions in their definition must have a first parameter that refers to the object. ObjectTalk does not care if you call that first member self, this or anything else. You can also see in the example that methods (member functions) can be declared in a traditional way or as lambda assignments.

object.test(p1, p2); becomes test(object, p1, p2);

class Test : Object {
	function test(this, p1, p2) {
	}

	function test2(self) {
	}

	var test3 = function(object) {
	}
}

Member Functions

Collection Class

The Collection class is an abstract class without any functionality derived from Object. The purpose of it in ObjectTalk is simply to group all collection classes and to provide a common base class for them.

Arrays Dictionaries and Sets are derived from this class.

Array Class

Arrays are sequences of objects that can be constructed using square brackets ([]) or through the Array class constructor. The Array class has many member functions to manipulate the content of an array.

var array1 = [ 1, 2, "test", 7 + 4, a ];
var array2 = Array(3.14, 7, 34, 1);

array1.append("new value");
var thirdValue = array1[3];

var array3 = [3.14, [3, 5, 4], 34, 1];

Member Functions

Overrides

The Array class overrides the following member functions from the Object class:

• string

Dict Class

Dictionaries contain indexed key/value pairs that are constructed using curly brackets ({}) or through the Dict class constructor. The Dict class also has many member functions to manipulate the content of a dictionary.

var dict1 = [ "First Name": "John", "Last Name": "Doe", "Age": 34 };
var dict2 = Dict("Name", "John Doe", "Address", "Unknown");

dict1["Last Update"] = "1 Apr 2000";
var name = dict2["Name"];

Member Functions

Overrides

The Dict class overrides the following member functions from the Object class:

• string

Set Class

Sets store distinct values in a collection without defined order. You can use a set instead of an array when the order of items isn’t important, or when you need to ensure that an item only appears once. Sets can be created using the Set class constructor. The Set class also has many member functions to manipulate the content of a set or to perform set operations (e.g. union, difference).

var set = Set(1, 2, 3, 5);
var set2 = Set(1, 3, 6, 8);

assert(set.intersection(set2) == Set(1, 3));
assert(set.difference(set2) == Set(2, 5, 6, 8));
assert(set.union(set2) == Set(1, 2, 3, 5, 6, 8));
assert(set.subtract(set2) == Set(2, 5));

Member Functions

Overrides

The Set class overrides the following member functions from the Object class:

• string

System Class

The System class is an abstract class without any functionality derived from Object. The purpose of it in ObjectTalk is simply to group all operating and file system classes.

Path Class

Objects of type path represent paths on a filesystem. A path name has the following syntax:

• root-name (optional): identifies the root on a filesystem with multiple roots (such as "C:" or "//myserver"). In case of ambiguity, the longest sequence of characters that forms a valid root-name is treated as the root-name.
• root-directory (optional): a directory separator that, if present, marks this path as absolute. If it is missing (and the first element other than the root name is a file name), then the path is relative and requires another path as the starting location to resolve to a file name.
• Zero or more of the following:
  • file-name: sequence of characters that aren't directory separators or preferred directory separators (additional limitations may be imposed by the OS or file system). This name may identify a file, a hard link, a symbolic link, or a directory. Two special file-names are recognized:
    • dot: the file name consisting of a single dot character . is a directory name that refers to the current directory
    • dot-dot: the file name consisting of two dot characters .. is a directory name that refers to the parent directory.
  • directory-separators: the forward slash character / or the alternative character provided by the operating system. If this character is repeated, it is treated as a single directory separator: /usr///////lib is the same as /usr/lib.

Member Functions

Overrides

The String class overrides the following member functions from the Object class:

• string
• __eq__
• __ne__

OS Class

The OS (Operating System) class encapsulates an interface to the native operating system. Filesystem operations are not included as they are covered by the FS (File System) class. The Global scope predefines an OS instance under the name os.

Member Functions

FS Class

The FS (File System) class encapsulates an interface to the native file system.

Member Functions