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 revision Previous revision
Next revision 		Previous revision
at:tutorial:basic [2007/04/17 17:26]
tvcutsem 		at:tutorial:basic [2020/02/09 22:05] (current)
elisag
Line 1: Line 1:
-<note> 
-**This Tutorial is still under heavy construction!!** 
-</note> 
 ====== Functional and Imperative Programming ====== ====== Functional and Imperative Programming ======
    
Line 34: Line 31:
 </code> </code>
  
-<note>+<note important>
 When using the '':='' assignment operator, beware of the following syntactic annoyance: the expression ''a := 1'' denotes an assignment to the variable ''a'', while ''a:= 1'' is misunderstood by the parser as ''a: = 1'', which is the invocation of a keyworded message named ''a:''. Keyworded message sends will be explained later on in this chapter. Hence, as a general rule, don't forget to always put a space between the variable name and the '':='' operator. When using the '':='' assignment operator, beware of the following syntactic annoyance: the expression ''a := 1'' denotes an assignment to the variable ''a'', while ''a:= 1'' is misunderstood by the parser as ''a: = 1'', which is the invocation of a keyworded message named ''a:''. Keyworded message sends will be explained later on in this chapter. Hence, as a general rule, don't forget to always put a space between the variable name and the '':='' operator.
 </note> </note>
Line 69: Line 66:
 >>[1, [1, 2, ["a", "e", "i", "o", "u"], 4, 5], "ambientTalk"] >>[1, [1, 2, ["a", "e", "i", "o", "u"], 4, 5], "ambientTalk"]
 </code> </code>
 +
  
 ==== Table Splicing ==== ==== Table Splicing ====
Line 87: Line 85:
 >>[2, 3, 4] >>[2, 3, 4]
 </code> </code>
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +
 +==== Multidimensional Tables ====
 +
 +As mentioned before, there is no special constructor for definition of multidimensional tables, a table entry can contain another table. In what follows we have a closer look to manipulations with multidimensional tables.  Consider a multidimensional table which is extensionally defined as follows:
 +
 +<code>
 +def a := [[1,0,0], [0,1,0], [0,0,1]];
 +>>[[1, 0, 0], [0, 1, 0], [0, 0, 1]]
 +>a[1][2]
 +>>0
 +>a[1]
 +>>[1, 0, 0]
 +>(a[1])[2] := 3;
 +>>3
 +>a
 +>>[[1, 3, 0], [0, 1, 0], [0, 0, 1]]
 +</code>
 +
 +An implicit definition of the same table can be expressed as follows:
 +
 +<code>
 +def i := 0;
 +def aux[3] {0}; 
 +def b[3] { i := i + 1; aux := [0,0,0]; aux[i] :=1; aux};
 +>>[[1, 0, 0], [0, 1, 0], [0, 0, 1]]
 +</code>
 +
 +You can find later in this chapter a helper function for creating matrices  [[:at:tutorial:basic#optional_parameters|here]].
 +
 + 
  
 ===== Functions ===== ===== Functions =====
Line 176: Line 216:
 </code> </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. +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. 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 188: Line 248:
 </code> </code>
  
-As is customary in languages with the above parameter passing semantics, AmbientTalk requires mandatory parameters to be defined //before// optional parameters, which should in turn be defined //before// a variable-argument parameter, if any.+As is customary in languages with the above optional arguments, AmbientTalk requires mandatory parameters to be defined //before// optional parameters, which should in turn be defined //before// a variable-argument parameter, if any. 
 + 
 +Let us show how to use optional arguments to define an auxilary function that creates matrices: 
 + 
 +<code> 
 +def makeMatrix(n, m := n, init := { |i,j| 0}){ 
 +  def [i,j] := [0,0]; 
 +  def makeCol(i,j) { 
 +     def col[m] { j := j + 1; init(i,j) } 
 +  }; 
 +  def matrix[n] { i := i + 1; makeCol(i,j)} 
 +}; 
 +>def c := makeMatrix(3); 
 +>>[[0, 0, 0], [0, 0, 0], [0, 0, 0]] 
 +>c[1] := [1,2,3] 
 +>>[1, 2, 3] 
 +>c 
 +>>[[1, 2, 3], [0, 0, 0], [0, 0, 0]] 
 +>def d := makeMatrix(4,4,  
 +  {|i,j| if: (i == j) then: {1} else: {0}}); 
 +>> [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]] 
 +</code>
  
 ===== Closures ===== ===== Closures =====
Line 204: Line 285:
 >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 308:
    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 234: Line 319:
 AmbientTalk borrows its block syntax from languages like Smalltalk and Self, where the role of the curly braces is played by square brackets, i.e. ''[ args | body ]''. In AmbientTalk, the ''<parlist>'' is only used to denote parameters to the block, not also for temporary variables as in Smalltalk. AmbientTalk borrows its block syntax from languages like Smalltalk and Self, where the role of the curly braces is played by square brackets, i.e. ''[ args | body ]''. In AmbientTalk, the ''<parlist>'' is only used to denote parameters to the block, not also for temporary variables as in Smalltalk.
 </note> </note>
 +
 +
  
 ===== Keywords ===== ===== Keywords =====
Line 243: Line 330:
   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 264: Line 352:
 </code> </code>
  
-However, it is impossible to directly call or define a keyworded function in a canonical style.+It is also possible to invoke keyworded functions using the canonical function application syntax: 
 + 
 +<code> 
 +foo:bar:(1,2) 
 +</code> 
 + 
 +<note important> 
 +Be careful when nesting calls to keyworded functions: a call of the form ''foo: foo: 1 bar: 2 bar: 3'' is parsed as ''foo: (foo: 1 bar: 2 bar: 3)'', not as ''foo: (foo: 1 bar: 2) bar: 3''. It is recommended to always explicitly parenthesize nested keyworded function calls. 
 +</note>
  
 ===== Native Data Types ===== ===== Native Data Types =====
  
 The basic data types in AmbientTalk are numbers (i.e. integers), fractions (i.e. double precision floating point numbers), text (i.e. strings), tables (i.e. arrays) and booleans. In fact, instances of these data types are nothing but objects and as such, they respond to a variety of native methods. Objects will be the subject of the next chapter of the tutorial. This section explains the basic data types and includes some examples how to manipulate them. The complete list of methods can be found in the language reference. The basic data types in AmbientTalk are numbers (i.e. integers), fractions (i.e. double precision floating point numbers), text (i.e. strings), tables (i.e. arrays) and booleans. In fact, instances of these data types are nothing but objects and as such, they respond to a variety of native methods. Objects will be the subject of the next chapter of the tutorial. This section explains the basic data types and includes some examples how to manipulate them. The complete list of methods can be found in the language reference.
 +
 +
  
 ==== Numerical data types ==== ==== Numerical data types ====
Line 301: Line 399:
 Numbers also support some useful iterator methods such as: Numbers also support some useful iterator methods such as:
 <code> <code>
->6.to: 0 step: 2 do: { |i| system.println(i) }+>1.to: 5 do: { |i| system.println(i)} 
 +1 
 +2 
 +3 
 +4 
 +5 
 +>1.to: 5 step: 2 do: { |i| system.println(i)} 
 +1 
 +3 
 +5 
 +>6.downTo: 0 step: 2 do: { |i| system.println(i) }
 6 6
 4 4
 2 2
 +0
 >>nil  >>nil 
 >3.doTimes: { |i| system.println(i) } >3.doTimes: { |i| system.println(i) }
Line 339: Line 448:
 >>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 384: Line 494:
 ==== Booleans ==== ==== Booleans ====
    
- +As any native type, booleans are objects so, they respond to keyword messages such as:
-AmbientTalk supports infix operators for booleans as &, | and !. As any native type, booleans are objects so, they respond to keyword messages such as:+
 <code> <code>
 <booleanexpr>.ifTrue: { ...}  <booleanexpr>.ifTrue: { ...} 
Line 393: Line 502:
 </code> </code>
  
-**=** and **!=** are the infix operators for equality and inequality. **true** and **false** are the boolean constant objects. What follows is some basic examples of boolean manipulation:+''='' and ''!='' are the infix operators for equality and inequality. The prefix operator ''!'' represents logical negation. ''true'' and ''false'' are the prototypical boolean singleton objects. What follows is some basic examples of boolean manipulation:
 <code> <code>
 >(0 < 1).ifTrue: { 0 }  >(0 < 1).ifTrue: { 0 } 
Line 400: Line 509:
 >>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 407: Line 516:
 </code> </code>
  
-Boolean infix operators such as & and | are not shortcut. Thus, both arguments will be evaluated. For lazy evaluation, you should use the natives methods. For example, false.and: { 1/0 } will return false without executing the second argument.+Compound boolean expressions can be created by means of a boolean's ''and:'' and ''or:'' methods, which both take a zero-argument closure as argument. For example, ''false.and: { 1/0 }'' will return ''false''. The block is not applied because a logical //and// with ''false'' always fails.
  
-===== Control Flow Structures =====+===== Control Flow Constructs =====
  
-Control flow structures are defined in the lexical root of AmbientTalk. The lexical root is an object containing globally visible native methods. We have already seen in the previous sections examples of usage of the foreach and if/then structures. The complete list of traditional control flow structures defined in AmbientTalk is shown below:+Control flow constructs are defined in the "lexical root". 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:'' control 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: { |v| body } in: [ table ] +foreach: iteratorClosure in: table 
-do: { body } if: condition +do: bodyClosure if: condition 
-do: { body } unless: condition+do: bodyClosure unless: condition
 </code> </code>
-An example of usage for some of these structures is shown below in the definition of the sort function.+ 
 +<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 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.length); 
- };+};
 >><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.1176823575.txt.gz · Last modified: 2007/04/17 17:30 (external edit)

Page Tools

Except where otherwise noted, content on this wiki is licensed under the following license: CC Attribution-Share Alike 4.0 International
CC Attribution-Share Alike 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki