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/06/25 21:03] – tvcutsemat:tutorial:basic [2008/03/12 17:17] – * 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 339: Line 341:
 >>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 402:
 >>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 414: Line 417:
 if: booleanCondition then: consequent if: booleanCondition then: consequent
 if: booleanCondition then: consequent else: alternative if: booleanCondition then: consequent else: alternative
-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>
  
-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> <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])
at/tutorial/basic.txt · Last modified: 2020/02/09 22:05 by elisag