A Dylan programozási nyelv

Vezérlés



Vezérlés

A Dylan nyelv a következő programvezérlési szerkezeteket kínálja: függvényhívás, operátorok és értékadás használata, feltételes futtatás (elágazás), iteráció (ciklus).

Függvényhívások

A függvényhívás általános szintaxisa: function(arg1,arg2, ..., argn)
Ahol a function bármilyen operátornév lehet, az argumentumok pedig kifejezések. A következő példában meghívjuk az average nevű függvényt: average(x, y)
A következő példákban a függvény amit meghívunk egy makró utasítás. A makrót végrehajtjuk a megadott paraméterrel, és az lesz a függvényhívás értéke. A két példa ekvivalens egymással, de a második példa olvashatóbb (a makró utasítás zárójelben van).

method(x) x+1 end (99) (method(x) x+1 end) (99)

A következő példában a függvény amit meghívunk egy másik függvényhívás eredménye. A key-test függvény a collection-t kapja argumentumként majd visszatér egy függvénnyel. Ez a függvény kapja meg argumentumként a key1 és key2 argumentumokat. A következő három kódrészletnek tehát ugyanaz a hatása:

key-test(collection)(key1, key2) (key-test(collection)) (key1, key2) begin let fun = key-test(collection); fun(key1, key2); end

A Dylan azoknak a függvényívásoknak amelyeknek egy argumentumuk van, egy alternatív szintaxist kínál. Az argument.function egyenértékű a function függvény meghívásával, az argument argumentummal. Ez a szintaxis az osztályok adattagjainak elérésére hasonlít. A következő példákban a sorpárok ugyanazt jelentik:

america.capital capital(america) window.position position(window) window.root-view.origin origin(root-view(window))

A Dylan-ban a sorozatok és a tömbök elemeinek elérésére az element illetve az aref függvények szolgálnak. Az elemek elérésére is létezik rövidebb szintaxis a szokásos formában. A következő sorpárok ugyanazt jelentik:

*all-windows*[0] element(*all-windows*, 0) *tic-tac-toe*[1,2] aref(*tic-tac-toe*, 1, 2)

Operátorok


A Dylan nyelvben számos unáris és bináris operátor áll rendelkezésünkre. Ezek közül három speciális, külön definiált szabályokkal. Az összes többi operátor valójában függvényhívások rövidítése. Az operátorokat az operandusaiktól whitespace karakterekkel, vagy zárójelekkel kell elválasztani. Az összes operátor balról jobbra értékelődik ki, kivéve az értékadó (:=) operátort, amelyik jobbról-balra.

Az operátorokhoz függvénynevek tartoznak (kivéve a három speciális operátort). Ezek a függvénynevek általában megegyeznek az operátorral, ezért ha használni akarjuk őket, akkor használnunk kell az escape szekvenciát. Pl.: ha definiálni szeretnénk egy + metódust a define method -dal akkor \x -et kell használnunk, ha pedig rendezést szeretnénk definiálni a < operátorral, akkor \< -t kell írnunk.

A három speciális operátort (&,|, :=) nem használhatjuk más célra.
A következő táblázatban megadjuk az operátorokat precedenciasorrenben. Az azonos csoportban levő operátorok egy precedenciaszinten vannak.

-
~
unáris
unáris
negáció
logikai negáció
negative
~
^ bináris hatványozás ^
*
/
bináris
bináris
szorzás
osztás
*
/
+
-
bináris
bináris
összeadás
kivonás
+
-
=
==
~=
~==
<
>
<=
>=
bináris
bináris
bináris
bináris
bináris
bináris
bináris
bináris
egyenlőség
azonosság
nem-egyenlő
nem-azonos
kisebb
nagyobb
kisebb-egyenlő
nagyobb-egyenlő
=
==
~=
~==
<
>
<=
>=
&
|
:=
bináris
bináris
bináris
logikai és
logikai vagy
értékadás
nincs
nincs
nincs

Meg kell jegyezni, hogy az := operátor valójában csak egy rövidítés a setter metódus meghívására (lásd objektum orientált programozás).

Elágazások

A Dylan nyelvben a vezérlő utasítások (elágazás ciklus) valójában makrók. Természetesen ugyanúgy használhatjuk őket mint ahogy azt más nyelvekben megszokhattuk.

Elágazások definiálására a következő makrók állnak rendelkezésre:

A Dylan nyelvben a logikai vagy operátor jele |, a logikai és jele: &.
Van egy előre definiált objektum, amely a FALSE értéket reprezentálja. A FALSE értéket a #f szimbólummal jelöljük. BÁRMELY MÁS objektum a TRUE értéknek felel meg de a könnyebb olvashatóság kedvéért használhatjuk a #t szimbólumot TRUE értékként.

Iterációk

Az elágazásokhoz hasonlóan ezek is makrók. Három fajta iteráció létezik:

A for ciklus itt tartalmazhat egy finally részt is, amely az utolsó lefutás után fog lefutni.

for (thing = first-thing then next(thing), until: done?(thing)) do-some(thing) end;

A fenti példában a thing ciklusváltozó tetszöleges objektum, amelyhez a next metódus legyártja a "következő" értéket, a done? logikai metódus pedig eldönti, hogy folytatjuk-e az iterációt.