A Setl programozási nyelv

Egyszerű adattípusok és műveleteik

Egészek

Az egész típus egy előjeles egész számot tartalmazhat, hosszúsági megkötés nélkül. Persze, ha két jegyű vagy egy ezer jegyű számokat adunk össze, akkor az lényeges sebességbeli különbséget jelent.

Csak egy nulla van a SETL-ben, és a pozitív illetve a negatív nullát nem különbözteti meg.

Bináris műveletek:

+ összeadás
- kivonás
* szorzás
/ osztás, valós eredményt ad
div osztás, egész eredményt ad
mod maradékképzés
** hatványozás (ha a jobb oldali operandus negatív, vagy mindkettő 0, akkor hiba lép fel, túlcsordulás nem lehetséges)
< > <= >= összehasonlító operátorok
max min a nagyobb, illetve a kisebb operandussal tér vissza

Unáris műveletek:

+ hatástalan
- ellentettképzés
str a szám string megfelelőjét adja vissza
type visszaadja az integer stringet
abs abszolútértékképzés
char az operandusnak megfelelő kódú karaktert tartalmazó stringgel tér vissza (hiba keletkezik, ha az operandus az adott gépen használatos karakterkód-intervallumon kívül esik)
even true, ha az operandus osztható kettővel, amúgy false
float az operandus valós alakjával tér vissza (ha az átalakítás túlcsordulással jár - ami nagyon nagy egészek esetén előfordulhat -, akkor hiba keletkezik)
odd false, ha a szám osztható kettővel, amúgy true
random a nulla és az operandus közti zárt intervallum egy egész értékével tér vissza
sign signum függvény, ha az operandus negatív, a visszatérési érték -1, ha pozitív, +1, amúgy 0

a := str (2 + 3); $ a = ’5’ c := str 003.000; $ c = ’3.0’

Valós számok

A valós típus megegyezik a gép által használt valós típussal, vagyis teljesen implementációfüggő. A SETL-ben csak egy fajta ponsotsságú valós típus létezik, és a "dupla pontosságú" gépi típust fogja használni, ha a gép szómérete kicsi (például 32 bit). Csak egy nulla érték van, és annak pozitív vagy negatív voltát nem tartja számon a nyelv.

A valós típus műveleteinek végrehajtása során ha túlcsordulás keletkezik, az hibát okoz. Ettől eltekintve minden bináris művelet megegyezik az egészeknél előfordulóval (persze mod és div nincs). Új művelet az atan2, ami a két operandus hányadosának arcus tangensét számolja ki.

Új unáris műveletek:
ceil felső egész rész
floor alsó egész rész
fix az egészrészt adja vissza (levágja a törtrészt)
type visszaadja a string stringet
expr az 'e' megfelelő hatványával tér vissza
log természetes alapú logaritmust számol
random balról zárt és jobbról nyílt, a nulla és a megadott operandus által meghatározott intervallumból egy valós értékkel tér vissza
sqrt négyzetgyököt von
cos sin tan tanh koszinusz, szinusz, tangens és tangens hiperbolicus függvények (radiánban számolnak)
acos asin atan a megfelelő függvények inverzei (radiánban számolnak)

a:=ceil 3.7; $ a=4.0 a:=ceil -3.7; $ a=-3.0 a:=floor 3.7; $ a=3.0 a:=floor -3.7; $ a=-4.0 a:=fix 3.7; $ a=3.0 a:=fix -3.7; $ a=-3.0

Karakterláncok

A gépen használható karakterek tetszőleges hosszúságú sorozata. Mivel a karakterkészletre semmilyen megkötés nincs, a lexikális rendezés teljesen implementációfüggő. További probléma, ha kihasználjuk egy számítógép speciális karakterkészletét, akkor az a program esetleg nem lesz működőképes más számítógépeken, amik eltérő karakterkészletet használnak.

A karakterláncok könnyedén feldarabolhatóak. Az alábbi példa ezt szemlélteti (a string első karakterének sorszáma 1):

abc:='egy halom halmaz több halmaz halma'; $ 1234567891111111111222222222233333 $ 0123456789012345678901234 cde:=abc(5..29); $ cde='halom halmaz több halmaz' cde:=abc(5); $ ugyanaz, mint az abc(5..5), abc='h' abc(18..); $ 18. karaktertől a végéig cde:=abc(18..); $ cde='több halmaz halma'

Ezek az stringrészkijelölő kifejezések egy értékadás bal oldalán is állhatnak. Ekkor a jobb oldal hossza tetszőleges lehet:

abc:='hello'; abc(3..4):='xyz'; $ abc='hexyzo' abc(4..):='m'; $ abc='hexm'

Bináris műveletek:

+ konkatenálás
< <= > >= lexikális relációk (implementációfüggő, mert a karakterlánc elemei is azok)
in ha a bal operandus előfordul a jobb oldali operandusban, mint annak egy része, akkor true értékkel tér vissza, amúgy false-al

Unáris műveletek:

# visszaadja a string hosszát
val valóssá vagy egésszé konvertálja a stringet (ha egész kell, akkor: fix val '3.7' például célra vezet)
type visszaadja a string stringet
abs ha az operandus egy darab karaktert tartalmaz, akkor annak a kódját adja vissza, amúgy hiba lép fel
str ha az operandus az azonosítók formai szabályainak megfelel, akkor érintetlenül hagyja, amúgy minden ' jelet megkettőzve, stringként adja vissza az operandus értékét

Logikai típus

Két értéke van, a TRUE és a FALSE. Általában logikai kifejezések során van szerepe.

Unáris műveletek:

not logikai tagadás
str az operandus értéke szerint vagy #t vagy a #f stringgel tér vissza
type a boolean stringget adja vissza

Bináris műveletek:

and logikai és
impl implikáció
or logikai vagy

Nem definiált érték

Az om reprezentálja a nem definiált értéket az alábbi esetekben:

Technikai szempontból az om nem egy érték, és nincs is típusa (ha a type operátort alkalmazzuk rá, akkor az hibát okoz), azonban néha kényelmes "rtékként" tekinteni egy nem definiált értékű változó "értékére".

Néhány esetben hiba fellépte helyett om érték generálódik (például ha a / operátort stringre alkalmazzuk). Ez sokkal inkább a nyelv implementációjának a jellegzetessége, mintsem a nyelvé. A nyelv nem határozza meg, hogy ilyen esetben mi történjék.

Minden esetben hiba történik, ha az om-on valamilyen műveletet akarunk végrehajtani. Semmilyen operátor nem alkalmazható rá, kivéve az egyenlőségvizsgálatot, ha azt akarjuk eldönteni, hogy van-e valamilyen meghatározott értéke egy változónak. Az értékadás nem operátor, így lehetséges, hogy egy változó értékét kitöröljük:

a:=om; $ ekkor a értéke nem definiált lett

Atom

Az atomok speciális, egyedi értékek, amiket adatstruktúrák felépítésekor használnak.

Közös műveletek

Ebben a részben az összes elemi típusra (és a később bemutatandó összetett típusokra is) alkalmazható operátorokat gyűjtöm össze. Kivételt csak az om képez (de az om-nak nincs típusa). A műveletek ismertetésére azért van szükség, mert a nyelv részei, és nem a standard könyvtáré, mivel ilyen a setl nyelvhez nem tartozik.

Unáris műveletek:

is_atom is_boolean is_integer is_map is_real is_set is_tuple true értékkel tér vissza, ha az operandus a megfelelő típusú, egyébként false-al

Bináris műveletek:

#?# a baloldali operandussal tér vissza, ha az definiált értékű, amúgy a jobboldalival (ekkor a bal om)
= true értéket ad, ha mindkét operandusnak azonos a típusa és az értéke, vagy ha mindkettő om, amúgy false-t
/= false értéket ad, ha mindkét operandusnak azonos a típusa és az értéke, vagy ha mindkettő om, amúgy true-t