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

Next revision		Previous revision
Next revisionBoth sides next revision
at:tutorial:basic [2007/03/31 12:43] – moved ambientat:tutorial:basic [2007/04/04 11:03] – * elisag
Line 5: Line 5:
 </note> </note>
  
-==== Basic 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.
Line 11: Line 11:
 ==== 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.
  
 In the examples we use the interactive AmbientTalk shell (iat) where the input and output prompt are represented by > and >> , respectively.  In the examples we use the interactive AmbientTalk shell (iat) where the input and output prompt are represented by > and >> , respectively. 
Line 24: Line 24:
 Variable definitions can be combined with assignments as shown above. As in Pico, assignments uses the ":=" operator. Note that there must be an space between the variable and the ":=" operator in order for the parse to resolve the ambiguity between a keyword message and a assignment, e.g. "a := 1" is understood as an assignment while "a:" as a keyword. We will further elaborate on keywords in the following sections. Variable definitions can be combined with assignments as shown above. As in Pico, assignments uses the ":=" operator. Note that there must be an space between the variable and the ":=" operator in order for the parse to resolve the ambiguity between a keyword message and a assignment, e.g. "a := 1" is understood as an assignment while "a:" as a keyword. We will further elaborate on keywords in the following sections.
  
-An assignment consists of one or more expressions, providing that the number of expressions the the right hand side match the number of variables on the left hand side. This allows a permutation of variables such as:+An assignment consists of one or more expressions, providing that the number of expressions on the right hand side match the number of variables on the left hand side. This allows a permutation of variables such as:
 <code> <code>
 >[x, y] := [ y, x ] >[x, y] := [ y, x ]
Line 33: Line 33:
 ==== Tables ==== ==== Tables ====
  
-As in Pico, indexed tables represent what other languages call arrays or lists. Tables indexes range from 1 to the size of the table. As variables, one can define, assign and refer to a table. Table definition is made also with the keyword def  in the following form:+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:
 <code> <code>
 def t[ <size> ] { <expression> } def t[ <size> ] { <expression> }
Line 41: Line 41:
 >def z := 0 >def z := 0
 >>0 >>0
->def t[5] { z := z + 1 }+>def table[5] { z := z + 1 }
 >>[1, 2, 3, 4, 5] >>[1, 2, 3, 4, 5]
 </code> </code>
-Table entries can also contain another tables. -> TOADD_1+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> 
 +>def vocals := ["a", "e", "i", "o", "u"] 
 +>>["a", "e", "i", "o", "u"] 
 +>table[3] := vocals 
 +>>[1, 2, ["a", "e", "i", "o", "u"], 4, 5] 
 +>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 ==== ==== 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> <code>
 def functionname( <arglist> ) { <body> } def functionname( <arglist> ) { <body> }
 </code> </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> <code>
 >def square (x) { x*x } >def square (x) { x*x }
at/tutorial/basic.txt · Last modified: 2020/02/09 22:05 by elisag