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/05 14:49] – elisag | at:tutorial:basic [2020/02/09 21:47] – elisag | ||
---|---|---|---|
Line 1: | Line 1: | ||
- | < | ||
- | **IN PROGRESS!!** | ||
- | - TODO: Talk about methods instead of functions? Check iat chapter. | ||
- | </ | ||
====== Functional and Imperative Programming ====== | ====== Functional and Imperative Programming ====== | ||
- | This part of the tutorial | + | This part of the tutorial |
===== 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 | + | 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 can contain |
- | In the examples we use the interactive AmbientTalk shell (iat) where the input and output prompt are represented by > and >> | + | In the examples we use the interactive AmbientTalk shell (iat) where the input and output prompt are represented by > and %%>>%% respectively. |
< | < | ||
Line 20: | Line 16: | ||
</ | </ | ||
- | Variable definitions can be combined with assignments as shown above. As in Pico, assignments uses the ":=" | + | Variable definitions can include an initialization expression that immediately initializes the variable. Variable assignment is performed by means of the well-known '' |
- | An assignment consists of one or more expressions, | ||
< | < | ||
>[x, y] := [ y, x ] | >[x, y] := [ y, x ] | ||
>> | >> | ||
</ | </ | ||
- | Reference | + | |
+ | As we will explain later, the '' | ||
+ | |||
+ | The variable name is used to refer a variable. The variable is evaluated when referenced. | ||
+ | < | ||
+ | >x | ||
+ | >>7 | ||
+ | </ | ||
+ | |||
+ | <note important> | ||
+ | When using the '': | ||
+ | </ | ||
===== Tables ===== | ===== Tables ===== | ||
- | Indexed tables represent | + | The //table// is AmbientTalk' |
< | < | ||
- | def t[ <size> ] { <expression> } | + | def t[ <sizeexpression> ] { <initexpression> } |
</ | </ | ||
- | This means that the <expression> will be evaluated | + | This constructs a table, |
< | < | ||
>def z := 0 | >def z := 0 | ||
Line 43: | Line 50: | ||
</ | </ | ||
- | 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 | + | Although there is no special constructor for definition of multidimensional tables, a table entry can contain another table. This is internally stored as a one-dimensional |
< | < | ||
- | > | + | > |
>> | >> | ||
- | > | + | > |
>>[1, 2, [" | >>[1, 2, [" | ||
> | > | ||
Line 53: | Line 60: | ||
</ | </ | ||
- | 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 | + | As shown in the definition of the variable '' |
< | < | ||
Line 60: | Line 67: | ||
</ | </ | ||
- | === Table Splicing === | ||
- | TODO! | + | ==== Table Splicing ==== |
+ | |||
+ | AmbientTalk provides the //splice operator// '' | ||
+ | < | ||
+ | > | ||
+ | >>[1, 2, 3, 4] | ||
+ | >[1, @[2,[3]], [4], @[5], @[], 6] | ||
+ | >>[1, 2, [3], [4], 5, 6] | ||
+ | </ | ||
+ | |||
+ | The splicing operator can be also used in the left-hand side of an assignment or definition to separate the head of a table with its rest elements, as shown below. | ||
+ | < | ||
+ | >def [first, @rest] := [1,2,3,4] | ||
+ | >>[1, 2, 3, 4] | ||
+ | >rest | ||
+ | >>[2, 3, 4] | ||
+ | </ | ||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | |||
+ | ==== Multidimensional tables ==== | ||
+ | |||
+ | As mentioned before, there is no special constructor for definition of multidimensional tables, a table entry can contain another table. In what follows we have a closer look to manipulations with multidimensional tables. | ||
+ | |||
+ | < | ||
+ | def a := [[1,0,0], [0,1,0], [0,0,1]]; | ||
+ | >> | ||
+ | > | ||
+ | >>0 | ||
+ | >a[1] | ||
+ | >>[1, 0, 0] | ||
+ | > | ||
+ | >>3 | ||
+ | >a | ||
+ | >> | ||
+ | </ | ||
+ | |||
+ | An implicit definition of the same table can be expressed as follows: | ||
+ | |||
+ | < | ||
+ | def i := 0; | ||
+ | def aux[3] {0}; | ||
+ | def b[3] { i := i + 1; aux := [0,0,0]; aux[i] :=1; aux}; | ||
+ | >> | ||
+ | </ | ||
+ | |||
===== Functions ===== | ===== Functions ===== | ||
- | As variables and tables, functions are defined with the keyword **def** in the form of: | + | Analogous to 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. 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. Hence, AmbientTalk employs // |
< | < | ||
>def square (x) { x*x } | >def square (x) { x*x } | ||
Line 77: | Line 137: | ||
>>25 | >>25 | ||
</ | </ | ||
- | This example also illustrates | + | This example also illustrates |
< | < | ||
- | >def f(){nil} | + | >def f() { nil } |
>>< | >>< | ||
>f() | >f() | ||
>>nil | >>nil | ||
</ | </ | ||
- | The return value of a function is the result of the last statement | + | The return value of a function is the result of the last executed |
- | Functions have access | + | < |
+ | A function definition is a statement. The body of a function can contain a list of statements, each separated by '';'' | ||
+ | < | ||
+ | def funA() { | ||
+ | // do something useful | ||
+ | } | ||
+ | def funB() { | ||
+ | // do something else | ||
+ | } | ||
+ | </ | ||
+ | The parser will complain saying that '' | ||
+ | </ | ||
+ | |||
+ | Functions in AmbientTalk are //lexically scoped//, which means that free variables are looked up in the enclosing environment of the function | ||
< | < | ||
>def counter := 0 | >def counter := 0 | ||
Line 100: | Line 173: | ||
>def fac(n) { | >def fac(n) { | ||
def inner(n, result) { | def inner(n, result) { | ||
- | if: (n =0) then: { result } else: { inner( n-1, n * result) | + | if: (n = 0) then: { result } else: { inner( n-1, n * result) |
}; | }; | ||
inner(n,1) | inner(n,1) | ||
Line 109: | Line 182: | ||
</ | </ | ||
- | Variables and functions defined locally to functions are only visible in the scope of the function where there were defined. | + | This example also illustrates how a function can be made " |
- | === Variable-Length Argument Functions === | ||
- | You can create functions that take an arbitrary | + | ==== Variable-Length Argument Functions ==== |
+ | |||
+ | You can create functions that take an arbitrary number of arguments | ||
< | < | ||
- | >def sum(@args){ { | + | >def sum(@args) { |
def total := 0; | def total := 0; | ||
foreach: { |el| total := total + el } in: args; | foreach: { |el| total := total + el } in: args; | ||
- | total} | + | total |
+ | }; | ||
>>< | >>< | ||
> | > | ||
Line 124: | Line 199: | ||
</ | </ | ||
- | When the //sum// function is called, the arguments are passed to the function | + | When the //sum// function is called, the //args// table is spliced and passed |
+ | |||
+ | Alternatively, | ||
< | < | ||
>def sum(a, b, @rest){ { | >def sum(a, b, @rest){ { | ||
Line 135: | Line 212: | ||
</ | </ | ||
- | In this example | + | In that case, the //sum// function |
+ | |||
+ | The splice operator can also be used to transform a table into an argument list for a function, for example: | ||
+ | < | ||
+ | def args := [3,4,5]; | ||
+ | > sum(1,2, @args); | ||
+ | >> 15 | ||
+ | </ | ||
+ | |||
+ | One way to think about this is that the splice operator splices the '' | ||
+ | < | ||
+ | > sum(1, | ||
+ | >> 21 | ||
+ | </ | ||
+ | |||
+ | |||
+ | ==== Optional Parameters ==== | ||
+ | |||
+ | A function can also declare optional arguments as shown below. Optional arguments can be omitted in a function call. If this is the case, the default expression provided in their definition is evaluated and passed as argument to the function instead. | ||
< | < | ||
>def incr( number, step := 1){ number + step} | >def incr( number, step := 1){ number + step} | ||
Line 145: | Line 240: | ||
</ | </ | ||
+ | As is customary in languages with the above optional arguments, AmbientTalk requires mandatory parameters to be defined //before// optional parameters, which should in turn be defined //before// a variable-argument parameter, if any. | ||
+ | |||
+ | Let us show how to use optional arguments to define an auxilary function that creates matrices as follows: | ||
+ | |||
+ | < | ||
+ | def makeMatrix(n, | ||
+ | def [i,j] := [0,0]; | ||
+ | def makeCol(i, | ||
+ | def col[m] { j := j + 1; init(n,m) } | ||
+ | }; | ||
+ | def matrix[n] { i := i + 1; makeCol(i, | ||
+ | }; | ||
+ | def b := makeMatrix(2, | ||
+ | > | ||
+ | >> | ||
+ | > | ||
+ | >> false false false true | ||
+ | >def c := makeMatrix(3); | ||
+ | >> | ||
+ | >c[1] := [1,2,3] | ||
+ | >>[1, 2, 3] | ||
+ | >c | ||
+ | >> | ||
+ | </ | ||
===== Closures ===== | ===== Closures ===== | ||
- | The function name can also be used just to refer the function | + | As you have probably noticed in the previous examples, |
+ | |||
+ | The function name can be thus used to refer the function | ||
+ | < | ||
+ | >def makeCell(val){ | ||
+ | def getter() { val} ; | ||
+ | def setter(v) {val := v}; | ||
+ | [getter, setter] | ||
+ | } | ||
+ | >>< | ||
+ | >def [get, set] := makeCell(42); | ||
+ | >> | ||
+ | > | ||
+ | >> | ||
+ | </ | ||
+ | |||
+ | This example also illustrates how a function can make public some of its local fields or functions by returning them as its return value. The '' | ||
===== Blocks ===== | ===== Blocks ===== | ||
- | In AmbientTalk, | + | In AmbientTalk, |
< | < | ||
{ |< | { |< | ||
</ | </ | ||
- | If the block do not require any parameter, the |< | + | |
+ | If the block does not require any parameter, the |< | ||
< | < | ||
- | >{| a, b| a+ b} (3,2) | + | >{|a, b| a+ b}(3,2) |
>>5 | >>5 | ||
</ | </ | ||
Note that the argument list passed to the block can define the different types of arguments previously explained. | Note that the argument list passed to the block can define the different types of arguments previously explained. | ||
< | < | ||
- | >{|a, b, @rest| | + | >def sum := {|a, b, @rest| |
def total := a + b; | def total := a + b; | ||
| | ||
- | | + | }; |
+ | >>< | ||
+ | >sum(1,2,3) | ||
>>6 | >>6 | ||
</ | </ | ||
Line 172: | Line 310: | ||
This example also illustrates that blocks are also used to iterate over enumerations, | This example also illustrates that blocks are also used to iterate over enumerations, | ||
- | AmbientTalk | + | < |
+ | AmbientTalk | ||
+ | </ | ||
+ | |||
+ | |||
+ | |||
+ | ===== Keywords ===== | ||
+ | |||
+ | AmbientTalk supports keyworded messages, as in Smalltalk and Self. We have already seen some examples | ||
< | < | ||
- | >def square := { |x| x * x } | + | > |
- | >>< | + | def i := 0; |
- | >square(1,2) | + | def mapped[tbl.length] { |
- | >>3 | + | i := i+1; |
+ | clo( tbl[ i ] ) | ||
+ | }; | ||
+ | } | ||
+ | >> < | ||
+ | </ | ||
+ | |||
+ | It can be invoked as follows: | ||
+ | < | ||
+ | > | ||
+ | >> | ||
+ | </ | ||
+ | |||
+ | In AmbientTalk keyworded functions and function calls are actually syntactic sugar. They are transformed by the parser into their canonical equivalent. Hence: | ||
+ | < | ||
+ | def foo: arg1 bar: arg2 {...} | ||
+ | </ | ||
+ | is transformed into: | ||
+ | < | ||
+ | def foo: | ||
+ | </ | ||
+ | |||
+ | It is also possible to invoke keyworded functions using the canonical function application syntax: | ||
+ | |||
+ | < | ||
+ | foo: | ||
+ | </ | ||
+ | |||
+ | <note important> | ||
+ | Be careful when nesting calls to keyworded functions: a call of the form '' | ||
+ | </ | ||
+ | |||
+ | ===== Native Data Types ===== | ||
+ | |||
+ | The basic data types in AmbientTalk are numbers (i.e. integers), fractions (i.e. double precision floating point numbers), text (i.e. strings), tables (i.e. arrays) and booleans. In fact, instances of these data types are nothing but objects and as such, they respond to a variety of native methods. Objects will be the subject of the next chapter of the tutorial. This section explains the basic data types and includes some examples how to manipulate them. The complete list of methods can be found in the language reference. | ||
+ | |||
+ | |||
+ | |||
+ | ==== Numerical data types ==== | ||
+ | |||
+ | AmbientTalk supports numbers and fractions which represent what other languages call integers and double precision floating point numbers, respectively. | ||
+ | |||
+ | Note that since numerical types are objects in AmbientTalk, | ||
+ | < | ||
+ | > | ||
+ | >>2 | ||
+ | > | ||
+ | >> | ||
+ | >1 ** 5 | ||
+ | >>[1, 2, 3, 4] | ||
+ | >5 *** 1 | ||
+ | >>[5, 4, 3, 2, 1] | ||
+ | > | ||
+ | >>1 | ||
+ | > | ||
+ | >>1 | ||
+ | > | ||
+ | >>2 | ||
+ | </ | ||
+ | |||
+ | Beware of the precedence rules for function application versus method invocation, which may lead to unexpected results, e.g.: | ||
+ | < | ||
+ | > | ||
+ | >> | ||
+ | </ | ||
+ | This code is interpreted as '' | ||
+ | |||
+ | Numbers also support some useful iterator methods such as: | ||
+ | < | ||
+ | >1.to: 5 do: { |i| system.println(i)} | ||
+ | 1 | ||
+ | 2 | ||
+ | 3 | ||
+ | 4 | ||
+ | 5 | ||
+ | >1.to: 5 step: 2 do: { |i| system.println(i)} | ||
+ | 1 | ||
+ | 3 | ||
+ | 5 | ||
+ | > | ||
+ | 6 | ||
+ | 4 | ||
+ | 2 | ||
+ | 0 | ||
+ | >>nil | ||
+ | > | ||
+ | 1 | ||
+ | 2 | ||
+ | 3 | ||
+ | >> | ||
+ | </ | ||
+ | |||
+ | ==== Texts ==== | ||
+ | |||
+ | |||
+ | A text data type represent a string of characters. Texts are often created using sequences of characters surrounded by double quotes ("). AmbientTalk doesn' | ||
+ | < | ||
+ | >" | ||
+ | >> | ||
+ | >" | ||
+ | >> | ||
+ | >" | ||
+ | | ||
+ | } | ||
+ | >>" | ||
+ | >" | ||
+ | >>" | ||
+ | >" | ||
+ | >> | ||
+ | </ | ||
+ | |||
+ | AmbientTalk also provides some useful support for pattern matching using regular expressions. | ||
+ | < | ||
+ | >" | ||
+ | >> | ||
+ | >" | ||
+ | >> | ||
+ | </ | ||
+ | |||
+ | |||
+ | ==== Tables ==== | ||
+ | |||
+ | |||
+ | We have already introduced how to define tables. Let us now focus on how to manipulate them with the native methods provided by the table object. | ||
+ | < | ||
+ | > | ||
+ | >>[1, 3] | ||
+ | > | ||
+ | >>[2, 3, 4] | ||
+ | >def vowels := [" | ||
+ | >> | ||
+ | > | ||
+ | >>5 | ||
+ | > | ||
+ | >>" | ||
+ | > | ||
+ | >>" | ||
+ | > | ||
+ | >> | ||
+ | > | ||
+ | >>" | ||
+ | > | ||
+ | >> | ||
+ | </ | ||
+ | |||
+ | Tables also support some useful iterator methods as shown below. | ||
+ | |||
+ | < | ||
+ | >def sum:= 0; | ||
+ | >>0 | ||
+ | > | ||
+ | >> | ||
+ | >sum | ||
+ | >>6 | ||
+ | >def sumNnum (@args) { | ||
+ | args.inject: | ||
+ | } | ||
+ | >>< | ||
+ | >sumNnum(1,2,3) | ||
+ | >>6 | ||
+ | </ | ||
+ | |||
+ | ==== Booleans ==== | ||
+ | |||
+ | As any native type, booleans are objects so, they respond to keyword messages such as: | ||
+ | < | ||
+ | < | ||
+ | < | ||
+ | < | ||
+ | < | ||
+ | </ | ||
+ | |||
+ | '' | ||
+ | < | ||
+ | >(0 < 1).ifTrue: { 0 } | ||
+ | >>0 | ||
+ | >(3 != 5).ifTrue: { 1 } ifFalse: { 0 } | ||
+ | >>1 | ||
+ | > def [i, j] := [1,3] | ||
+ | >>[1, 3] | ||
+ | >{i < j}.whileTrue: | ||
+ | 1 | ||
+ | 2 | ||
+ | >> | ||
+ | </ | ||
+ | |||
+ | Compound boolean expressions can be created by means of a boolean' | ||
+ | |||
+ | ===== Control Flow Constructs ===== | ||
+ | |||
+ | Control flow constructs are defined in the " | ||
+ | < | ||
+ | if: booleanCondition then: consequentClosure | ||
+ | if: booleanCondition then: consequentClosure else: alternativeClosure | ||
+ | while: conditionClosure do: body | ||
+ | foreach: iteratorClosure in: table | ||
+ | do: bodyClosure if: condition | ||
+ | do: bodyClosure unless: condition | ||
+ | </ | ||
+ | |||
+ | <note warn> | ||
+ | Note that '' | ||
+ | </ | ||
+ | |||
+ | The above definitions in the lexical root of AmbientTalk are simply convenience functions for the methods defined on booleans and closures. For example, an if-statement can also be encoded as a message send, as in Smalltalk: '' | ||
+ | |||
+ | An example of usage for some of the above structures is shown below in the definition of the sort function. | ||
+ | < | ||
+ | >def sort(table, cmp := { |e1,e2| e1 < e2 }) { | ||
+ | def quickSort(table, | ||
+ | def left := low; | ||
+ | def right := high; | ||
+ | def pivot := table[(left+right) /- 2]; | ||
+ | def save := nil; | ||
+ | while: { left <= right } do: { | ||
+ | while: { cmp(table[left], | ||
+ | left := left + 1 | ||
+ | }; | ||
+ | while: { cmp(pivot, table[right]) } do: { | ||
+ | right := right - 1 | ||
+ | }; | ||
+ | if: (left <= right) then: { | ||
+ | // swap elements | ||
+ | save := table[left]; | ||
+ | table[left] := table[right]; | ||
+ | table[right] := save; | ||
+ | left := left + 1; | ||
+ | right := right - 1; | ||
+ | }; | ||
+ | }; | ||
+ | if: (low< | ||
+ | if: (high> | ||
+ | table; | ||
+ | }; | ||
+ | quickSort(table, | ||
+ | }; | ||
+ | >>< | ||
+ | > | ||
+ | >>[2, 4, 5, 6, 8, 37] | ||
</ | </ | ||
+ | AmbientTalk has no '' |
at/tutorial/basic.txt · Last modified: 2020/02/09 22:05 by elisag