Paraméterátadó-morfizmus diagramja:

1. Paraméterátadó-morfizmus diagramja: p: tartalmazás SPEC SPEC1 h : SPEC  SPEC' h1: SPEC1SPEC1' SPEC'SPEC1' p': tartalmazás SPEC: paraméter specifikáció. SPEC1= SPEC + (S1,OP1,E1) : típus spec. formális paraméterekkel. SPEC': aktuális paraméter specifikáció. h : SPEC  SPEC': specifikáció morfizmus. h1: (sSS1)(op:s1,...,sn sOPOP1)(h1(op:s1,...,sn s) = if op:s1,...,snsOP1then op:h1(s1),...,h1(sn)h1(s) else h(op):h(s1),...,h(sn)h(s) fi;

2. Példa: p data string(data) h h1 nat string(nat) p' Paraméter : data : (data, :  data); string(data): ( {string, data}, {empty:  string, make: data  string concat: string string  string,...} Aktuális paraméter: nat; h: data  nat; Eredmény: string(nat): ( {string, nat}, {empty:  string, make: nat  string })

3. Adva h1 : SPECA SPECB, h2 : SPECA  SPECC, h3 : SPECB  SPECD; és h4 : SPECC  SPECD morfizmusok. Ha h3  h1 = h4  h2; akkor a morfizmus diagrammot kommutatívnak nevezzük. h1 SPECA SPECB h2 = h3 SPECC SPECD h4 = jelentése: h3 h1 = h2  h4;

4. Példa: p data string(data) h = h1 nat string(nat) k1 p' = = k k' spec h1 p = p'  h ; k'(nat) = k(nat); k(string) = k1(string); k' = k  p' ; k1 = k  h1;

5. Adattípus osztály specifikációja: e PAR EXP i = eb IMP BOD ib PAR : formális paraméterek specifikációja; EXP = PAR+(S1,OP1, E1) : export felület specifikációja; IMP = PAR' + (S2, OP2, E2) : import felület specifikációja; BOD = IMP + eb(EXP) : megvalósítás specifikációja; Specifikáció: PAR, IMP; Kitüntetett sortú specifikáció: EXP = ( SEXP,OPEXP,EEXP); BOD = (SBOD, OPBOD, EBOD); Tartalmazás: e, ib; Tartalmazás, vagy tartalmazás és átnevezés i; eb: EXP  BOD; kitüntetett sortú morfizmus, reprezentáció;

6. Interfész (kívülről látható rész): osztálynév(paraméterek,korlátozás) is a class specification = parameters = sorts: oprs : eqns: exports = classsort: oprs : eqns: imports = sorts: oprs : eqns: body = oprs : rep: pt(bod)  pt(exp); eqns :

7. Konstrukciós (construction) rész : osztálynév(paraméterek,korlátozás) is a class specification = parameters = sorts: oprs : eqns: exports = classsort: oprs : eqns: imports = sorts: oprs : eqns: body = oprs : rep: pt(bod)  pt(exp); eqns :

8. (megnyilvánulási aspektus (behaviour) rész): osztálynév(paraméterek,korlátozás) is a class specification = parameters = sorts: oprs : eqns: exports = classsort: oprs : eqns: imports = sorts: oprs : eqns: body = oprs : rep: pt(bod)  pt(exp); eqns :

9. Megvalósítás (beburkolt rész). osztálynév(paraméterek,korlátozás) is a class specification = parameters = sorts: oprs : eqns: exports = classsort: oprs : eqns: imports = sorts: oprs : eqns: body = oprs : rep: pt(bod)  pt(exp); eqns :

10. osztálynév(paraméterek,korlátozás) is a class specification = parameters = sorts: oprs : eqns: exports = classsort: oprs : eqns: imports = sorts: oprs : eqns: body = oprs : rep: pt(bod)  pt(exp); eqns : Ha a body részben a reprezentációs függvény: a = (c). Ha a body részben egy axióma: fs(fc(a)) = h(a). Akkor az a body részben: fs(fc((c), )) = h((c), ).

11. Példa. Adott a zsák informális specifikációja. bempty : üres zsák előállítása; binsert( b,e ) : a b zsákban egy e elem elhelyezése, a zsákban egy elem többszörösen is előfordulhat. bdelete(b,e) : a b zsákból egy e elem kitörlése. many(b,e) : eredményül a b zsákban az e elem multiplicitását szolgáltatja. bsize : a zsákban lévő összes elem száma. Válasszunk két vektort és egy mutatót a zsák ábrázolására. Az egyik vektorban hézagmentesen egymás után elhelyezzük az elemeket A másik vektorban pedig azonos index értékek mellett az elemek multiplicitásának értékeit helyezzük el. A mutató egy nem negatív egész szám, amely azt mutatja, hogy hány különböző elem van a zsákban. Az ábrázolás : vector  vector  natbool  bag. Készítsük el a zsák típusosztály specifikációját. A zsáktípus neve legyen bag.

12. Megoldás. bag(data, n: nat ) is a class specification = parameters = nat + bool + sorts : data oprs : :  data = : data data  bool [infix] eqns: a, b, c data; a = b  b = a a = b  b = c  a = c

13. exports = class sorts : bag oprs: bempty :  bag binsert : bag data  bag bdelete : bag data  bag many : bag data  nat bsize : bag  nat eqns : b  bag; a, e data bdelete(bempty, a) = bempty many(bempty, a) = zerus bsize(bempty) = zerus bdelete(binsert(b, a), e) = if a=e then b else binsert(bdelete (b,e))fi many(binsert(b,a), e) = if a=e then succ(many(b,e)) else many(b,e) fi bsize(binsert(b, a)) = succ(bsize(b)) bsize(binsert(b, a))  n  binsert(s,a) = "undefined"

14. imports = sorts : vector oprs : nil : vector put: vector nat data  vector access: vector nat  data shiftL : vector nat  vector eqns : vvector ; i,jnat; ddata; access(nil, i) =; shiftL (nil) = nil; access(put(v,i,d),j) = if i=j then d else access(j) fi i = j  shiftL(put(v,i,d),j) = shiftL(v,j); 1 i  j  shiftL (put(v,i,d),j) = put(shiftL(v,j),i,d); i  j  shiftL (put(v,i,d),j) = put(shiftL(v,j),prec(i),d);

15. body = oprs: rep : vector vector nat  set eqns: v,u  vector, m nat, a  data; 1=succ(zerus); empty = (nil, nil, zerus) insert((v,u, m), a) = if (/, 1 /  m)(v[ / ] = a) then (v, u[ / ]: = succ(access(u,l)), m) else (v[succ(m)] := a, u[succ(m)] := 1), succ(m) fi; end set;

16. nat is a class specification = parameters = - exports = sorts: nat oprs: zerus:  nat succ: nat  nat prec: nat  nat add: nat nat  nat eqns: a,bnat; prec(zerus) = "undefined"; prec(succ(a)) = a; add(a,b) = add(b,a) add(a,zerus) = a add(a,succ(b)) = succ(add(a,b))

17. imports = sorts: nat oprs: 0 :  nat _+1: nat  nat _ -1: nat  nat + : nat nat  nat[infix] eqns: n,m  nat; 0 - 1 = "undefined" (n + 1) - 1 = n; n + m = m + n n + 0 = n

18. body = oprs : rep: int  nat eqns : iint; zerus = 0 succ(i) = i +1 end nat; (rep(i): (i)) (zerus =  (0)) (succ((i)) = (i+1)) prec((0)) = "undefined"; prec(succ((i) )) = n; add((i),(k) ) = add((k),(i)); add((i),zerus) = n; add((i),succ((k))) = succ(add((i),(k)));