Objects and Classes

Objects: Fields and Functions

Everything is an object in Cleet, even primitive types like Int and Bool.

Objects have fields and functions. Which fields and functions the object has is specified by the object's class. Fields are the data that the object knows about. In other languages, fields are often called "instance variables".

An object's fields are visible to anyone who knows about the object. In other words, all fields are "public". This goes against Smalltalk's philosophy, but if fields are private, a lot of wasted effort tends to go into creating getter and setter functions. If a field shouldn't be touched by other objects, a comment to that effect should be sufficient to prevent any reasonable programmer from doing so.

Functions are basically little programs that the object can run. The code for a function is called its method. Function names can be any arbitrary string, but most of the time they'll be normal identifiers. Functions are differentiated from each other not only by their names, but also by their argument types. In C++ terms, they are overloaded. So an object might have these three different functions with the same name: create(), create(value: Int), and create(name: String).

In fact, the create functions are somewhat special and are the main reason Cleet has function overloading. create functions are called when the object is created and serve the same purpose as constructors in C++. Unlike C++ constructors, they are otherwise normal functions and have no arcane rules about when virtual functions can and can't be called.

Similarly, a class can have a destroy() function which is called when an object goes away (that is, when the garbage collector "finalizes" it). This is needed only very rarely, mostly when some system resource (such as a file handle) has been acquired and should be released.

Inheritance

Cleet supports single inheritance. (Multiple inheritance may be added in the future.) Any class for which a superclass hasn't been specified is a subclass of Object. All functions are virtual, although compilers are encouraged to optimize function calls when they can determine that virtual dispatch isn't required. A class may have a function without a method, in which case it is expected that subclasses of the class will override it. Such functions are called phantom functions (the equivalent of C++'s "pure virtual" functions).

Classes

Classes are objects too. The class function will return an object's class.

Class Fields and Functions

A class field is a field that is shared by all instances of a class (unlike normal fields, where each instance has its own). A class function is similar; it is part of the class, not the instance, and so can only access class fields.

A common use for class fields and functions is the Singleton pattern. Here's an example:

Class: DisplayScreen

the-display-screen: DisplayScreen;  [class]

screen: DisplayScreen
[class]
{
  if (the-display-screen == nil)
    the-display-screen = new DisplayScreen;
  return the-display-screen;
}

Class Files

Currently, all code for a class is contained in a file, usually in a single file. The file has the same name as the class. It consists of a header followed by declarations of fields and functions. For example:

Class: HelloWorld
Superclass: Program


// fields:
message: String;


// functions:
create()
{
  message = "Hello world!\n";
}

run()
{
  message.write();
}

A field is declared by following its name with a colon, its type, and a semicolon. Optionally, the semicolon can be followed by an attribute (or attributes), as shown above in the "Class Fields and Functions" example.

A function is declared by its name, its arguments (which are optional if it has no arguments), its return type if it returns a value, its attributes, and finally its code. A "phantom" (ie. "virtual") function will have the "phantom" attribute and will not have code:

draw(display: Display)
[phantom]

If you're declaring a function with a corresponding setter, you can add the code for the setter as a code block immediately following the main code block. The extra argument will be named "new-value". So this:

name: String
{
  return this.the-name;
}
{
  this.the-name = new-value;
  redraw();
}

is the same as this:

name: String
{
  return this.the-name;
}

name-set(new-name: String)
{
  this.the-name = new-name;
  redraw();
}