User Tools

Site Tools


Sidebar

Jump to
AmbientTalk
CRIME
iScheme

at:tutorial:objects

This is an old revision of the document!


In this section, we explain how the object-oriented programming paradigm is implemented in AmbientTalk.

Objects, fields and methods

In AmbientTalk, objects are not instantiated from classes. Rather, they are either created ex-nihilo or by cloning and adapting existing objects, like prototypes in the SELF programming language. The definition of such a prototypical object contains a number of fields and methods that represent the object's state and behaviour respectively.

The following code illustrates the ex-nihilo creation of an object:

> def point := object: { 
    def x := 0;
    def y := 0;
    def init(aX,aY) {
      x := aX;
      y := aY;
    };
    def sumOfSquares() { x*x + y*y };
  }

As all definitions in AmbientTalk, objects, fields and methods are defined using the def keyword. Fields are defined using a def name := value syntax while methods are defined using a name(parameters) {body} syntax.

AmbientTalk not only supports traditional canonical syntax (e.g. o.m(a,b,c)) but also keyworded syntax (e.g. o.at: key put: value) for method definitions and message sends, as in SmallTalk.

In the example above, the state of the point object is composed of x and y fields while its behaviour corresponds to the init and sumOfSquares methods.

Sending messages

In AmbientTalk, computation is expressed in terms of objects sending messages to one another. Messages are used to invoke the fields and methods of the objects.

> point.x
>>2
> point.sumOfSquares()
>>13

This code shows two messages sent to the point object defined above in this section. The x message acts as an accessor for the x field. The sumOfSquares message selects the sumOfSquares method and evaluates its body.

Cloning and instantiation

As said before in this section, AmbientTalk objects are created ex-nihilo or by cloning and adapting an existing object. The code below shows the instatiation of a new point object by using the cloning semantics.

> def anotherPoint := point.new(2,3)

Every object understands the message new, which creates a clone (a shallow copy) of the receiver object and initializes the clone by invoking its init method with the arguments that were passed to new (aX and aY in the example of the point object). Hence, the init method plays the role of “constructor” for AmbientTalk objects. AmbientTalk’s object instantiation protocol closely corresponds to class instantiation in class-based languages, except that the new object is a clone of an existing object, rather than an empty object allocated from a class.

AmbientTalk also provides a clone language contsruct which only creates a clone of the receiver object without calling the init method (as a matter of fact the new message desribed above does nothing more but invoking this construct and the init method subsequently).

> def clonedPoint := clone: point

Delegation and cloning

AmbientTalk features object inheritance or delegation. By means of delegation, an object can reuse and extend the defintion of another establishing a parent-child relationship. We identify two kinds of delegation relationships: IS-A and SHARE-A. These relationships define two different semantics for clonning child objects. Whereas clonning a IS-A child also clones its parent, SHARE-A child shares the parent of the cloned object (see the figure below).

:at:tutorial:isaversussharea.png

The following code shows how to extend objects with a IS-A relationship. It uses the extend: with: language construct.

> def point3D := extend: point with: {
    def z := 0;
    def sumofsquares() {
      super.sumofsquares() + z*z
    }
  }

The following code shows how to extend objects with a SHARE-A relationship. It uses the share: with: language construct.

> def point3D := share: point with: {
    def z := 0;
    def sumofsquares() {
      super.sumofsquares() + z*z
    }
  }

Delegation and dynamic inheritance

The parent of an object is bound to a field named super. The delegation chain defined by an object and its parent (or chain of parents) determines the scope in which the message is looked up. As any field in AmbientTalk objects, the super field can be dynamically modified.

> def OpenConnection := object: {...};
    def ClosedConnection := object: {...};
    def Connection := object: {
      def open() {
        super := OpenConnection.new();
    };
    def close() {
      super := ClosedConnection.new();
    };
  }

First-class delegation

AmbientTalk provides an explicit delegation operator ^ shown in the code below.

> def point3D := extend: point with: {
    def z := 0;
    def init(aX, aY, aZ) {
      super^init(aX, aY);
      z := aZ;
    }
  }

Encapsulation

In AmbientTalk, all fields and methods are “public” via selection. Still, a field or method can be made “private” by means of lexical scoping. The following code shows the definition of an object inside the definition of a function. The fields and methods of this object cannot be accessed directly from outside the funuction.

> def makeObject(hidden) {
    object: {
      def foo() { /* use hidden */ }
    }
  }

Due to the encapsulation of this object the following instruction fails:

> makeObject(5).hidden;
>>Lookup failure : selector hidden could not be found in 
  <object:5068254>
at/tutorial/objects.1183374907.txt.gz · Last modified: 2007/07/02 13:18 (external edit)