A Falcon programozási nyelv

Típusok, típuskonstrukciók

Típusszerkezet

A Falcon egy gyengén típusos nyelv, azaz a változóknak nincsen típusa csak az értékeknek. Egy változó bármilyen típusú értéket tárolhat, hogy a virtuális gép hogyan értelmezi azt a változó használatától, környezetétől függ. Ennek előnye, hogy sokkal könnyebben gyorsabban lehet programozni, viszont annál nagyobb hátrány, hogy programozói hiba esetén nem fordítási, hanem futási időben jelentkezik a hiba.

Elemi típusok

  • IntegerType: Az egész számok típusa. A Falcon egész értékei 4 bytosak és előjelesek így -(2^31) ... 2^31 intervallumbeli értéket vehetnek fel, az ettől nagyobb számok már numeric-nek számítanak.
  • NumericType: Lebegőpontos számok, amik jelen esetben -(2^1023) ... 2^1023 közötti értéket jelent.
  • RangeType: Egy értékpár ami egy egész számokból álló intervallumot határoz meg. pl [1:3] az 1, 2, 3 számokat takarja. Valójában inkább egy 1 léptékű monoton sorozatról van szó. (ld. tömbök).
  • BooleanType: Logikai érték, true vagy false
  • StringType: Karakterlánc típus, tetszőleges hosszú lehet.
  • NilType: Null típus, egyetlen értéke a nil.
  • FunctionType: Függvény típus. A Falconban függvények is értékül adhatóak változónak, ezután az meghívható a változó nevével is.

    Típuskonstrukciók

    Tömbök

    A legfontosabb típuskonstrukció a tömb. A tömb elemek listája, amikre indexen keresztül hivatkozhatunk. A Falcon tömbje nem típusos, bármilyen értékeket tartalmazhat vegyesen. A Falconra jellemző, hogy mindenre van egyszerűsített és normál szintaktika, ez igaz a tömbökre is. Tömböket többféleképpen is létrehozhatunk:

    array = ["Hello", 42, 3.14, var]
    A szokásos jelölésből elhagyhatjuk a szögletes zárójeleket, ha egy sorba írjuk a tömb elemeit:
    array = "Hello", 42, 3.14, var
    Hosszú tömböknél hasznos lehet a következő rövid, de rendkívül veszélyes leírási módszer is:
    array = .["Hello" 42 3.14 var]
    Többsoros leírás esetén használni kell a zárójeleket:
    array = ["Hello", 42, 3.14, var]
    Backslash karakterrel jelezhető, hogy a következő sor logikailag ehhez a sorhoz tartozik:
    array = "Hello", \ 42, \ 3.14, \ var

    Érdekesség a tömbökkel kapcsolatban, hogy elemei egyszerűen kimásolhatóak változókba:

    array = 1, 2, 3 a, b, c = array
    Ekkor az a értéke 1, a b értéke 2 és a c értéke 3 lesz. Azonban ha kevesebb vagy több változók használunk a második értékadásban, mint ahány eleme van a tömbnek "Incompatible unpack size" hibaüzenetet kapunk.

    A tömb elemei a szokásos módon [ ] operátor segítségével írható ki. A tömböket 0-tól indexeljük:

    var = "something" array = ["Hello", 42, 3.14, var] i = 0 loop print("Element ", i, " : ", array[i]) end ++i == len(array)
    A tömb hosszát a könyvtári len függvény segítségével kérdezhetjük le. A fenti program a következő kimenetet adja:
    Hello 42 3.14 something
    A tömbök negatív számmal is indexelhetőek, ilyenkor néhány más nyelvhez hasonlóan a tömb végétől visszafelé keresi meg az adott indexet. A tömbnek hivatkozhatunk egy rész tömbjére is, ha index helyett egy intervallumot adunk meg a : segítségével (pl. 1:3, 4:, :2, -3:). Ha az intervallum első eleme nagyobb mint a második akkor nem üres tömböt kapunk hanem a nagyobb indextől a kisebbig haladva egy fordított irányú résztömböt.

    A nyelv rengeteg könyvtári függvényt biztosít a tömbök manipulálására. Az arrayBuffer egy meghatározott kapacitású tömböt hoz létre és nil értékekkel tölti fel azt. Az arrayHead, arrayTail függvények kiveszik az első vagy utolsó elemet a tömbből és visszaadják azt. Az arrayRemove ugyanezt teszi egy meghatározott indexű taggal. Az arrayDel, arrayDelAll meghatározott értékű elem első/összes előfordulását keresi meg és törli az(oka)t. Az arrayFilter az első paramétereként megadott tömb minden elemére meghívja a második paraméterként megkapott függvényt. Az arrayFind segítségével visszaadhatjuk egy tömbbeli érték indexét.

    Fontos megjegyezni, hogy a String nem tömb ebben a nyelvben (StringType nem ArrayType), ugyan az indexelés és az intervallumos indexelés ugyan úgy használható rajta mint a tömbökön, de a tömbfüggvények már nem.

    Szótárak

    A falcon másik fontos adatszerkezetei a szótárak (Dictionary). Itt nem egy láncolt adatszerkezetről van szó, hanem egy kulcs-érték leképezésről. Szótárat a következő módszerrel hozhatunk létre:

    gyümölcsleltár = ["alma"=>"egy", "körte"=>3, "barack"=nil] > gyümölcsleltár["alma"] > gyümölcsleltár["körte"] > gyümölcsleltár["barack"]
    A szótárak kulcsa és értéke tetszőleges típusú lehet akár vegyesen is. A fenti kódrészlet a következő eredményt adja:
    egy 3 nil
    A szótárak is rengeteg függvénnyel rendelkeznek, hasonlóan a tömbökhöz. A dictSet beszúr egy új kulcs érték párt. A dictKeys és dictValues kicsomagolja a kulcs illetve értékhalmazt egy tömbbe. A dictGet visszaadja a paraméterként megkapott kulcshoz tartozó értéket. A legfontosabb függvény azonban a bless, ami a szótárunkból egy prototípust/objektumot, ahol a kulcsok lesznek az objektum változói/függvényei az értékek pedig az aktuális értékeik.

    Kifejezések, operátorok

    A Falcon rengeteg operátort tartalmaz, de sajnos jelen pillanatban ezek pontos listája és precedenciája még nem dokumentált (2009.06.28)

  •