Abstrakta datatyper Moduler nr 12

En presentation över ämnet: "Abstrakta datatyper Moduler nr 12"— Presentationens avskrift:

1 Abstrakta datatyper Moduler nr 12
Signaturer, strukturer och funktorer

2 Abstrakta datatyper Konkreta typer används som representationer
Operationer på representationen kapslas in Operationer och datastrukturer samlas på ett ställe Underliggande representationen göms Endast viktiga operationer och egenskaper visas utåt Fördelar: Program som använder datatypen blir oberoende av en specifik representation av datatypen. Det blir lättare att effektivisera och förändra ett dataobjekt internt.

3 Syntax: abstype typename = constructor [of type ] | constructor [of type ] ..… with declarations (val, fun, datatype,......) end De funktioner som definieras kallas ofta primitiva funktioner för datatypen. Endast de deklarerade funktionerna och värdena är tillsammans med typen synliga utåt. Konstruerarna är endast lokala.

4 Exempel naturliga tal abstype nat = Nat of int with exception MakeNat
fun makeNat n = if n < 0 then raise MakeNat else Nat n fun showNat (Nat n) = n local type relop = int * int -> bool type intop = int * int -> int fun relOp (ff: relop) (Nat x) (Nat y) = ff (x,y) fun intOp (ff: intop) (Nat x) (Nat y) = makeNat (ff (x,y)) in val natEqual = relOp (op=) val natPlus = intOp (op+) val natMinus = intOp (op-) end

5 Resultat type nat exception MakeNat val makeNat = fn : int -> nat
val showNat = fn : nat -> int val natEqual = fn : nat -> nat -> bool val natPlus = fn : nat -> nat -> nat val natMinus = fn : nat -> nat -> nat

6 Test Måste ha egna funktioner för att visa objekt och för att jämföra.
val q1 = makeNat 3; > val q1 = - : nat val q2 = makeNat 23; > val q2 = - : nat natPlus q1 q2; > val it = - : nat Måste ha egna funktioner för att visa objekt och för att jämföra. showNat (natPlus q1 q2); > val it = 26 : int natEqual q1 q2; > val it = false : bool

7 Exempel Två abstype-värden kan ej jämföras
Abstype-konstruerare kan ej användas ”utanför” definitionen q1 = q2; ! Toplevel input: ! q1 = q2; ! ^^ ! Type clash: expression of type ! nat ! cannot have equality type ''a fun nateq (Nat x) (Nat y) = x=y; … ! A constructor name expected

8 Rationella tal abstype rational = rat of int * int with
val zero = rat (0,1) val one = rat (1,1) fun // (m,n) = if n > 0 then rat (m,n) else raise Error fun ++ (rat(m1,n1),rat(m2,n2)) = rat (m1*n2 + m2*n1,n1*n2) fun == (rat(m1,n1),rat(m2,n2)) = m1*n2 = m2*n1 end type rational val zero = - : rational val one = - : rational val // = fn : int * int -> rational val ++ = fn : rational * rational -> rational val == = fn : rational * rational -> bool

9 Ordnade träd som abstrakt datatyp
Genom att baka in ordningsfunktionen i (den interna) representationen, så slipper man skicka den som explicit parameter till alla trädfunktioner. Det ordnade trädet representeras som par av en ordningsfunktion och ett binärt träd. Endast vid skapandet av ett träd måste ordningsfunktionen ges.

10 Exempel abstype 'a ordtree = ord of ('a order * 'a tree)
and 'a tree = empty | node of 'a * 'a tree * 'a tree with fun make (less : 'a order) = ord (less,empty) fun add v (ord (less,t)) = let fun insert empty = node (v,empty,empty) | insert (node(nv,l,r)) = if less v nv then node (nv, insert l,r) else node (nv,l, insert r) in ord (less,insert t) end end; > type 'a ordtree > type 'a tree > val make = fn : 'a order -> 'a ordtree > val add = fn : 'a -> 'a ordtree -> 'a ordtree

11 Moduler i ML Structure paket med deklarationer
Signature paket med typning av deklarationer Functor parametriserad struktur

12 Structure En structure är en samling deklarationer
Funktionsbibliotek Mönster för en structure structure struct_name = struct any legal definition or other structure end

13 Paket med listfunktioner
structure List_struct = struct exception Drop and Take fun take n alist = fun drop n alist = fun dropwhile pred alist =..... fun takewhile pred alist = fun filter pred alist =..... end

14 Åtkomst av objekt i en struktur:
Punktnotation structname.defname List_struct.take 3 [9,2,4,7,1]; val it = [9,2,4] : int list Explicit öppning open List_struct val first3 = take 3 Risk för namnkonflikter om flera strukturer öppnas. Kan ej stängas explicit.

15 Egenskaper Strukturer kan nästas En struktur kan öppnas inuti en annan
Namn: List_struct.substruct.id En struktur kan öppnas inuti en annan En strukturdef. kan bindas till en annan struktur; structure L2_struct = List_struct Strukturer kan ej jämföras

16 - open List; > type 'a list = 'a General.list val foldr = fn : ('a * 'b -> 'b) -> 'b -> 'a General.list -> 'b = fn : 'a General.list * 'a General.list -> 'a General.list val foldl = fn : ('a * 'b -> 'b) -> 'b -> 'a General.list -> 'b val find = fn : ('a -> bool) -> 'a General.list -> 'a option val concat = fn : 'a General.list General.list -> 'a General.list val nth = fn : 'a General.list * int -> 'a val drop = fn : 'a General.list * int -> 'a General.list val filter = fn : ('a -> bool) -> 'a General.list -> 'a General.list val length = fn : 'a General.list -> int val null = fn : 'a General.list -> bool val hd = fn : 'a General.list -> 'a val revAppend = fn : 'a General.list * 'a General.list -> 'a General.list val all = fn : ('a -> bool) -> 'a General.list -> bool val last = fn : 'a General.list -> 'a val take = fn : 'a General.list * int -> 'a General.list val map = fn : ('a -> 'b) -> 'a General.list -> 'b General.list

17 Signaturer En samling typning av deklarationer
Ger typerna hos deklarationerna i en struktur. Skiljer på specifikation och implementation signature sig_name = sig exception E type T eqtype T datatype T val I : T structure S : Sig end

18 Exempel signature OBJ_sig = sig type OBJECT
val grow : OBJECT -> OBJECT val shrink : OBJECT -> OBJECT end

19 Att notera type OBJ val namn : typ
kan deklareras i en struktur antingen som en type eller en datatype val namn : typ används oavsett om typ är en funktionstyp En struktur kan associeras med en signatur. (En delmängd av) strukturens objekt måste matcha signaturens typ(er).

20 Exempel MLs svar: structure INT_struct : OBJ_sig = struct
type OBJECT = int fun grow n = n+1 fun shrink n = n-1 end; MLs svar: structure INT_struct : OBJ_sig

21 Matchning struktur Û signatur
1) Varje deklaration i signaturen måste ha en motsvarande deklaration i strukturen. 2) Varje deklaration i strukturen som har en motsvarande typdeklaration i signaturen måste matcha denna typ. 3) Om en eqtype deklareras i signaturen måste motsvarande typ i strukturen ha likhet definierad. 4) En definition i en struktur som inte matchas av en deklaration i signaturen är inte åtkomlig utifrån.

22 shrink saknas structure Bad_struct1 : OBJ_sig = struct
type OBJECT = string fun grow c = if (c>="a") … end Error: unmatched val spec: shrink

23 Felaktiga typer structure Bad_struct2 : OBJ_sig = struct
type OBJECT = real fun grow n = floor (n+1.0) fun shrink n = floor (n-1.0) end; Error: value type in structure doesn't match signature spec name: grow spec: OBJECT -> OBJECT actual: real -> int

24 Dold deklaration structure CHAR2_struct : OBJ_sig = struct
type OBJECT = string fun last l = l fun grow c = c fun shrink c = c end; > structure CHAR2_struct : OBJ_sig CHAR2_struct.last; > Error: unbound variable or constructor: last in path CHAR2_struct.last

25 signature NUM_sig = sig type object val Int2OBJ : int -> object val Real2OBJ : real -> object … end structure NUM_struct = struct datatype object = Int of int | Real of real val Int2OBJ = Int val Real2OBJ = Real structure USEFUL_struct:NUM_sig = NUM_struct structure USELESS_struct:OBJ_sig = NUM_struct val newOBJ = USELESS_struct.Int2OBJ 3; > Error: Unbound name.... val newOBJ = USEFUL_struct.Int2OBJ 3; > val newOBJ = Int 3: NUM_struct.object

26 Signaturer... Med hjälp av olika signaturer kan man få olika ”views” av samma struktur. En type i en signatur kan definieras som en datatype i en matchande struktur. Datatypens konstruerare blir då ”gömda” i strukturen. För att kunna använda den måste vi definiera primitiva funktioner som skapar objekt av datatypen och tar fram dess komponenter.

27 Signaturer Kan ej jämföras (ingen likhetsop.)
Kan endast definieras på toppnivå, kan ej nästas. M.h.a nyckelordet include kan deklarationerna i en signatur inkluderas i en annan. Kan definieras samtidigt som en struktur structure S : sig end = struct end Två strukturer kan dela en typ eller understruktur

28 Funktorer En avbildning från struktur till struktur med en struktur : signatur som parameter (en parametriserad struktur). En funktor appliceras på en aktuell struktur. Mönster för en functor functor funct_name(par_struct : par_sig): funct_sig = struct any legal deklarations or other structure using names declared in par_struct end

29 Funktorer Modularisering.
Flexibilitet vad gäller vilken struktur som används i en funktor Dokumentation. Måste specificera typer Tydligt interface mellan bibliotek (param_struct) och program. Underlättar separat kodutveckling Möjliggör separatkompilering (med typkontroller)

30 Funktorer Funktorer kan ha en tom parameterlista, eller flera strukturer som parametrar Funktorer är ej funktioner (över strukturer); – kan ej skickas som parametrar – ej partiellt applicerbara