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/04/06 08:26] – elisagat:tutorial:basic [2007/04/06 09:00] – * elisag
Line 2: Line 2:
 **IN PROGRESS: FIRST DRAFT!!** **IN PROGRESS: FIRST DRAFT!!**
  
-- TODO: Adding Table splicing, quasi-quoting?+- Add quasi-quoting?
 </note> </note>
 ====== Functional and Imperative Programming ====== ====== Functional and Imperative Programming ======
Line 46: Line 46:
 Although there is no special constructor for definition of multidimensional tables, a table entry can contain another table. This is internally stored as a unidimensional table whose entries are other tables. Although there is no special constructor for definition of multidimensional tables, a table entry can contain another table. This is internally stored as a unidimensional table whose entries are other tables.
 <code> <code>
->def vocals := ["a", "e", "i", "o", "u"]+>def vowels := ["a", "e", "i", "o", "u"]
 >>["a", "e", "i", "o", "u"] >>["a", "e", "i", "o", "u"]
->table[3] := vocals+>table[3] := vowels
 >>[1, 2, ["a", "e", "i", "o", "u"], 4, 5] >>[1, 2, ["a", "e", "i", "o", "u"], 4, 5]
 >table[3][2] >table[3][2]
Line 61: Line 61:
 </code> </code>
  
-=== Table Splicing ===+==== Table Splicing ====
  
 TODO! TODO!
Line 112: Line 112:
 This example also illustrates how a function can be made private by means of lexical scope. Variables and functions defined locally to functions are only visible in the scope of the function where there were defined. Note that local //inner// function is only visible inside the //fac// function and its nested scopes. Thus, calling //fac.inner(2,3)// will return a lookup failure error. This example also illustrates how a function can be made private by means of lexical scope. Variables and functions defined locally to functions are only visible in the scope of the function where there were defined. Note that local //inner// function is only visible inside the //fac// function and its nested scopes. Thus, calling //fac.inner(2,3)// will return a lookup failure error.
    
-=== Variable-Length Argument Functions ===+==== Variable-Length Argument Functions ====
  
 You can create functions that take an arbitrary  number of arguments by means of the splicing operator **@** as shown below: You can create functions that take an arbitrary  number of arguments by means of the splicing operator **@** as shown below:
Line 198: Line 198:
  
 AmbientTalk supports keyword messages. We have already seen some examples of keyword messages in the previous sections such as the foreach structure. In AmbientTalk keywords are transformed by the parser into functions in the form: AmbientTalk supports keyword messages. We have already seen some examples of keyword messages in the previous sections such as the foreach structure. In AmbientTalk keywords are transformed by the parser into functions in the form:
 +<code>
 def foo: arg1 bar: arg2 {...} def foo: arg1 bar: arg2 {...}
 def foo:bar:(arg1,arg2){..} def foo:bar:(arg1,arg2){..}
 +</code>
  
 ===== Native Data Types ===== ===== Native Data Types =====
Line 253: Line 253:
 >"ambienttalk".explode() >"ambienttalk".explode()
 >>["a", "m", "b", "i", "e", "n", "t", "t", "a", "l", "k"] >>["a", "m", "b", "i", "e", "n", "t", "t", "a", "l", "k"]
->"one, two, three".split(", ")+>"one, two, three".split(",")
 >>["one", "two", "three"] >>["one", "two", "three"]
->"ambienttalk".replace: "[aeiou]" by: { |vowel| vowel.toUpperCase() }+>"ambienttalk".replace: "[aeiou]" by: { 
 + |vowel| vowel.toUpperCase()  
 +}
 >>"AmbIEnttAlk" >>"AmbIEnttAlk"
 >"A".toLowerCase() >"A".toLowerCase()
Line 273: Line 275:
 ==== 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.
 +<code>
 +>[1,2,3].filter: {|e| e != 2 }
 +>>[1, 3]
 +>[1,2,3].map: { |i| i + 1 }
 +>>[2, 3, 4]
 +>def vowels := ["a", "e", "i", "o", "u"]
 +>>["a", "e", "i", "o", "u"]
 +>vowels.length
 +>>5
 +>vowels.at(1)
 +>>"a"
 +>vowels.atPut(1, "z")
 +>>"z"
 +>vowels
 +>>["z", "e", "i", "o", "u"]
 +>vowels.select(2,5).implode()
 +>>"eio"
 +>vowels.isEmpty()
 +>>false
 +</code>
 +
 +Tables also support some useful iterator methods such as:
 +<code>
 +>def sum:= 0; 
 +>>0
 +>[1,2,3].each: { |i| sum := sum + i }
 +>>nil
 +>sum
 +>>6
 +>def sumNnum (@args) {
 +  args.inject: 0 into: { |total, next| total + next}
 +}
 +>><closure:sumNnum>
 +>sumNnum(1,2,3)
 +>>6
 +</code>
  
 ==== Booleans ==== ==== Booleans ====
Line 300: Line 340:
  
 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. 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.
- 
  
 ===== Control Flow Structures ===== ===== Control Flow Structures =====
Line 321: Line 360:
      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 
at/tutorial/basic.txt · Last modified: 2020/02/09 22:05 by elisag