Differences

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

--- at:tutorial:basic [2007/04/04 11:25]
elisag
+++ at:tutorial:basic [2020/02/09 22:05]
elisag
@@ Line 1: / Line 1: @@
-<note>
-**UNDER CONSTRUCTION!!**
-</note>
-==== 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.
-==== 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.
-<code>
->def x := 5
->>5
->def y := x + 2
->>7
-</code>
-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 on the right hand side match the number of variables on the left hand side. This allows a permutation of variables such as:
-<code>
->[x, y] := [ y, x ]
->>[7,5]
-</code>
-Reference is just done by evaluating the variable.
-==== 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:
-<code>
-def t[ <size> ] { <expression> }
-</code>
-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:
-<code>
->def z := 0
->>0
->def table[5] { z := z + 1 }
->>[1, 2, 3, 4, 5]
-</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.
-<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 ====
-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:
-<code>
->def square (x) { x*x }
->>nil
->square(5)
->>25
-</code>
-Functions can call themselves recusively and as in Pico, functions can also be nested in the definitions other functions such as:
-<code>
->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
-</code>
-Variables and other functions defined locally to a function 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, 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
->>0
->sum := sum + 1
->>1
->sum := { | x, y| x + y }
->>nil
->sum(1,2)
->>3
-</code>
-==== Blocks ====

Ambient-Oriented Programming

User Tools

Site Tools

Differences

Page Tools