User Tools
Sidebar
at:tutorial:basic
This is an old revision of the document!
Table of Contents
IN PROGRESS
- 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.
Basic 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.
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.
In the examples we use the interactive AmbientTalk shell (iat) where the input and output prompt are represented by > and » , respectively.
>def x := 5 >>5 >def y := x + 2 >>7
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:
>[x, y] := [ y, x ] >>[7,5]
Reference is just done by evaluating the variable.
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:
def t[ <size> ] { <expression> }
This means that the <expression> will be evaluated <size> times, i.e., one for each slot of the table. This allows expressions such as initializing a table of ascending numbers as shown below:
>def z := 0
>>0
>def t[5] { z := z + 1 }
>>[1, 2, 3, 4, 5]
Table entries can also contain another tables. → TOADD_1
Functions
As variables and tables, functions are defined with the keyworkd def in the form of:
def functionname( <arglist> ) { <body> }
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:
>def square (x) { x*x }
>>nil
>square(5)
>>25
As usual, functions can call themselves recusively. More interesting, you can also nest definitions of functions inside other functions as in:
>def fac(n) {
def inner(n, result) {
if: (n =0) then: { result } else: { inner( n-1, n * result) }
};
inner(n,1)
}
>>nil
>fac(5)
>>120
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.
>def sum := 0
>>0
>sum := sum + 1
>>1
>sum := { | x, y| x + y }
>>nil
>sum(1,2)
>>3
Blocks
at/tutorial/basic.1175337793.txt.gz · Last modified: 2007/04/04 09:10 (external edit)
Except where otherwise noted, content on this wiki is licensed under the following license: CC Attribution-Share Alike 4.0 International
