at:tutorial:basic
Differences
This shows you the differences between two versions of the page.
Both sides previous revisionPrevious revisionNext revision | Previous revisionNext revisionBoth sides next revision | ||
at:tutorial:basic [2007/04/04 10:56] – elisag | at:tutorial:basic [2007/04/06 08:08] – * elisag | ||
---|---|---|---|
Line 1: | Line 1: | ||
< | < | ||
- | **IN PROGRESS** | + | **IN PROGRESS!!** |
- | - Could it be possible that the " | + | - TODO: Talk about methods instead |
- | - (TOADD_1:) how to define and deal with multidimensional tables. | + | |
</ | </ | ||
- | + | ====== 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 31: | Line 29: | ||
Reference is just done by evaluating the variable. | Reference is just done by evaluating the variable. | ||
- | ==== Tables ==== | + | ===== Tables |
- | As in Pico, indexed | + | Indexed |
< | < | ||
def t[ < | def t[ < | ||
Line 44: | Line 42: | ||
>>[1, 2, 3, 4, 5] | >>[1, 2, 3, 4, 5] | ||
</ | </ | ||
- | 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. | ||
< | < | ||
- | >def vocals := [1, t, " | + | >def vocals := [" |
>> | >> | ||
- | >t[3] := vocals; | + | >table[3] := vocals |
>>[1, 2, [" | >>[1, 2, [" | ||
- | >t[3][2] | + | >table[3][2] |
>>" | >>" | ||
</ | </ | ||
- | As shown in the definition of the varible | + | As shown in the definition of the varible |
+ | |||
+ | < | ||
+ | >[ 1, table, " | ||
+ | >>[1, [1, 2, [" | ||
+ | </ | ||
+ | |||
+ | === Table Splicing === | ||
+ | |||
+ | TODO! | ||
- | ==== Functions ==== | + | ===== Functions |
- | As variables and tables, functions are defined with the keyworkd | + | As variables and tables, functions are defined with the keyword **def** in the form of: |
< | < | ||
def functionname( < | def functionname( < | ||
</ | </ | ||
- | The argument list is just a list of local variables which are always evaluated one by one from left to right. | + | 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 } | >def square (x) { x*x } | ||
Line 70: | Line 77: | ||
>>25 | >>25 | ||
</ | </ | ||
- | As usual, | + | This example also illustrates how functions |
+ | < | ||
+ | >def f(){nil} | ||
+ | >>< | ||
+ | >f() | ||
+ | >> | ||
+ | </ | ||
+ | The return value of a function is the result of the last statement executed. Functions must always return a value - i.e. they cannot be abstract. The example also illustrates how to create dumb function that doesn' | ||
+ | |||
+ | Functions have access to the enclosing environment of its definition as shown in the following example. | ||
+ | < | ||
+ | >def counter := 0 | ||
+ | >>0 | ||
+ | > def inc() { counter := counter + 1} | ||
+ | >>< | ||
+ | >inc() | ||
+ | >>1 | ||
+ | </ | ||
+ | |||
+ | Functions | ||
< | < | ||
>def fac(n) { | >def fac(n) { | ||
Line 78: | Line 104: | ||
inner(n,1) | inner(n,1) | ||
} | } | ||
- | >>nil | + | >>< |
>fac(5) | >fac(5) | ||
>>120 | >>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' | + | This example also illustrates how a function can be made private by means of lexical scope. Variables |
+ | |||
+ | === Variable-Length Argument Functions === | ||
+ | |||
+ | You can create functions that take an arbitrary | ||
< | < | ||
- | >def sum := 0 | + | >def sum(@args){ { |
- | >>0 | + | def total := 0; |
- | > | + | |
- | >>1 | + | total} |
- | >sum := { | x, y| x + y } | + | >>< |
- | >>nil | + | >sum(1,2,3) |
- | > | + | >>6 |
- | >>3 | + | |
</ | </ | ||
- | ==== Blocks ==== | + | 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: |
+ | < | ||
+ | >def sum(a, b, @rest){ { | ||
+ | def total := a + b; | ||
+ | foreach: { |el| total := total + el } in: rest; | ||
+ | total} | ||
+ | >>< | ||
+ | > | ||
+ | >>6 | ||
+ | </ | ||
+ | |||
+ | 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: | ||
+ | < | ||
+ | >def incr( number, step := 1){ number + step} | ||
+ | >>< | ||
+ | > | ||
+ | >>4 | ||
+ | > | ||
+ | >>6 | ||
+ | </ | ||
+ | |||
+ | ===== Closures ===== | ||
+ | |||
+ | As you have probably noticed in the previous examples, | ||
+ | |||
+ | The function name can be thus used to refer the function (without calling it). This will also return a closure to that function. | ||
+ | |||
+ | |||
+ | ===== Blocks ===== | ||
+ | |||
+ | In AmbientTalk, | ||
+ | < | ||
+ | { |< | ||
+ | </ | ||
+ | If the block do not require any parameter, the |< | ||
+ | < | ||
+ | >{| a, b| a+ b} (3,2) | ||
+ | >>5 | ||
+ | </ | ||
+ | Note that the argument list passed to the block can define the different types of arguments previously explained. | ||
+ | < | ||
+ | >{|a, b, @rest| | ||
+ | def total := a + b; | ||
+ | | ||
+ | | ||
+ | >>6 | ||
+ | </ | ||
+ | |||
+ | This example also illustrates that blocks are also used to iterate over enumerations, | ||
+ | |||
+ | AmbientTalk doesn’t support function assigment. However, one can assign blocks to variables. In order to call the block the name of the variable must be used. If the block defined parameters, these are required to the call as argument list. What follows is an example of such manipulation: | ||
+ | < | ||
+ | >def square := { |x| x * x } | ||
+ | >>< | ||
+ | > | ||
+ | >>3 | ||
+ | </ |
at/tutorial/basic.txt · Last modified: 2020/02/09 22:05 by elisag