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/04 11:51] – * elisagat:tutorial:basic [2007/04/05 10:04] – elisag
Line 2: Line 2:
 **UNDER CONSTRUCTION!!** **UNDER CONSTRUCTION!!**
 </note> </note>
- +====== Functional and Imperative Programming ====== 
-==== Functional and Imperative Programming ==== + 
 This part of the tutorial shows AmbientTalk as a simple expression language with a minimum syntax which resembles very on Java script. This section mainly describes the basic features of the language, namely variables, functions and tables and control flow. This part of the tutorial shows AmbientTalk as a simple expression language with a minimum syntax which resembles very on Java script. This section mainly describes the basic features of the language, namely variables, functions and tables and control flow.
  
-==== Variables ====+===== Variables =====
    
 As usual, one can define, assign and refer to a variable. Variable definitions are made with the keyword **def**. Note that AmbientTalk is a dynamically typed language so, variables do not have a type but, they just contain values. As usual, one can define, assign and refer to a variable. Variable definitions are made with the keyword **def**. Note that AmbientTalk is a dynamically typed language so, variables do not have a type but, they just contain values.
Line 29: Line 28:
 Reference is just done by evaluating the variable.  Reference is just done by evaluating the variable. 
  
-==== Tables ====+===== Tables =====
  
-As in Pico, indexed tables represent what other languages call arrays or lists. Tables are unidimensional and their indexes range from 1 to the size of the table. As variables, one can define, assign and refer to a table. Table definition is also made  with the keyword **def** in the following form:+Indexed tables represent what other languages call arrays or lists. Tables are unidimensional and their indexes range from 1 to the size of the table. As variables, one can define, assign and refer to a table. Table definition is also made  with the keyword **def** in the following form:
 <code> <code>
 def t[ <size> ] { <expression> } def t[ <size> ] { <expression> }
Line 42: Line 41:
 >>[1, 2, 3, 4, 5] >>[1, 2, 3, 4, 5]
 </code> </code>
-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 vocals := ["a", "e", "i", "o", "u"]
Line 53: Line 52:
 </code> </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.+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> <code>
Line 60: Line 59:
 </code> </code>
  
-==== Functions ====+=== Table Splicing === 
 + 
 +TODO! 
 + 
 +===== Functions =====
    
 As variables and tables, functions are defined with the keyword **def** in the form of:  As variables and tables, functions are defined with the keyword **def** in the form of: 
Line 73: Line 76:
 >>25 >>25
 </code> </code>
-Functions can call themselves recusively and as in Pico, functions can also be nested in the definitions other functions such as: +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> <code>
 >def fac(n) {  >def fac(n) { 
Line 81: Line 96:
   inner(n,1)   inner(n,1)
 } }
->>nil+>><closure:fac>
 >fac(5) >fac(5)
 >>120 >>120
 </code> </code>
  
-Variables and other functions defined locally to a function are only visible in the scope of the function where there were defined.+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>
 +
 +===== Blocks =====
  
 The function name can also be used just to refer the function but without calling it. TODO! The function name can also be used just to refer the function but without calling it. TODO!
Line 103: Line 153:
 >>3 >>3
 </code> </code>
- 
-==== Blocks ==== 
at/tutorial/basic.txt · Last modified: 2020/02/09 22:05 by elisag