Claire

Beépített adattípusok, változók

A Claire beépített adattípusai

A Claire-ben definiált skaláris adattípusok a következők: az egész szám (integer), a valós szám (float), a logikai értékek (boolean), a karakter (char), a sztring (string). Objektumoknak a konstans listája használható típusként, mint például {john, jack, mary}, vagy {1,4,9}. Mutató nincs a nyelvben.

Az összetett adattípus képzésére nagyon sok lehetőségünk van a nyelvben. Mivel a nyelv objektumorientált, így létrehozhatunk osztályokat. Intervallumokat is definiálhatunk, a következő módon: <egész szám>..<egész szám>. A különböző típusokat logikai műveletekkel is összekapcsolhatjuk, ezek szintaxisa: <típus> U <típus>, illetve <típus> ^ <típus>. Így például definiálhatjuk a következő típusokat: a számok halmaza: integer U float, 1..5 intervallum: (1..100)^(-2..5).
A megszokott tömb is használható <típus>[] alakban, de explicit is megadhatjuk a tömböt a make_array(méret, típus, kezdőérték) alakban, például a következőképpen:

let l := make_array(10,float,0.0) in l[1] := l[3] + l[4]

A Claire-ben létrehozhatunk listákat is. Ez a nyelvben rendezett listát jelent, amely egy kiterjesztett tömbnek felel meg, többféle típussal. Előfordulhat duplikáció is benne. Szintaxisa egyszerű, list(...) alakú. Például list(a,b,c,d), list(1, 2+3), list(). Ha meg akarjuk adni a típust is, akkor egy kicsit más formában kell leírni. Például: list<thing>(a,b,c,d),list<integer>(1,2+3), list<float>().
Halmazokat is definiálhatunk, amely objektumok gyűjteménye duplikáció és rendezettség nélkül. A szintaxis a listához hasonló, set(...) alakú. Például: set(a,b,c), set(1,2+3). Vagy a típus megadásával: set<thing>(a,b,c), set<integer>(1,2+3).
A Claire-ben megtalálható a tuple adattípus is, amellyel rendezett n-est lehet leírni, például tuple(integer,char), amely egy rendezett páros, első eleme egész szám, második eleme pedig karakter.
A Claire-ben definiálhatunk táblákat is, a következő szintaxissal:

<name>[var:(<integer> .. <integer>)]:<típus> := <expression(var)>.

Például:

square[x:(0 .. 20)] : integer := (x*x).

Később kiterjesztették az intervallum típusát, hogy ne csak egész számintervallumot lehessen használni. Ennek szintaxisa:

<name>[var:<típus>] : <típus> := <expression(var)>.

Definiálhatunk szabályokat (rules) is a nyelvben. A szabály egy objektum, amely összeköt egy feltételt egy eseménnyel, akcióval. Minden alkalommal, amikor a feltétel igazzá válik egy új esemény hatására, az akció végrehajtódik. A feltétel logikai formula egy vagy több szabad változóval változóval. Az akció egy Claire kifejezés, amely ugyanazokat a szabad változókat használja. A feltétel akkor és csak akkor van ellenőrizve, ha egy esemény történt. Szintaxis:

név() :: rule( feltétel => kifejezés)

Például:

r1() :: rule( x.friends :add y => for z in y.friend x.friends :add z )

Lehetőség van altípus képzésére is, a subtype segítségével. Szintaxisa subtype[típus] alakú. Az így létrejött altípusnak vehetjük a metszetét bármilyen más típussal. A Claire is használja, a list és a set esetében, a list[t] egy mutató a list ^ subtype[t]-re, a set[t] pedig a set ^ subtype[t]-re.

A Claire-t nem nevezhetjük szigorúan típusosnak. A változók létrehozásánál nem kell megadni a változó típusát, viszont kötelező kezdőértéket adni neki.

A típusok a szokásos műveletekkel rendelkeznek.

A rendezett típusok kezdőértéke 1.

x ^ y az x-nek y-ra emelt hatványa, ha x és y számok. Ha x egész, akkor y-nak pozitív egésznek kell lennie. ^2(x : integer) -> integer a 2 az x-ediken függvény.
x / y az osztás, de ha x egész, akkor y-nak is egésznek kell lennie, s az eredmény is egész lesz.

Változók

A Claire-ben a változókat a let kulcsszó után írhatjuk. Fontos, hogy minden esetben meg kell adni a kezdőértéket, ami lehet unknown is. Mint fentebb már írtuk, a változóknak megadhatunk névteret és státuszt. A változók abban a modulban lesznek láthatóak, amelyben definiáltuk őket, illetve a leszármazottaikban, plusz azokban a modulokban, ahol ezt beállítottuk. Lehetőség van globális változó létrehozására. A

global_variable <: thing(range:type, value:any)

általános osztályból tudunk létrehozni globális változót, a következőképpen:

tata :: global_variable(range = integer, value = 12)

Rövidebb jelöléssel:

tata:integer :: 12

Fontos, hogy más nyelvekkel, mint például a C++ ellentétben, mindig kell kezdőértéket adnunk a globális változónak (persze ez lehet az unknown is).

Ha a változó értékét nem változtathatjuk meg, azaz konstans adatokat akarunk létrehozni, azt a globális változónak a következő alakjával tehetjük meg:

toto :: 13 exp :: Logic/Algebra/exp