Differences

This shows you the differences between two versions of the page.

--- at:tutorial:objects [2007/07/02 13:02] – jorge
+++ at:tutorial:objects [2007/07/09 21:03] – * tvcutsem
@@ Line 4: / Line 4: @@
 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.
+and adapting existing objects, in the spirit of prototype-based programming such as in the SELF programming language. The definition of 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:
 <code>
-> def point := object: {
+def Point := object: {
-    def x := 0;
+  def x := 0;
-    def y := 0;
+  def y := 0;
-    def init(aX,aY) {
+  def init(aX,aY) {
-      x := aX;
+    x := aX;
-      y := aY;
+    y := aY;
-    };
+  };
-    def sumOfSquares() { x*x + y*y };
+  def sumOfSquares() { x*x + y*y };
-  }
+}
 </code>
-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.
+The above code defines an //ex-nihilo// created point object and binds it to the variable ''Point''. The object itself does not carry a name (i.e. it is "anonymous"). Like all definitions in AmbientTalk, fields and methods are defined using the ''def'' keyword. Fields are defined using a ''def name := value'' syntax while methods are defined using a ''def name(parameters) {body}'' syntax.
-<note important>
+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.
-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.
-</note>
-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.
+<note>
+As already explained in the [[at:tutorial:basic|basic programming]] part of the tutorial, 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''). Keyworded syntax can be used both for method definitions and for message sends.
+For Smalltalk/Self programmers: note that a keyworded message send does require a message sending operator (like ''.'') in between the receiver and the message, which is different from Smalltalk and Self. As will be described in later chapters, AmbientTalk features more than one message sending operator, so the programmer must explicitly specify which one to use.
+</note>
 ===== Sending messages =====
@@ Line 32: / Line 34: @@
 <code>
-> point.x
+> Point.x
->>2
+>>0
-> point.sumOfSquares()
+> Point.sumOfSquares()
->>13
+>>0
 </code>
-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.
+This code shows two messages sent to the point object defined above. The ''x'' message acts as an accessor for the ''x'' field. The ''sumOfSquares'' message looks up the ''sumOfSquares'' method in the object and applies it.
+Note that the "prototypical" point object defined above can act as a stand-alone object. This is different from a class in a class-based language, which often requires the use of ''static'' fields or methods to be used stand-alone.
 ===== Cloning and instantiation =====
@@ Line 67: / Line 71: @@
 > def point3D := extend: point with: {
     def z := 0;
-    def sumofsquares() {
+    def sumOfSquares() {
-      super.sumofsquares() + z*z
+      super^sumOfSquares() + z*z
     }
   }
@@ Line 78: / Line 82: @@
 > def point3D := share: point with: {
     def z := 0;
-    def sumofsquares() {
+    def sumOfSquares() {
-      super.sumofsquares() + z*z
+      super^sumOfSquares() + z*z
     }
   }
@@ Line 88: / Line 92: @@
 <code>
-> def OpenConnection := object: {...};
+> def openConnection := object: {...};
-    def ClosedConnection := object: {...};
+> def closedConnection := object: {...};
-    def Connection := object: {
+> def connection := object: {
-      def open() {
+    def open() {
-        super := OpenConnection.new();
+      super := openConnection.new();
     };
     def close() {
-      super := ClosedConnection.new();
+      super := closedConnection.new();
     };
   }
 </code>
-===== First-class Delegation =====
+<note important>
+In AmbientTalk, ''self'' and ''super'' indicate the current object and its parent respectively. While the former corresponds to a language keyword the latter is just a field name of the object.
+</note>
+===== First-class delegation =====
+AmbientTalk provides an explicit delegation operator ''^'' (the "caret" or "hat" symbol). The code below illustrates the use of the ''^'' operator in the implementation of the ''init'' method of the ''point3D'' object.
+<code>
+> def point3D := extend: point with: {
+    def z := 0;
+    def init(aX, aY, aZ) {
+      super^init(aX, aY);
+      z := aZ;
+    };
+  }
+</code>
+A message sent to an object using the ''^'' symbol (e.g. to the parent object in the example above) will start the method lookup in this object (and its parents) and then execute the method body in the lexical scope of the message sender (''self'' is bound to the message sender).
+<note warning>
+The delegation operator does not have the same semantics as the dot notation. A message sent to ''super'' using the dot notation will not only start the method lookup in the object bound the ''super'' field but also bind the ''self'' pseudo variable to this object.
+</note>
 ===== Encapsulation =====