A Stuktúra nélküli adat
A new kulcsszóval egy új, önálló értéket hozhatunk létre.
Pl:
let red = new
let blue = new
let green = new
let colour = {red,blue,green}
Adatstuktúrák
A stukturával rendelkező összetett adatokat már csak megfelelő függvényeken keresztül érhetjük el: A konstruktor-funkció a létrehozáshoz szükséges, az extraktor-funkció, hogy átadja a konstruktor alkalmazásának aktuális argumentumait. A
cetype TYPE
definiál egy [C,E] párt, ahol a C a konstruktor funkció, az E az
extraktor. A TYPE határozza meg a konstruktor funkció
argumentumait, többszörös arg.-ok direktszorzattal adhatók meg.
Pelda: A
let stack = @push | {empty_stack}
let empty_stack = new
let [push,[top,pop]] = cetype any ^ stack
egy hagyományos verem-tipust definiál a következőképpen:
- - empty_stack egy uj nev, az üres halmazt jelenti
- - stack egy uniója ('|' az unio jele) a push konstruktor minden alkalmazását tartalmazó halmaznak (@push) és az 'empty_stack' nevet tartalmazó halmaznak. (tipus-ellenőrzésnél még visszatérünk rá)
- - cetype any ^ stack megad egy [C,E] párt, ahol a push-t kapcsolja a C-hez, top-ot a "head E"-hez, pop-ot a "head(tail E)"-hez.
- - ^ direktszorzat jele
let [C1,E1]=cetype T
let [C2,E2]=cetype T
utan E2 C1 x hibás.
A rekord is így definiálható a'G'-ben:
let [person,[age,married,name]] = cetype int ^ bool ^ string
megfelel a következő rekordnak:
record person is
age : int
married : bool
name : string
értékadás
let P1 = person[6,'false',"jim"]
Ebben az esetben a person nem tipus, hanem konstruktor funkció. Mivel a tipus a 'G'-ben egy halmaz, amely a megfelelő konstruktor funkció alkalmazásainak gyüjteménye, ezért az @person jelenti a tipust.
Egyszerű tipus-ellenőrzés
A tipus-ellenőrzést a 'G' egyszerű esetben halmaz-tagság ellenőrzéssel valósítja meg.
A generic tipus
A cetype alkalmazásakor létrejövő [C,E] párból készíthető generic a kifejezés azon argumentum-tipusainak absztrakciójával, amelyeken a cetype operal. Pl. a generic verem definialható a következőképpen:
let stack =
with T:type func
@push T|{empty_stack}
end
let empty_stack = new
let [push,[top,pop]] =
with T:type func
cetype T ^ stack T
end
Ekkor egy adott U tipusra a "push U" lesz a konstruktor funkció,
"top U" es "pop U" a selektor funkciók. Vagyis a fentiek
megfelelnek a
let [push U,[top U,pop U]] = cetype U ^ stack U
definiciónak.
Generic függvenyek
Nézzük egy függvény absztrakcióját, amely T tipusú elemeket R reláció szerint növekvően rendezi:
let sort =
with [T:type,R:T ^ T->bool] func
with L:glist T func
sweep [nil,L]
let sweep =
with [N1:glist T, N2:glist T] func
if
N2 = nil then N1
else
sweep
[
insert [N1, gcar T N2]
,
gcdr T N2
]
fi
:
glist T
end
let insert =
with [M : glist T, element:T] func
if
M = nil then gcons T [element, nil]
elif
R [element, gcar T M]
then
gcons T [element, M]
else
gcons T
[
gcar T M
,
insert [gcdr T M, element]
]
fi
:
glist T
end
end
end
Megj:
gcar => head
gcons => prep
gcdr => tail
A sort[U,S] kifejezés visszaad egy függvényt, amelyben a
U tipusu elemekre végrehajtható a S relácio szerinti rendezés.
Tipus-függvények
Nagyon rugalmas es általanos tipus-rendszert szeretnénk, amely sokfajta adatra alkalmazható, ehhez szükséges az adat-definició és az adat-tipus ellenőrzés szövegben való elkülönítése.
Pl:
let checked_gcar =
with t func
gcar t: glist t -> t
end
segítségével a programban a "checked_gcar U"-t használhatjuk,
amely már tipusellenőrzést is tartalmaz.
Adattipusok - Összegzés
A 'G'-ben a tipus egyszerűen egy adat, amely a ':'-operator jobboldali operandusaként is szerepelhet. A következőzket tekintjük tipusoknak:
- halmazokat
- tipusok direktszorzatat
- hozzárendelést: type1 -> type2
- tipus-függvényeket
(i) E:S => if E in S then E fi
(ii) E:T1^...^Tn => [E!1:T1,...,E!n:Tn]
(iii) (E1:T1->T2)E2 => E1(E2:T1):T2
(iv) (E1:F)E2 => E1 E2:F E2
ahol
Ei : valamilyen adat
(ii)-ban lista
(iii)-ban E1 függvény
(iv)-ben E1 függvény
S : halmaz
F : függvény
Ti : altalanos tipus (halmazt is beleérteve)
! : lista-elem szelektor ([4,5,6]!2 jelentése 5)