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 17:04] – tvcutsem | at:tutorial:basic [2008/03/12 17:18] – * tvcutsem | ||
---|---|---|---|
Line 1: | Line 1: | ||
- | < | + | |
- | **This Tutorial is still under heavy construction!!** | + | |
- | </ | + | |
====== Functional and Imperative Programming ====== | ====== Functional and Imperative Programming ====== | ||
Line 34: | Line 32: | ||
</ | </ | ||
- | < | + | < |
When using the '': | When using the '': | ||
</ | </ | ||
Line 148: | Line 146: | ||
This example also illustrates how a function can be made " | This example also illustrates how a function can be made " | ||
+ | |||
==== Variable-Length Argument Functions ==== | ==== Variable-Length Argument Functions ==== | ||
Line 177: | Line 176: | ||
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 186: | Line 185: | ||
>>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 201: | Line 202: | ||
>def [get, set] := makeCell(42); | >def [get, set] := makeCell(42); | ||
>> | >> | ||
+ | >get(); | ||
+ | >>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 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 227: | Line 233: | ||
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: | ||
+ | </ | ||
+ | |||
+ | However, it is impossible to directly call or define a keyworded function in a canonical style. | ||
===== Native Data Types ===== | ===== Native Data Types ===== | ||
- | + | The basic data types in AmbientTalk are numbers | |
- | 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. | + | |
==== Numerical data types ==== | ==== Numerical data types ==== | ||
- | AmbientTalk supports numbers and fractions which represent what other languages call integers and floating point numbers, respectively. | + | AmbientTalk supports numbers and fractions which represent what other languages call integers and double precision |
- | Note that since numerical types are objects in AmbientTalk, | + | Note that since numerical types are objects in AmbientTalk, |
< | < | ||
>1.inc() | >1.inc() | ||
>>2 | >>2 | ||
- | > | ||
- | >>1 | ||
>1.cos() | >1.cos() | ||
>> | >> | ||
Line 271: | Line 293: | ||
>>2 | >>2 | ||
</ | </ | ||
+ | |||
+ | Beware of the precedence rules for function application versus method invocation, which may lead to unexpected results, e.g.: | ||
+ | < | ||
+ | > | ||
+ | >>-1 | ||
+ | </ | ||
+ | This code is interpreted as '' | ||
Numbers also support some useful iterator methods such as: | Numbers also support some useful iterator methods such as: | ||
Line 312: | Line 341: | ||
>> | >> | ||
</ | </ | ||
+ | |||
==== Tables ==== | ==== Tables ==== | ||
- | We have already | + | We have already |
< | < | ||
> | > | ||
Line 357: | Line 387: | ||
==== Booleans ==== | ==== Booleans ==== | ||
- | + | As any native type, booleans are objects so, they respond to keyword messages such as: | |
- | AmbientTalk supports infix operators for booleans as &, | and !. As any native type, booleans are objects so, they respond to keyword messages such as: | + | |
< | < | ||
< | < | ||
Line 366: | Line 395: | ||
</ | </ | ||
- | **=** and **!=** are the infix operators for equality and inequality. | + | '' |
< | < | ||
>(0 < 1).ifTrue: { 0 } | >(0 < 1).ifTrue: { 0 } | ||
Line 373: | Line 402: | ||
>>1 | >>1 | ||
> def [i, j] := [1,3] | > def [i, j] := [1,3] | ||
- | >>>[1, 3] | + | >>[1, 3] |
>{i < j}.whileTrue: | >{i < j}.whileTrue: | ||
1 | 1 | ||
Line 380: | Line 409: | ||
</ | </ | ||
- | Boolean infix operators such as & and | are not shortcut. Thus, both arguments will be evaluated. For lazy evaluation, you should use the natives methods. For example, false.and: { 1/0 } will return false without executing the second argument. | + | Compound boolean expressions can be created by means of a boolean' |
- | ===== Control Flow Structures | + | ===== Control Flow Constructs |
- | Control flow structures | + | Control flow constructs |
< | < | ||
- | if: booleanCondition then: { consequent } | + | if: booleanCondition then: consequentClosure |
- | if: booleanCondition then: { consequent } else: { alternative } | + | if: booleanCondition then: consequentClosure |
- | while: | + | while: |
- | foreach: | + | foreach: |
- | do: { body } if: condition | + | do: bodyClosure |
- | do: { body } unless: condition | + | do: bodyClosure |
</ | </ | ||
- | An example of usage for some of these structures is shown below in the definition of the sort function. | + | |
+ | <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 sort(table, cmp := { |e1,e2| e1 < e2 }) { | ||
- | def quickSort(table, | + | |
- | def left := low; | + | def left := low; |
- | def right := high; | + | def right := high; |
- | def pivot := table[(left+right) /- 2]; | + | def pivot := table[(left+right) /- 2]; |
- | def save := nil; | + | def save := nil; |
- | while: { left <= right } do: { | + | while: { left <= right } do: { |
- | | + | while: { cmp(table[left], |
- | left := left + 1 | + | left := left + 1 |
- | }; | + | }; |
- | | + | while: { cmp(pivot, table[right]) } do: { |
- | right := right - 1 | + | right := right - 1 |
- | }; | + | }; |
- | | + | if: (left <= right) then: { |
- | | + | // swap elements |
- | | + | save := table[left]; |
- | table[left] := table[right]; | + | table[left] := table[right]; |
- | table[right] := save; | + | table[right] := save; |
- | left := left + 1; | + | left := left + 1; |
- | right := right - 1; | + | right := right - 1; |
- | | + | }; |
- | }; | + | }; |
- | if: (low< | + | if: (low< |
- | if: (high> | + | if: (high> |
- | | + | table; |
- | | + | }; |
- | | + | quickSort(table, |
- | }; | + | }; |
>>< | >>< | ||
> | > | ||
>>[2, 4, 5, 6, 8, 37] | >>[2, 4, 5, 6, 8, 37] | ||
</ | </ | ||
+ | |||
+ | AmbientTalk has no '' |
at/tutorial/basic.txt · Last modified: 2020/02/09 22:05 by elisag