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

Példa: p data string(data) h h 1 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 })

Adva h 1 : SPEC A  SPEC B, h 2 : SPEC A  SPEC C, h 3 : SPEC B  SPEC D ; és h 4 : SPEC C  SPEC D morfizmusok. Ha h 3  h 1 = h 4  h 2 ; akkor a morfizmus diagrammot kommutatívnak nevezzük. h 1 SPEC A SPEC B h 2 = h 3 SPEC C SPEC D h 4 = jelentése: h 3  h 1 = h 2  h 4 ;

Példa: p datastring(data) h = h 1 natstring(nat) k 1 p' = = k k' spec h 1  p = p'  h ; k'(nat) = k(nat); k(string) = k 1 (string); k' = k  p' ; k 1 = k  h 1 ;

Adattípus osztály specifikációja: e PAREXP i = eb IMPBOD ib PAR : formális paraméterek specifikációja; EXP = PAR+(S 1,OP 1, E 1 ) : export felület specifikációja; IMP = PAR' + (S 2, OP 2, E 2 ) : 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 = ( S EXP,OP EXP,E EXP ); BOD = (S BOD, OP BOD, E BOD ); Tartalmazás: e, ib; Tartalmazás, vagy tartalmazás és átnevezés i; eb: EXP  BOD; kitüntetett sortú morfizmus, reprezentáció;

 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 : 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 : 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 : (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 : 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 : Ha a body részben a reprezentációs függvény: a =  (c). Ha a body részben egy axióma: f s (f c (a)) = h(a). Akkor az a body részben: f s (f c (  (c), )) = h(  (c), ).

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.

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

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"

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

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;

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))

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

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)));