Moduler i Standard ML

Transkript

1 Moduler i Standard ML Hans Hüttel December 2001 I løbet af datalogikurset har vi haft glæde af en hel række forskellige standardmoduler som f.eks. Math, Int, Real og String. Disse moduler kan, har vi set, bruges i mange forskellige sammenhænge. I denne note beskriver jeg nogle grundlæggende aspekter ved modulsystemet i Standard ML hvordan man kan lave sine egne moduler fordelene ved at opbygge sit program som moduler Undervejs vil jeg benytte et lille eksempel på moduler. Noten kan ikke beskrive alle aspekter af modulsystemet i SML. Den interesserede læser kan finde en grundig beskrivelse, herunder en gennemgang af de såkaldte funktorer, i [HR99, kapitel 11]. 1 Et lille eksempel Lad os forklare hovedideerne i modulsystemerne med et lille eksempel. Vi vil lave et modul der kan udføre nogle simple operationer på (endelige) mængder og repræsentere simple konstanter. Vi antager at alle elementer i en mængde skal have samme type. 1.1 Krav til mængdemodulet Vi skal kunne udtrykke den tomme mængde og for ethvert element a skal vi kunne bygge mængden {a}. Vores mængdeoperationer skal være foreningsmængde ( ), indsættelse af et element og fjernelse af et element. Endelig skal vi kunne undersøge om a er element i mængden M, d.v.s. om a M. Det kan også være rart at kunne få en liste der angiver elementerne i en given mængde. 1

2 element : a * a list -> bool fjern : a * a list -> a list forening : a list * a list -> a list indsaet : a * a list -> a list oprems : a -> a singleton : a -> a list tom : a list Tabel 1: Interface til vores mængdemodul I en mængde forekommer ethvert element præcis een gang. Derfor kan vi udtrykke en mængde som en liste hvis elementer alle er forskellige. Den tomme mængde udtrykker vi således som den tomme liste. Mængder skal kunne have vilkårlige typer elementer. Derfor skal vi lave en parametriseret type der er polymorf, d.v.s. vi laver typeerklæringen type a mgd = a list Vi kan nu specificere det interface vi ønsker til vores mængdemodul. Funktionerne element, fjern, forening, indsaet, oprems og singleton skal være polymorfe funktioner. Konstantværdien tom skal være den tomme liste (der er en polymorf værdi). Tilsammen giver det os et interface som i Tabel 1. Nu skal vi så beskrive hvad funktionerne rent faktisk gør. Dette giver anledning til det lille SML-program i Tabel 2. Funktionerne over lister er ganske sædvanlige rekursive funktioner over lister og jeg vil derfor ikke gennemgå dem alle her. Hvis læseren har behov for at genopfriske begreberne om lister i SML henviser jeg til [HR99, kapitel 5]. Blot vil jeg nævne at definitionen af funktionen oprems specificerer typeinformationen for at sikre at SML-systemet udleder den korrekte type for denne funktion. En liste, opfattet som værende af type a mgd opremses ved simpelthen at opfatte den som værende af type a list. 1.2 Strukturer i SML Vi indfører nu det første nye begreb fra modulsystemet. Vi kan nemlig pakke erklæringerne i Tabel 2 ind i en såkaldt struktur. En struktur er indkapslet i ordene struct...end. En strukturerklæring består af det reserverede ord structure efterfulgt af navnet på strukturen, et lighedstegn og selve strukturen. Se Tabel 3. 2

3 type a mgd = a list; (* den tomme maengde *) val tom = []; (* funktion der opretter en maengde med eet givet element *) fun singleton a = [a]; fun element (x,[]) = false element (x,(y::m)) = x=y orelse element (x,m); fun indsaet (x,m) = if element (x,m) then m else (x::m); fun fjern (x,[]) = [] fjern (x,(y::m)) = if x=y then m else y::(fjern (x,m)); fun forening ([],m) = m forening ((x::m1),m2) = if element (x,m2) then forening (m1,m2) else x::(forening (m1,m2)); fun oprems m : a mgd = m : a list Tabel 2: En samling af erklæringer der modellerer mængder 3

4 structure Maengde = struct type a mgd = a list; val tom = []; fun singleton a = [a]; fun element (x,[]) = false element (x,(y::m)) = x=y orelse element (x,m); fun indsaet (x,m) = if element (x,m) then m else (x::m); fun fjern (x,[]) = [] fjern (x,(y::m)) = if x=y then m else y::(fjern (x,m)); fun forening ([],m) = m forening ((x::m1),m2) = if element (x,m2) then forening (m1,m2) else x::(forening (m1,m2)); fun oprems m = m Tabel 3: Strukturen Maengde Hvordan holder SML-systemet styr på denne erklæring? SML-systemet holder som bekendt styr på erklæringer i en omgivelse. Erklæringen i Tabel 3 binder navnet Maengde til to omgivelser, nemlig en typeomgivelse som binder typekonstruktoren mgd og en værdiomgivelse som binder alle de erklærede variabel- og funktionsnavne. Når man skal bruge variable og funktioner skal man derfor foranstille navnet på strukturen. Så vi skal f.eks. skrive - Maengde.indsaet ("hest",maengde.singleton "gris"); og får svaret val it = ["hest","gris"] : string list Hvis man bruger mange funktioner i en struktur kan man åbne strukturen så man slipper for de lange navne. Hertil bruger man funktionen open, der fortæller hvilke funktioner der findes i strukturens omgivelse. - open Maengde; > type a mgd = a list val a element = fn : a * a list -> bool val a fjern = fn : a * a list -> a list 4

5 val a forening = fn : a list * a list -> a list val a indsaet = fn : a * a list -> a list val a oprems = fn : a list -> a list val a singleton = fn : a -> a list val a tom = [] : a list Herefter kan man bruge løs af funktioner og værdier: - singleton 7; > val it = [7] : int list - forening (singleton 7,singleton 9); > val it = [7, 9] : int list 1.3 Signaturer i SML Enhver struktur i SML har en grænseflade, nemlig en fortegnelse over de typer man har defineret i strukturer og typerne af de værdier (simple værdier og funktioner) som er defineret i strukturen. Denne grænseflade kalder man en signatur En signatur er en meddelelse fra systemet Når man erklærer en struktur og præsenterer den for SML-systemet vil SMLsystemet automatisk finde strukturens signatur. For strukturen fra Tabel 3 giver SML-systemet dette svar: structure Maengde : sig type a mgd = a list val element : a * a list -> bool val fjern : a * a list -> a list val forening : a list * a list -> a list val indsaet : a * a list -> a list val oprems : a mgd -> a list val singleton : a -> a list val tom : a list end En signatur kan man således opfatte som typen af en struktur. 5

6 signature MaengdeSignatur = sig type a mgd val element : a * a mgd -> bool val fjern : a * a mgd -> a mgd val forening : a mgd * a mgd -> a mgd val indsaet : a * a mgd -> a mgd val oprems : a mgd -> a list val singleton : a -> a mgd val tom : a mgd Tabel 4: Signaturen MaengdeSignatur En signatur er også en kravspecifikation Men man kan også opfatte en signatur som en specifikation af kravene til et moduls interface og selv erklære sine signaturer. Vi kunne starte designet af vores modul med at erklære en signatur og herefter finde ud af hvordan funktionerne i signaturen rent faktisk skulle se ud. Vi kunne derfor skrive en signaturerklæring som i Tabel 4. Vi ville definere en type for mængder a mgd og bruge denne som udgangspunkt i stedet for lister. Herefter kunne vi så arbejde med at få lavet en struktur hvori vi har defineret funktionerne i signaturen MaengdeSignatur. I vores strukturerklæring skriver vi at strukturen overholdet signaturen MaengdeSignatur. Dette har vi gjort i Tabel 5. 2 Strukturer skal matche deres signaturer I det følgende vil vi antage at vi selv erklærer vores signaturer. Når man som i Tabel 4 har erklæret en struktur Str som man påstår overholder en bestemt signatur Sig vil SML-systemet tjekke om dette faktisk er tilfældet. 2.1 Regler for match Hvornår matcher en struktur Str en signatur Sig? I Str skal der være erklæret i hvert fald de typer og værdier (herunder funktioner) som Sig foreskriver. 6

7 structure Maengde : MaengdeSignatur = struct type a mgd = a list; val tom = []; fun singleton a = [a]; fun element (x,[]) = false element (x,(y::m)) = x=y orelse element (x,m); fun indsaet (x,m) = if element (x,m) then m else (x::m); fun fjern (x,[]) = [] fjern (x,(y::m)) = if x=y then m else y::(fjern (x,m)); fun forening ([],m) = m forening ((x::m1),m2) = if element (x,m2) then forening (m1,m2) else x::(forening (m1,m2)); fun oprems m : a mgd = m : a list Tabel 5: En erklæring af Maengde hvor vi kræver at Maengde skal matche signaturen MaengdeSignatur Typerne af de værdier i Str som kræves af Sig skal stemme overens med de tilsvarende typer beskrevet i Sig Strukturen Maengde i Tabel 5 matcher signaturen MaengdeSignatur; hvis a mgd forstås som a list vil alle værdier få den korrekte type og der er de værdier som signaturen foreskriver. I Tabel 6 ser vi strukturen AltMaengde, et eksempel på en noget anderledes struktur der også matcher signaturen MaengdeSignatur. Forskellen er at vi i strukturen AltMaengde repræsenterer mængder ikke som lister, men som elementer af en nyerklæret datatype. Se [HR99, kapitel 7 og 8] for at blive mindet om datatype-erklæringer. Til gengæld kan vi se at strukturen TristMaengde i Tabel 7 ikke kan matche signaturen MaengdeSignatur. Dels mangler funktionerne forening og oprems helt, dels har værdien tom typen int list hvor signaturen foreskriver den polymorfe type a list. 2.2 Værdier i en struktur ud over signaturens er lokale! Vi har lige set at en struktur Str matcher en signatur Sig hvis der i Str findes mindst de værdier som Sig foreskriver og disse har de typer som Sig kræver. 7

8 structure AltMaengde : MaengdeSignatur= struct datatype a mgd = Tom Tilfoej of a* a mgd val tom = Tom; fun singleton a = Tilfoej (a,tom) fun element (x,tom) = false element (x,tilfoej(y,m)) = x=y orelse element (x,m); fun indsaet (x,m) = if element (x,m) then m else Tilfoej(x,m); fun fjern (x,tom) = Tom fjern (x,tilfoej(y,m)) = if x=y then m else Tilfoej(y,(fjern (x,m))); fun forening (Tom,m) = m forening (Tilfoej(x,m1),m2) = if element (x,m2) then forening (m1,m2) else Tilfoej(x,(forening (m1,m2))); fun oprems Tom = [] oprems (Tilfoej(x,m)) = x::(oprems m) Tabel 6: En anden struktur som også matcher signaturen MaengdeSignatur structure TristMaengde : MaengdeSignatur= struct type a mgd = a list; val tom = [ 42 ]; fun singleton a = [a]; fun element (x,[]) = false element (x,(y::m)) = x=y orelse element (x,m); fun indsaet (x,m) = if element (x,m) then m else (x::m); fun fjern (x,[]) = [] fjern (x,(y::m)) = if x=y then m else y::(fjern (x,m)); Tabel 7: En struktur som ikke matcher signaturen MaengdeSignatur 8

9 structure HMaengde : MaengdeSignatur= struct type a mgd = a list; val tom = []; fun singleton a = [a]; fun element (x,[]) = false element (x,(y::m)) = x=y orelse element (x,m); fun indsaet (x,m) = if element (x,m) then m else (x::m); fun fjern (x,[]) = [] fjern (x,(y::m)) = if x=y then m else y::(fjern (x,m)); fun forening ([],m) = m forening ((x::m1),m2) = if element (x,m2) then forening (m1,m2) else x::(forening (m1,m2)); fun oprems m : a mgd = m : a list; fun hest x = forening (x, ["hest"]) Tabel 8: En struktur der matcher signaturen MaengdeSignatur og har en yderligere værdi, nemlig funktionen hest Men dette indebærer at der i Str kan findes yderligere værdier. Tabel 8 giver et eksempel på dette. Vi erklærer en struktur HMaengde som har tilføjet en ekstra funktion hest. Hvis vi f.eks. prøver at bruge hest-funktionen til at tilføje hest til den tomme mængde får vi at vide at hest-funktionen ikke er bundet: - HMaengde.hest HMaengde.tom;! Toplevel input:! HMaengde.hest HMaengde.tom;! ^^^^^^^^^^^^^! Unbound value component: HMaengde.hest Så hvis man erklærer værdier i en struktur ud over de værdier som signaturen angiver, vil disse værdier være lokale. Dette kan man udnytte hvis man har brug for at erklære hjælpefunktioner i sin struktur. Fordi disse hjælpefunktioner er lokale, er de skjult for uvedkommende. 9

10 2.3 Transparent og opak matching I de eksempler vi netop har set, er al information i signaturen tilgængelig for brugeren af moduler. Dette kalder man transparent matching man kan se ind i modulet. Men det kan give problemer med hensyn til typeinformation. Her er et eksempel på problemet med transparent matching. I strukturen Maengde repræsenterer vi mængder som lister uden gentagelse af elementer. Men der er ikke noget der forhindrer os i at bruge funktionerne fra strukturen på andre slags lister, og så får vi naturligvis resultater der er noget vås: - Maengde.fjern(1,[1,1,2,3]); > val it = [1, 2, 3] : int list Ovenstående fejl kan naturligvis undgås ved lidt omtanke. Men hvis vi anvendte fjern-funktionen f.eks. på en meget lang liste kan vi risikere at vi begår og overser en fejl. Derfor giver SML mulighed for at man kan skjule typeinformation. Herefter kan man kun bruge funktionerne i strukturen på elementer som bliver bygget af funktioner i strukturen. Man skjuler typeinformation ved at bruge opak 1 matching af signaturer. I Tabel 9 ser vi hvordan vi på denne måde kan erklære Maengde så typeinformationen om a mgd ikke længere er synlig. Vi skal faktisk blot skrive :> i strukturens hoved i stedet for :. Nu vil funktionsanvendelsen fra før give en typefejl, fordi typen a mgd ikke længere kan ses bare at være en liste. - Maengde.fjern(1,[1,1,2,3]);! Toplevel input:! Maengde.fjern(1,[1,1,2,3]);! ^^^^^^^^! Type clash: expression of type! a list! cannot have type! int mgd Når vi anvender funktioner korrekt får vi svar som nedenstående: - Maengde.singleton "hest"; > val it = <mgd> : string mgd Hvordan kan man nu se hvilke elementer der er i en mængde? Det kan vi med funktionen oprems: 1 opak [o pa k] (fr. opaque, lat. opacus skyggefuld, mørk) uigennemsigtig 10

11 structure Maengde : > MaengdeSignatur= struct type a mgd = a list; val tom = []; fun singleton a = [a]; fun element (x,[]) = false element (x,(y::m)) = x=y orelse element (x,m); fun indsaet (x,m) = if element (x,m) then m else (x::m); fun fjern (x,[]) = [] fjern (x,(y::m)) = if x=y then m else y::(fjern (x,m)); fun forening ([],m) = m forening ((x::m1),m2) = if element (x,m2) then forening (m1,m2) else x::(forening (m1,m2)); fun oprems m : a mgd = m : a list Tabel 9: Erklæringen af en struktur der matcher signaturen MaengdeSignatur med opak matching eneste forskel er :> - val mgd1 = Maengde.singleton "hest"; > val mgd1 = <mgd> : string mgd - val mgd2 = Maengde.singleton "ko"; > val mgd2 = <mgd> : string mgd - val mgd3= Maengde.forening(mgd1,mgd2); > val mgd3 = <mgd> : string mgd - Maengde.oprems mgd3; > val it = ["hest", "ko"] : string list En yderligere fordel ved at skjule typedetaljer på denne måde er at vi kan lave detaljerne i et modul om uden at brugerne af modulet får brug får at vide det. Hvis vi f.eks. beslutter os til at lave modulet Maengde om så det anvender datatype-ideen fra AltMaengde ovenfor kan vi blive ved med at bruge det nye modul på præcis samme måde som det gamle. Både Maengde og AltMaengde matcher jo MaengdeSignatur så funktionerne vi har til rådighed hedder samme i begge tilfælde, og der er i begge filfælde en type som hedder a mgd hvis udseende vi ikke kender. 11

12 3 Hvorfor er det en god ide at opbygge sit program af moduler? Det er ofte en god idé at opbygge sit program som en samling moduler. Alle moderne programmeringssprog understøtter denne ide. Objektorienterede programmeringssprog som Java og C++ benytter en lidt anden struktureringsidé end ML men den grundlæggende filosofi er beslægtet: Et program kan struktureres som en samling af moduler der hver især tilbyder en række værdier og operationer. Programmet benytter de forskellige modulers operationer (og modulerne kan naturligvis kalde hinanden.) Genbrug og deling af gode ideer Hvis man ofte bruger de samme beslægtede funktioner kan man samle dem i et modul som man oversætter een gang for alle med mosmlc. Man kan desuden vælge at gøre sine biblioteker offentligt tilgængelige på Internet. MLs biblioteker er opstået på denne måde. Bedre muligheder for arbejdsdeling Hvis flere mennesker går sammen om at lave et program kan man opdele programmeringsopgaven i flere mindre delopgaver. Hver delopgave går ud nu på at udarbejde et modul. Hvis man bliver enige om modulernes signaturer på forhånd behøver man kun at kende dem og hver enkelt kan herefter arbejde videre for sig. Nemmere at opdatere dele af et program Hvis man opdeler et program i moduler kan man lettere opdatere et program uden at skulle foretage gennemgribende rettelser i hele programmet. Mange store softwareproducenter udsender med mellemrum opdateringer af deres programmer. Sådanne opdateringer består typisk af nye versioner af moduler til erstatning af gamle. 4 Separat oversættelse af moduler Vi kan oversætte moduler hver for sig med mosmlc og senere indlæse modulerne med load præcis som vi ville indlæse et modul fra standardbiblioteket. Her er hvad man skal huske: En signatur kan oversættes for sig selv. En signaturfil skal have efternavnet sig (ikke sml!) og signaturen i filen skal have samme navn som filen. Signaturen Mystik skal derfor findes i signaturfilen Mystik.sig. 12

13 En struktur der matcher Sig skal hedde det samme som Sig. Hvis signaturen Mystik findes i signaturfilen Mystik.sig, skal strukturen hedde Mystik. Filen med den pågældende struktur skal også hedde det samme samme som signaturen. Så strukturfilen skal hedde Mystik.sml. Når man oversætter en signatur MinSignatur.sig får man som resultat en ny fil MinSignatur.ui hvor ui står for user interface. Denne fil beskriver signaturens krav. Når man oversætter en struktur MinStruktur.sml får man desuden en ny fil MinStruktur.uo. Hvis strukturen skal matche en signatur man allerede har oversat undersøger ML-systemet om der allerede findes en ui-fil og om denne passer med resultatet af at oversætte strukturen. Hvis man vil indlæse et modul skal de relevante ui- og uo-filer være tilgængelige fra det katalog hvor det program der bruger dem findes. På en lokal installation af Moscow ML kan man placere sine biblioteker i underkataloget lib hvor standardbibliotekerne findes. Litteratur [HR99] M. Hansen og H. Rischel. Introduction to Programming Using SML, Addison-Wesley