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/17 16:40] – tvcutsem | at:tutorial:basic [2007/04/17 17:23] – tvcutsem | ||
---|---|---|---|
Line 10: | Line 10: | ||
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 any value. | 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 any value. | ||
- | In the examples we use the interactive AmbientTalk shell (iat) where the input and output prompt are represented by > and <code>>></ | + | In the examples we use the interactive AmbientTalk shell (iat) where the input and output prompt are represented by > and %%>>%% respectively. |
< | < | ||
Line 19: | Line 19: | ||
</ | </ | ||
- | Variable definitions can include an initialization expression that immediately initializes the variable. Variable assignment is performed by means of the well-known | + | Variable definitions can include an initialization expression that immediately initializes the variable. Variable assignment is performed by means of the well-known |
< | < | ||
Line 35: | Line 35: | ||
< | < | ||
- | When using the '': | + | 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 52: | Line 53: | ||
</ | </ | ||
- | 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 |
< | < | ||
>def vowels := [" | >def vowels := [" | ||
Line 62: | Line 63: | ||
</ | </ | ||
- | As shown in the definition of the varible //vowels//, evaluating a series of comma-separated data types between square brackets (aka a tabulation) results | + | As shown in the definition of the variable '' |
< | < | ||
Line 71: | Line 72: | ||
==== Table Splicing ==== | ==== Table Splicing ==== | ||
- | AmbientTalk provides the operator @ to splice tables into surrounding table expressions. | + | AmbientTalk provides the // |
< | < | ||
> | > | ||
Line 79: | Line 80: | ||
</ | </ | ||
- | The splicing operator can be also used for matching | + | 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] | >def [first, @rest] := [1,2,3,4] | ||
Line 89: | Line 90: | ||
===== 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 100: | Line 101: | ||
>>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 123: | Line 137: | ||
>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 132: | Line 146: | ||
</ | </ | ||
- | This example also illustrates how a function can be made private by means of lexical | + | This example also illustrates how a function can be made "private" |
+ | |||
==== Variable-Length Argument Functions ==== | ==== Variable-Length Argument Functions ==== | ||
- | You can create functions that take an arbitrary number of arguments by means of the splicing operator | + | 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 162: | Line 178: | ||
In that case, the //sum// function still accepts an arbitrary number of arguments as long as two arguments are supplied. //a// and //b// are considered as mandatory arguments of the argument list. | In that case, the //sum// function still accepts an arbitrary number of arguments as long as two arguments are supplied. //a// and //b// are considered as mandatory arguments of the argument list. | ||
- | A function can also declare optional arguments as shown below. Optional arguments can be omitted in a function call. Internally, the default | + | 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 |
< | < | ||
>def incr( number, step := 1){ number + step} | >def incr( number, step := 1){ number + step} | ||
Line 171: | Line 187: | ||
>>6 | >>6 | ||
</ | </ | ||
+ | |||
+ | As is customary in languages with the above parameter passing semantics, AmbientTalk requires mandatory parameters to be defined //before// optional parameters, which should in turn be defined //before// a variable-argument parameter, if any. | ||
===== Closures ===== | ===== Closures ===== | ||
Line 188: | Line 206: | ||
</ | </ | ||
- | 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 get and set could be then passed | + | 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 212: | Line 231: | ||
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 i := 0; |
- | > | + | def mapped[tbl.length] |
- | >>9 | + | clo(tbl[i: |
+ | }; | ||
+ | } | ||
+ | >> < | ||
</ | </ | ||
- | ===== Keywords ===== | + | It can be invoked as follows: |
+ | < | ||
+ | >map: square onto: [1,2,3] | ||
+ | >> | ||
+ | </ | ||
- | AmbientTalk supports keyword messages. We have already seen some examples of keyword messages in the previous sections such as the foreach structure. | + | In AmbientTalk |
< | < | ||
def foo: arg1 bar: arg2 {...} | def foo: arg1 bar: arg2 {...} | ||
- | def foo: | + | </ |
+ | is transformed into: | ||
+ | < | ||
+ | def foo: | ||
</ | </ | ||
- | ===== Native Data Types ===== | + | However, it is impossible to directly call or define a keyworded function in a canonical style. |
+ | ===== Native Data Types ===== | ||
- | The basic types in AmbientTalk are numbers, fractions, text, tables and booleans. In fact, 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. | + | The basic data types in AmbientTalk are numbers |
==== Numerical data types ==== | ==== Numerical data types ==== |
at/tutorial/basic.txt · Last modified: 2020/02/09 22:05 by elisag