Differences

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

--- at:tutorial:basic [2007/12/04 15:16] – *Fixed mstevens
+++ at:tutorial:basic [2009/04/14 19:24] – Fixed stijnm
@@ Line 245: / Line 245: @@
   def i := 0;
   def mapped[tbl.length] {
-    clo(tbl[i:=i+1])
+    i := i+1;
+    clo( tbl[ i ] )
   };
 }
@@ Line 415: / Line 416: @@
 Control flow constructs are defined in the lexical root of AmbientTalk. The lexical root is an object containing globally visible native methods (i.e. it is the top-level environment). We have already seen in the previous sections examples of use of the foreach and if/then structures. A list of traditional control flow structures defined in AmbientTalk is shown below:
 <code>
-if: booleanCondition then: consequent
+if: booleanCondition then: consequentClosure
-if: booleanCondition then: consequent else: alternative
+if: booleanCondition then: consequentClosure else: alternativeClosure
-while: condition do: body
+while: conditionClosure do: body
-foreach: iteratorclosure in: table
+foreach: iteratorClosure in: table
-do: body if: condition
+do: bodyClosure if: condition
-do: body unless: condition
+do: bodyClosure unless: condition
 </code>
-Note that ''condition'' in the ''while:do:'' construct denotes a //closure// that should return a boolean value. It needs to be a closure because the code is evaluated repeatedly until the closure returns false. ''body'', ''consequent'', ''alternative'' all denote zero-argument closures.
+<note warn>
+Note that ''conditionClosure'' in the ''while:do:'' construct denotes a //closure// that should return a boolean value. It needs to be a closure because the code is evaluated repeatedly until the closure returns false. ''bodyClosure'', ''consequentClosure'', ''alternativeClosure'' all denote zero-argument closures. As a general rule, all code that needs to be delayed or executed repeatedly must be wrapped in a closure.
+</note>
-An example of usage for some of these structures is shown below in the definition of the sort function.
+The above definitions in the lexical root of AmbientTalk are simply convenience functions for the methods defined on booleans and closures. For example, an if-statement can also be encoded as a message send, as in Smalltalk: ''boolean.ifTrue: {...} ifFalse: {...}''.
+An example of usage for some of the above structures is shown below in the definition of the sort function.
 <code>
 >def sort(table, cmp := { |e1,e2| e1 < e2 }) {
-	def quickSort(table, low, high) {
+  def quickSort(table, low, high) {
-	   	def left := low;
+    def left := low;
-	   	def right := high;
+    def right := high;
-	   	def pivot := table[(left+right) /- 2];
+    def pivot := table[(left+right) /- 2];
-	   	def save := nil;
+    def save := nil;
-        while: { left <= right } do: {
+    while: { left <= right } do: {
-		    while: { cmp(table[left], pivot) } do: {
+      while: { cmp(table[left], pivot) } do: {
-                left := left + 1
+        left := left + 1
-            };
+      };
-		    while: { cmp(pivot, table[right]) } do: {
+      while: { cmp(pivot, table[right]) } do: {
-                right := right - 1
+        right := right - 1
-            };
+      };
-		    if: (left <= right) then: {
+      if: (left <= right) then: {
-			    // swap elements
+        // swap elements
-			    save := table[left];
+        save := table[left];
-					table[left] := table[right];
+        table[left] := table[right];
-					table[right] := save;
+        table[right] := save;
-					left := left + 1;
+        left := left + 1;
-					right := right - 1;
+        right := right - 1;
-		    };
+      };
-	   };
+    };
-	   if: (low<right) then: { quickSort(table,low,right) };
+    if: (low<right) then: { quickSort(table,low,right) };
-	   if: (high>left) then: { quickSort(table,left,high) };
+    if: (high>left) then: { quickSort(table,left,high) };
-	   table;
+    table;
-	  };
+  };
-	  quickSort(table, 1, table.getLength());
+  quickSort(table, 1, table.length);
-	};
+};
 >><closure:sort>
 >sort([2,37,6,4,5,8])