Differences

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

--- at:tutorial:basic [2007/07/05 11:43] – elisag
+++ at:tutorial:basic [2009/06/05 15:32] – added tvcutsem
@@ Line 1: / Line 1: @@
-<note>
-**This Tutorial is still under heavy construction!!**
-</note>
 ====== Functional and Imperative Programming ======
@@ Line 176: / Line 174: @@
 </code>
 In that case, the //sum// function still accepts an arbitrary number of arguments as long as two arguments are supplied. //a// and //b// are considered as mandatory arguments of the argument list.
+The splice operator can also be used to transform a table into an argument list for a function, for example:
+<code>
+def args := [3,4,5];
+> sum(1,2, @args);
+>> 15
+</code>
+One way to think about this is that the splice operator splices the ''args'' table into the table of actual arguments. The "rest" arguments do not necessarily need to be the last parameters, for example:
+<code>
+> sum(1,2,@args,6);
+>> 21
+</code>
+==== Optional Parameters ====
 A function can also declare optional arguments as shown below. Optional arguments can be omitted in a function call. If this is the case, the default expression provided in their definition is evaluated and passed as argument to the function instead.
@@ Line 228: / Line 241: @@
    foreach: { |el| total := total + el} in: rest; total
  };
->>
+>><closure:lambda>
 >sum(1,2,3)
 >>6
@@ Line 247: / Line 260: @@
   def i := 0;
   def mapped[tbl.length] {
-    clo(tbl[i:=i+1])
+    i := i+1;
+    clo( tbl[ i ] )
   };
 }
@@ Line 343: / Line 357: @@
 >>true
 </code>
 ==== Tables ====
-We have already introduce how to define tables. Let us now focus on how to manipulate them with the native methods provided by the table object.
+We have already introduced how to define tables. Let us now focus on how to manipulate them with the native methods provided by the table object.
 <code>
 >[1,2,3].filter: {|e| e != 2 }
@@ Line 403: / Line 418: @@
 >>1
 > def [i, j] := [1,3]
->>>[1, 3]
+>>[1, 3]
 >{i < j}.whileTrue: { system.println(i); i := i + 1 }
@@ Line 416: / Line 431: @@
 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])