Ambient-Oriented Programming

User Tools

Site Tools

Trace:
at:tutorial:basic

Differences

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

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
Next revisionBoth sides next revision
at:tutorial:basic [2007/05/15 19:36] – * tvcutsemat:tutorial:basic [2008/07/03 16:20] – * tvcutsem
Line 1: Line 1:
-<note> +
-**This Tutorial is still under heavy construction!!** +
-</note>+
 ====== Functional and Imperative Programming ====== ====== Functional and Imperative Programming ======
    
Line 204: Line 202:
 >def [get, set] := makeCell(42); >def [get, set] := makeCell(42);
 >>[<closure:getter>, <closure:setter>] >>[<closure:getter>, <closure:setter>]
 +>get();
 +>>42
 </code> </code>
  
Line 225: Line 225:
    def total := a + b;     def total := a + b; 
    foreach: { |el| total := total + el} in: rest; total     foreach: { |el| total := total + el} in: rest; total 
- }; sum(1,2,3)+ }; 
 +>><closure:lambda>  
 +>sum(1,2,3)
 >>6 >>6
 </code> </code>
Line 243: Line 245:
   def i := 0;   def i := 0;
   def mapped[tbl.length] {   def mapped[tbl.length] {
-    clo(tbl[i:=i+1])+    i := i+1; 
 +    clo( tbl[ i ] )
   };   };
 } }
Line 339: Line 342:
 >>true >>true
 </code> </code>
 +
  
 ==== Tables ==== ==== 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> <code>
 >[1,2,3].filter: {|e| e != 2 } >[1,2,3].filter: {|e| e != 2 }
Line 399: Line 403:
 >>1 >>1
 > def [i, j] := [1,3] > def [i, j] := [1,3]
->>>[1, 3]+>>[1, 3]
 >{i < j}.whileTrue: { system.println(i); i := i + 1 } >{i < j}.whileTrue: { system.println(i); i := i + 1 }
 1 1
Line 412: 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: 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> <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> </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> 
 + 
 +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 these structures is shown below in the definition of the sort function.+An example of usage for some of the above structures is shown below in the definition of the sort function.
 <code> <code>
 >def sort(table, cmp := { |e1,e2| e1 < e2 }) { >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.getLength()); 
- };+};
 >><closure:sort> >><closure:sort>
 >sort([2,37,6,4,5,8]) >sort([2,37,6,4,5,8])
 >>[2, 4, 5, 6, 8, 37] >>[2, 4, 5, 6, 8, 37]
 </code> </code>
 +
 +AmbientTalk has no ''return'' statement. To achieve a similar jump in the control flow, see the section on [[:at:tutorial:modular#escaping_continuations|escaping continuations]].
at/tutorial/basic.txt · Last modified: 2020/02/09 22:05 by elisag