Differences

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

--- at:tutorial:basic [2007/04/04 10:56] – elisag
+++ at:tutorial:basic [2007/04/05 09:59] – elisag
@@ Line 1: / Line 1: @@
 <note>
-**IN PROGRESS**
+**UNDER CONSTRUCTION!!**
-  - Could it be possible that the "table of contents" table in this page contains also a link to the actual page with the table of contents of the tutorial?
-  - (TOADD_1:) how to define and deal with multidimensional tables.
 </note>
@@ Line 47: / Line 45: @@
 <code>
->def vocals := [1, t, "a", "e", "i", "o", "u"]
+>def vocals := ["a", "e", "i", "o", "u"]
 >>["a", "e", "i", "o", "u"]
->t[3] := vocals;
+>table[3] := vocals
 >>[1, 2, ["a", "e", "i", "o", "u"], 4, 5]
->t[3][2]
+>table[3][2]
 >>"e"
 </code>
 As shown in the definition of the varible "vocals", evaluating a series of comma-separated abstract grammar values between square brackets (aka a tabulation) results in a table.
+<code>
+>[ 1, table, "ambientTalk"]
+>>[1, [1, 2, ["a", "e", "i", "o", "u"], 4, 5], "ambientTalk"]
+</code>
 ==== Functions ====
-As variables and tables, functions are defined with the keyworkd def in the form of:
+As variables and tables, functions are defined with the keyword **def** in the form of:
 <code>
 def functionname( <arglist> ) { <body> }
 </code>
-The argument list is just a list of local variables which are always evaluated one by one from left to right.  A basic function looks like this:
+The argument list is just a list of local variables which are always evaluated one by one from left to right. A basic function looks like this:
 <code>
 >def square (x) { x*x }
@@ Line 70: / Line 73: @@
 >>25
 </code>
-As usual, functions can call themselves recusively. More interesting, you can also nest definitions of functions inside other functions as in:
+This example also illustrates how functions are called. Calls to functions without parameters must also include the parenthesis.
+Functions have access to the enclosing environment of its definition as shown in the following example.
+<code>
+>def counter := 0
+>>0
+> def inc() { counter := counter + 1}
+>><closure:inc>
+>inc()
+>>1
+</code>
+Functions can call themselves recusively and they can also be nested in the definitions of other functions such as:
 <code>
 >def fac(n) {
@@ Line 78: / Line 93: @@
   inner(n,1)
 }
->>nil
+>><closure:fac>
 >fac(5)
 >>120
 </code>
-Note that variables and functions defined locally to functions are only visible in the scope of the function where there were defined. Notice also that a function name can also be used just to refer the function but without calling it.
-Unlike Pico, AmbientTalk doesn't support function assigment. However, you can assign functions to variables. This means that a closure will be created and assigned to the variable. What follows is an example of such manipulation.
+Variables and functions defined locally to functions are only visible in the scope of the function where there were defined.  In the previous example, //fac// uses a local function //inner// that is only visible inside //fac// and its nested scopes, in the example //fac.inner.//
+=== Variable-Length Argument Functions ===
+You can create functions that take an arbitrary  number of arguments by means of the splicing operator **@** as shown below:
+<code>
+>def sum(@args){ {
+  def total := 0;
+  foreach: { |el|  total := total + el } in: args;
+  total}
+>><closure:sum>
+>sum(1,2,3)
+>>6
+</code>
+When the //sum// function is called, the arguments are passed to the function in a table called //args// which can also be modified inside the body of the function. An alternative definition of the //sum// function follows:
+<code>
+>def sum(a, b, @rest){ {
+  def total := a + b;
+  foreach: { |el|  total := total + el } in: rest;
+  total}
+>><closure:sum>
+>sum(1,2,3)
+>>6
+</code>
+In this example the //sum// function accepts an arbitrary number of arguments as long as two arguments, //a// and //b//, are supplied. //a// and //b// are thus considered as mandatory arguments. A function can also declare optional arguments as shown below:
+<code>
+>def incr( number, step := 1){ number + step}
+>><closure:incr>
+>incr(3)
+>>4
+>incr(3,3)
+>>6
+</code>
+==== Closures and Blocks ====
+The function name can also be used just to refer the function but without calling it. TODO!
+Unlike Pico, AmbientTalk doesn't support function assigment. However, one can assign functions to variables. This means that internally a closure will be created and assigned to the variable. What follows is an example of such manipulation:
 <code>
 >def sum := 0