Az ELASTIC programozási nyelv

Típusok

A nyelv dinamikus típusrendszerrel rendelkezik, ami azt jelenti, hogy egy változónak nincs típusa, csak a változó értékének lehet típusa. A változók úgy viselkednek, mint az értékek (objektumok) konténerei, így egy változó tartalmazhat egy integer objektumot most, és később egy stringet, ellentétben a típusos nyelvekkel, mint a C++, Java és sok más, ahol a változó nevével deklarálunk kell a típusát is. A dinamikus típusrendszrrel rendelkező nyelvek nagy rugalmasságot adnak a programozónak ( könnyen készíthetők általános (generic) adatszerkezete, pl. listák, fák ), azon az áron, hogy elveszatjük a fordítási időben történő tapus ellenőrzés előnyeit, mivel az ellenőrzések csak futási időben lehetségesek. A változókat minden esetben deklarálni kell, a local, a static, a public, vagy a private kulcsszó segítségével. A nyelv 5 típust különböztet meg, ezek a skalár (egész, lebegőpontos, logikai, karakter, string), a tömb, az asszociatív tömb, a szimbólum, és az osztály (objektum).

Skalárok

Egy skalár típusú változónak értékül lehet adni bármilyen másik skalárt, ugyanis a skalárokat azonos belső ábrázolási formában tárolja.

Tömbök

A tömbök tetszőleges számú és tetszőleges típusú elemeket tárolhatnak, egy tömbnek eleme lehet egy másik tömb vagy akár egy hashtábla is, így bármilyen összetett adattípus könnyen megvalósítható a nyelvben. 

 
        local a = #[1,3.14,'e',"alma",#['a','b'],%["ég","kék","fű","zöld"],#szimbólum];

Egy tömb létrehozásakor a '#' jelöli a fordító számára, hogy új tömböt kell létrehozni, ennek a szimbólumnak a hatására hívódik meg a tömb konstruktora. A tömbök mindig 0-tól indexelődnek egész számokkal, de egy szintaktikai cukorka miatt a negatív számokkal való indexelés sem okoz hibát, hanem ezt a fordító úgy értelmezi mintha a tömböt hátulról kezdve, visszafelé szeretnénk indexelni, a negatív index abszolútértéke+1-el. 

 
        a[0]           //értéke 1
        a[1]           //értéke 3.14
        a[4]           //értéke az ['a','b'] tömb
        a[4][0]        //értéke 'a'
        a[5]["ég"]     //értéke "kék"
 
        a[-1]          //értéke #szimbólum
        a[-5]          //értéke 'e'

A nyelv megengedi, hogy a tömböket nem konstans kifejezéssel inicializáljuk.

Asszociatív tömbök

Az asszociatív tömbök kulcs érték párok tárolására szolgálnak. Egy hashtáblának az elemei is tetszőleges típusúak lehetnek, akár a kulcs akár az érték lehet tömb vagy másik hashtábla is. 

 
        local b = %["ég", "kék",#[1,2],"egy-kettő"];

Az asszociatív tömbök a kulcshalmazuk elemeivel indexelhetőek. Ha olyan kulccsal indexeljük, amely nem eleme a kulcshalmaznak akkor létrejön egy új hashbeli elem a megadott kulccsal és @nil értékkel. 

 
        b[#[1,2]]              //értéke "egy-kettő"
        b[3.14]=#Pi            //létrejön egy új kulcs érték pár (3.14, #Pi)

Szimbólumok

A szimbólumok, egy kicsit a C nyelv #define szimbólumaira hasonlítanak. A lefordított bytecode-ban egészekként vannak ábrázolva, így a velük végzett összehasonlító műveletek gyorsak, és a memóriafoglalásuk is kicsi. A szabványos könyvtár tartalmaz a szimbólumok kezelésére szolgáló függvényeket, többek között olyat, amely képes a string -> symbol, symbol -> string konverzióra. Ezen nyelvi elemek segítségével lehet a nyelvben megvalósítani a felsorolási típust is.

Osztályok

Lásd külön az objektum orientáltság témakörben.

Bájtkód típus

A modulokat, függvényeket, osztályokat a fordító bájtkódra fordítja, és ezeket a kódokat is eltárolhatjuk egy skalár változóban, így függvényeket, de akár csomagokat is átadhatunk egy függvénynek paraméterül egy skalár változón keresztül. Pl.: 

 
package trunky2;
import basic;
 
function trunky()
{
        local funky;                                  //skalár változó
        static v = 0;
        v = v + 1;
        funky = function() {                          //létrejön egy név nélküli függvény, és 
               basic.print( v, '\n' );                       //a függvény bájtkódja belekerül a skalár változóba
        };
        return funky;                                 //ez lehet visszatérési érték is
}
 
local func;
func = trunky();
basic.print( func, '\n' );                           //kiírhatjuk magát a bájtkódot,
func();                                              //de meg is hívhatjuk, mint függvény

Egy példa kód, ami megmutatja a típusok használatának a jellemzőit, kivéve az oszályokat:

    package tipusok;

    import basic;

    // egy változó létrehozása
    local v;

    // egy egész
    basic.print( 5, '\n' );

    // lebegő pontos
    basic.print( 12.45, '\n' );

    // egy karakter
    basic.print( 'a', '\n' );

    // logikai érték
    basic.print( @true, '\n' );

    // egy szimbólum
    basic.print( #aSymbol, '\n' );

    // egy karakterlánc
    basic.print( "Egy egyszerű karakterlánc", '\n' );

    // egy tömb
    v = #[ 1, 'a', 20.5, "ABCD" ];
    basic.print( v, '\n' );
    basic.print( v[3], '\n' );

    // egy asszociatív tömb
    v = %[ "szin", "narancs",
           "suly", 12 ];
    basic.print( v["weight"], '\n' );
    basic.print( v["color"], '\n' );

A program futásának eredménye: 

    5

    12.45

    a

    @true

    #aSymbol

    Egy egyszerű karakterlánc

    [1, 'a', 20.5, "ABCD"]

    ABCD

    12

    narancs