FP-2: Supplerende noter i funktionsprogrammering - Københavns ...

FP-2: Supplerende noter i
funktionsprogrammering
Nils Andersen
juli 2005
Datalogisk Institut
Københavns Universitet
2005 ∗HCØ Tryk∗

Redaktion: c○ Nils Andersen 2005
Tryk: HCØ Tryk
Oplag: 120 eksemplarer
ISSN 0108-3708
Forord
Disse noter er skrevet med henblik p˚a den indledende programmeringsundervisning i funktionsprogrammering
p˚a Datalogisk Institut ved Københavns Universitet (DIKU).
Siden den første version fra 1996 er noterne løbende blevet omarbejdet, og ved Det
Naturvidenskabelige Fakultets overgang i efter˚aret 2004 fra semester- til kvartalsstruktur
m˚atte en del af stoffet fjernes.
Efter fremkomsten af lærebogen FP-1 [5], (Hansen og Rischel: Introduction to Programming
using SML) blev noterne omskrevet, s˚a de først og fremmest behandlede emner, der
enten kun berøres overfladisk eller helt forbig˚as i lærebogen.
Noternes første seks kapitler udgør en selvstændig fremstilling, men senest inden kapitel 7
(Tegn, tekster, udskrivning) er det nødvendigt at sætte sig ind i typen af lister [5, Chapt. 5].
Tak til kollegaer og studerende, som gennem ˚arene har bidraget med kritik og kommentarer,
og en særlig tak til Jakob Grue Simonsen for hans pertentlige gennemlæsning. Yderligere
kommentarer, forslag, oplysninger om trykfejl og lignende modtages gerne. De kan sendes
til nils@diku.dk
2

Indhold
1 Programstyret databehandling 9
1.1 Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2 Databehandling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.3 Analoge og digitale data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4 Automatisering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.4.1 Universalitet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5 Programmering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5.1 Det imperative princip . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5.2 Det applikative princip . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.5.3 Højere programmeringssprog . . . . . . . . . . . . . . . . . . . . . . . 14
1.5.4 Valg af programmeringssprog . . . . . . . . . . . . . . . . . . . . . . 15
1.6 Ind- og udlæsning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.7 Alfabeter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.7.1 ISO’s 7 bit-kode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.7.2 ISO’s 8 bit-kode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.7.3 Unicode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.8 Funktionsbegrebet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.8.1 Den matematiske opfattelse . . . . . . . . . . . . . . . . . . . . . . . 22
1.8.2 Den datalogiske opfattelse . . . . . . . . . . . . . . . . . . . . . . . . 22
1.9 Litteratur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2 Dialog med Standard ML 25
2.1 Dialogen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.1.1 Foranstillede (monadiske) operatorer . . . . . . . . . . . . . . . . . . 26
2.1.2 Sandhedsværdi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.1.3 Værdierklæring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.1.4 Afslutning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.2 Gruppering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.2.1 Associering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.2.2 Prioritet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.3 Funktioner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.3.1 Funktionserklæring . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.3.2 Funktionskald, parenteser og prioritet . . . . . . . . . . . . . . . . . . 32
2.3.3 Argumentsæt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2.4 Sprogsystemets faser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3

2.4.1 Navne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
2.5 Fem simple typer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.5.1 To typer tal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2.5.2 Sandhedsværdier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.5.3 Tegn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.5.4 Tekster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.6 Sammenfatning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2.7 Opgaver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3 Programmeringssproget Standard ML 41
3.1 Funktionsdefinition med valg mellem flere parametermønstre . . . . . . . . . 41
3.2 Evaluering af funktionskald . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.3 Virkefelt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.3.1 Redefinition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.3.2 Rekursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.4 Navnerum; biblioteksmoduler . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.5 Typen af heltal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.5.1 Heltalsdivision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
3.5.2 Euklids algoritme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.6 Standardundtagelser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.6.1 Ikke-udtømmende parametermønstre . . . . . . . . . . . . . . . . . . 49
3.6.2 Overløb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.7 Typen af sandhedsværdier . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.7.1 Striks eller efterladende strategi? . . . . . . . . . . . . . . . . . . . . 50
3.7.2 Betingelse som skildvagt . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.7.3 Konjunktion og disjunktion . . . . . . . . . . . . . . . . . . . . . . . 51
3.7.4 Koncis omgang med sandhedsværdier . . . . . . . . . . . . . . . . . . 52
3.8 De øvrige simple typer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.8.1 Typen af brudne tal . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.8.2 Typerne af tegn og tekster . . . . . . . . . . . . . . . . . . . . . . . . 53
3.9 Overlæssede symboler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.9.1 Typebegrænsning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.10 Definitionen af Standard ML . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.10.1 Skandering i grundsymboler . . . . . . . . . . . . . . . . . . . . . . . 55
3.10.2 Gruppering i syntaktiske helheder . . . . . . . . . . . . . . . . . . . . 57
3.11 Sammenfatning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.12 Opgaver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4 Produkttype. Terminering. Blokke 61
4.1 Strukturerede typer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.2 Sæt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.2.1 Enhedstypen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.3 Komponentvalg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.3.1 Projektionsfunktionerne . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.3.2 Joker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4.4 Blok . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4

4.4.1 Analytisk brug af val . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.4.2 Udtryk og erklæringer; let og local . . . . . . . . . . . . . . . . . . 67
4.5 Polymorfi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.5.1 Værdipolymorfi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.6 Kast af standardundtagelse . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.7 Robusthed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.8 Uendelig løkke . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.9 Sammenfatning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.10 Opgaver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5 Konstruktion af funktioner 75
5.1 Problemløsning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.1.1 Et eksempel: Hexadecimale tegnkoder . . . . . . . . . . . . . . . . . . 75
5.2 Rekursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.2.1 Fakultetsfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.2.2 Virkning af funktionskald . . . . . . . . . . . . . . . . . . . . . . . . 78
5.2.3 Rekursiv problemløsning . . . . . . . . . . . . . . . . . . . . . . . . . 78
5.2.4 Ræsonneren om funktionskald . . . . . . . . . . . . . . . . . . . . . . 79
5.3 Indsættelse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
5.4 Programnedskrivning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5.4.1 Navnevalg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5.4.2 Opstilling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5.4.3 Kommentarer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.4.4 Systematik . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.5 Afprøvning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.5.1 Bevis eller afprøvning? . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5.5.2 Afprøvningsdata i programteksten . . . . . . . . . . . . . . . . . . . . 82
5.5.3 Udformning af testdata . . . . . . . . . . . . . . . . . . . . . . . . . . 83
5.6 Programkonstruktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
5.6.1 Hanois t˚arn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
5.6.2 Egenskaber og definitioner . . . . . . . . . . . . . . . . . . . . . . . . 87
5.7 Kaldtræer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
5.8 Opgaver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6 Højereordensfunktioner 91
6.1 Funktion som funktionsværdi . . . . . . . . . . . . . . . . . . . . . . . . . . 91
6.1.1 Parentesregler ved funktionskald og funktionstype . . . . . . . . . . . 92
6.1.2 Sekventialisering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
6.1.3 Funktion af tupel eller sekventialiseret funktion? . . . . . . . . . . . . 93
6.1.4 Operator som funktion . . . . . . . . . . . . . . . . . . . . . . . . . . 94
6.2 Funktion som funktionsargument . . . . . . . . . . . . . . . . . . . . . . . . 94
6.3 Anonym funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
6.3.1 Funktionserklæring med val . . . . . . . . . . . . . . . . . . . . . . . 97
6.4 Sammenfatning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.5 Opgaver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
5

7 Tegn, tekster, udskrivning 99
7.1 Typen string af tekster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
7.2 Typen char af tegn . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
7.3 Typeerklæring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
7.4 Eksempler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
7.4.1 Majuskler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
7.4.2 Decimale talord . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
7.4.3 Opstilling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.5 Listefunktionalen map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
7.6 Sammenfatning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
7.7 Opgaver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
8 Naïv sortering 111
8.1 Naboombytning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
8.2 Boblesortering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8.3 Indsættelsessortering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8.4 Udtagelsessortering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8.5 Sammenfatning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
8.6 Opgaver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
9 Et større eksempel: kalender 115
9.1 Rektangulære billeder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
9.2 Opdeling af en liste i dellister . . . . . . . . . . . . . . . . . . . . . . . . . . 119
9.3 En enkelt m˚aneds billede . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
9.4 Ugedag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
9.5 M˚anedsdata . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
9.5.1 Skud˚ar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
9.5.2 De enkelte m˚aneder . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
9.5.3 Opsamling af m˚anedsdata . . . . . . . . . . . . . . . . . . . . . . . . 124
9.6 Kalenderfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
9.7 Hele programmet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
9.8 Udnyttelse af listefunktionalen map . . . . . . . . . . . . . . . . . . . . . . . 129
9.9 Hele programmet p˚a kompakt form . . . . . . . . . . . . . . . . . . . . . . . 130
9.10 Opgaver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
10 Kombinatorisk søgning 135
10.1 Det gr˚adige princip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
10.2 Alle løsninger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
10.3 Kaste og gribe undtagelser . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
10.4 Blindgydesøgning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
10.5 Otte-dronning-problemet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
10.6 Sammenfatning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
10.7 Opgaver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
6

11 Køretidseffektivitet 145
11.1 Eksempel: potensopløftning . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
11.1.1 En forbedring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
11.2 M˚aling af ressourceforbrug . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
11.3 Beregning af udførelsestid . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
11.4 Funktioners vækst . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
11.4.1 Store O-notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
11.4.2 Store Ω- og store Θ-notation . . . . . . . . . . . . . . . . . . . . . . . 150
11.5 Effektivitet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
11.6 Listespejling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
11.6.1 Analyse af listesammenstillen (operatoren @) . . . . . . . . . . . . . . 152
11.6.2 Analyse af funktionen spejl . . . . . . . . . . . . . . . . . . . . . . . 153
11.7 Programtransformation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
11.8 Sammenfatning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
11.9 Opgaver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
12 Effektiv sortering 159
12.1 Ineffektiv sortering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
12.2 En nedre grænse for sorteringstid . . . . . . . . . . . . . . . . . . . . . . . . 159
12.3 Forbedring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
12.4 Flettesortering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
12.4.1 Analyse af flettesortering . . . . . . . . . . . . . . . . . . . . . . . . . 161
12.5 Kviksortering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
12.5.1 Analyse af kviksortering . . . . . . . . . . . . . . . . . . . . . . . . . 162
12.6 Effektiv sortering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
12.7 Tilfældige tal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
12.7.1 Pseudo-tilfældige tal . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
12.8 Sammenfatning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
12.9 Opgaver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
A Styretegn 169
B Engelsk-dansk ordliste 173
B.1 Ordliste for de enkelte afsnit i lærebogen . . . . . . . . . . . . . . . . . . . . 174
B.1.1 Chapter 1: Getting started . . . . . . . . . . . . . . . . . . . . . . . . 174
B.1.2 Chapter 2: Basic values and operators . . . . . . . . . . . . . . . . . 175
B.1.3 Chapter 3: Tuples and records . . . . . . . . . . . . . . . . . . . . . . 176
B.1.4 Chapter 4: Problem solving I . . . . . . . . . . . . . . . . . . . . . . 177
B.1.5 Chapter 5: Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
B.1.6 Chapter 6: Problem solving II . . . . . . . . . . . . . . . . . . . . . . 177
B.1.7 Chapter 7: Tagged values and partial functions . . . . . . . . . . . . . 177
B.1.8 Chapter 8: Finite trees . . . . . . . . . . . . . . . . . . . . . . . . . . 178
B.2 Engelsk-dansk ordliste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
C Indeks 183
7

Kapitel 1
Programstyret databehandling
I betragtning af, at en computer tilsyneladende hverken producerer eller forarbejder eller
transporterer noget fysisk h˚andgribeligt materiale, kan man undre sig over disse apparaters
store betydning og udbredelse.
Dette kapitel indeholder nogle mere principielle overvejelser over en computers funktion.
1.1 Data
Det er centralt, at computere ikke arbejder med fænomenerne selv, men med repræsentationer
af dem eller, som man ogs˚a siger, med data. Ordbogsdefinitionen 1 af data er:
• En formaliseret repræsentation af kendsgerninger eller forestillinger p˚a en s˚adan form,
at den kan kommunikeres eller omformes ved en eller anden proces.
Bemærkning: En repræsentation kan tage sigte p˚a menneskelig tolkning (fx trykt tekst)
eller p˚a tolkning ved hjælp af apparatur (fx hulkort eller elektriske signaler).
✛ ✘
✩
✛
✩
✚
✚ ✪
✓
omverden
perception ✲
fænomen ✛
✔ forst˚aelse
✒✖✑ ✕
virkelighed
tanke
✬
bevidsthedsindhold
✫
information
✩
repræsentation✲ ✛
tolkning
✪
Figur 1.1: Forholdet imellem omverden, tanke og sprog.
sprog
symbol
Forholdet imellem omverdenen og menneskets erkendelse af den, beskaffenheden af vores
bevidsthed og tilsvarende problemer behandles og diskuteres i filosofisk og datalogisk litteratur.
Spørgsm˚alene er vanskelige, og der er ingenlunde enighed om svarene, men man kan
vælge at anskue sammenhængen p˚a følgende m˚ade (se figur 1.1): I det bombardement af
sanseindtryk og udfordringer, den omgivende virkelighed p˚atrykker os, forsøger mennesker
1 fra [1].
9
data

at orientere sig ved at danne ideer og begreber. Skal s˚adanne bevidsthedsfænomener huskes
til senere, kommunikeres til andre eller p˚a anden m˚ade behandles uden for bevidstheden, m˚a
de formes som talte eller skrevne ord eller andre symboler, der da (i henhold til ovenst˚aende
definition) fungerer som data.
Sagt p˚a en anden m˚ade er data den form, tanker og ideer fremtræder p˚a, n˚ar de befinder
sig uden for et menneskes bevidsthed, og der er en konvention for, hvorledes de skal tillægges
betydning.
Overgange mellem de tre faser finder sted i begge retninger: Ord og begreber foranlediges
som nævnt af virkelighedens ydre p˚avirkninger og dannes i en analyse, der givetvis i høj grad
er sprogligt og kulturelt betinget; man kunne sige, at ideerne udgjorde en form for model
af det studerede fænomen. Den anden vej siges vi at have forst˚aet et begreb, hvis vi er
klare over, hvilke praktiske betydninger det dækker. Begreber kan s˚a repræsenteres i form
af symboler, og omvendt kan symboler fortolkes som bestemte begreber.
1.2 Databehandling
12
31
5
indgangsdata
✲
addition
af decimale
talord
dataproces
Figur 1.2: Databehandling.
✲ 48
udgangsdata
I de mange situationer, hvor man benytter repræsentationer af ting i stedet for tingene
selv, foretager man en databehandling. I denne brede betydning er fænomenet ikke nyt:
opbevaring eller afsendelse af en lertavle med en meddelelse i kileskrift ligesom beregning p˚a
en abacus (kugleramme) var i henhold til begrebets definition databehandling. N˚ar databehandling
finder sted, foreligger der nogle indgangsdata eller inddata (eng.:input), hvoraf der
ved en dataproces dannes tilhørende udgangsdata eller uddata (eng.:output), se figur 1.2.
En del af ˚arsagen til, databehandling er s˚a nyttig, kan forklares ved at opfatte den som
simulering: Der er en proces, man gerne vil vide noget om, men af en eller anden grund
ønsker man ikke, den skal udspille sig i virkeligheden. Det kan være, den tager for lang tid
(hvordan bliver vejret i morgen?), er for dyr (opfør et nyt kraftværk!), destruktiv (hvad er
effekten af en bombesprængning?), forurenende, eller der kan være andre grunde til, at man
ikke ønsker et reelt eksperiment. Ved at simulere processen i en databehandling kan man
alligevel (i det omfang, modellen er troværdig) komme til kendskab om den. Denne opfattelse
illustreres af figur 1.3 og udgør vores bedste bud p˚a et svar p˚a det indledende spørgsm˚al om,
hvorfor computere egentlig er nyttige.
Mange EDB-anvendelser kan beskrives ud fra figur 1.3, men i en moderne hverdag tager
man ogs˚a en del hjælpemidler i brug, som kun langt ude harmonerer med opfattelsen af
databehandling som simulering: supermarkedets stregkodelæser og dankortautomat, pladsreservationssystemer
(for teatre, færge- og flyselskaber) og et elektronisk kontaktur er eksempler
p˚a databehandlingssystemer.
10

virkelighedens
plan
det bevidstheds- eller
begrebsmæssige plan
sprogets eller
kalkulens plan
✛ ✘
✩proces,
✛ der ✩ønskes
✚ studeret
✲
✚ ✪
✓
✛ ✘
✩
✛
✩
✚
indgangsfænomen✔
✚ ✪
✓
udgangsfænomen✔
✒ ✑ ✖ ✕
modellering
❄
✬
indgangsoplysninger
✫
repræsentation
❄
inddata
✩
✪
✲
dataproces
✒✖✑ ✕
✻
indsigt
✬
resultater
✫
✻ tolkning
uddata
Figur 1.3: Databehandling opfattet som simulering.
1.3 Analoge og digitale data
✩
✪
Man skelner mellem analog og digital repræsentation af information. Hvis der ved repræsentationen
benyttes en længde, vinkel, strøm, spænding eller anden kontinuert varierende fysisk
størrelse, kaldes det analoge data. I en analogregnemaskine benyttes der analoge signaler i
de centrale kredsløb; udviklingen inden for elektronik har imidlertid betydet, at man nu kan
opn˚a langt større hastighed og præcision ved at benytte digital teknik. (Det er den samme
udvikling, man i øjeblikket ser inden for telefon-, radio- og fjernsynstransmission.)
Digitale data forudsætter et vedtagent alfabet af s˚akaldte tegn (eng.:character), og i en
digital repræsentation, som ogs˚a kaldes et ord, er der til hver af en række positioner knyttet
et tegn.
Den skrivem˚ade for ikke-negative hele tal, som vi har fra araberne, er et eksempel p˚a
digital repræsentation: Tegnene er de ti decimale cifre, og positionerne betegner antallet af
enere, tiere, hundreder, osv., regnet fra højre (fordi arabisk læses fra højre mod venstre). Vi
vil skelne mellem et tal, som er det matematiske begreb, og dets repræsentation som talord.
Med et givet antal positioner udnytter det arabiske talsystem mulighederne optimalt: har
man for eksempel tre cifre til r˚adighed, kan der dannes 10·10·10 forskellige talord, som bruges
til at betegne de 1000 forskellige tal fra 0 (betegnet 000) til 999. Det underliggende princip
kaldes “radixnotation” og er ikke afhængigt af, at alfabetet netop har ti forskellige tegn:
Systemet kan bruges for et hvilket som helst alfabet, n˚ar der blot mindst er to forskellige
tegn i det. (Man kan s˚agar tillade forskellige alfabeter for hver af de forskellige positioner.)
Bruges kun de to cifre 0 og 1, f˚as det binære talsystem eller totalssystemet; et binært
ciffer kaldes ogs˚a en bit. Skrevet binært begynder talrækken 0, 1, 10, 11, 100, 101, 110, 111,
1000, 1001, . . .
I disse noter skal vi kun interessere os for digitale data.
11

1.4 Automatisering
Data skal (det ligger i selve definitionen) kunne behandles af en proces. Udførelse af de fire
elementære regningsarter p˚a decimale talord ciffer for ciffer under brug af “mente”, “l˚an”,
“den lille tabel” og s˚a videre er eksempler p˚a s˚adanne processer.
De nævnte metoder g˚ar helt slavisk frem, og i 1642 konstruerede Blaise Pascal (1623–
1662) en mekanisk regnemaskine, som kunne addere og subtrahere sekscifrede decimale talord;
moderne elektroniske lommeregnere kan behandle flere cifre og har mange flere funktioner.
Selv om en automatisk regnemaskine kan aflaste megen triviel talbehandling, skal man
dog stadig selv tage stilling til, hvilke operationer der skal udføres, og i hvilken rækkefølge
det skal ske. Det afgørende skridt fra regnemaskine til computer g˚ar ud p˚a at automatisere
hele dataprocessen og ikke blot de aritmetiske operationer. En computer indeholder
en regneenhed som en af sine dele, men er yderligere bygget ud, s˚a den kan løse en hel
beregningsopgave uden indgriben undervejs.
1.4.1 Universalitet
Rent teknisk er der ikke noget i vejen for at bygge automater, der løser specialiserede databehandlingsopgaver
(som at udstede billetter, veksle penge, styre en vaskemaskine og
lignende). Det viser sig imidlertid, at man ikke skal gøre en automats ordrerepertoire særligt
omfattende, før den bliver universel i den forstand, at den kan udføre en hvilken som helst
databehandling.
For os vil det interessante netop være universelle computere, det vil sige databehandlingsapparater
med den egenskab, at hvis man kunne specialbygge en indretning, der løste
en bestemt ønsket databehandlingsopgave, s˚a kan man ogs˚a f˚a computeren til at løse denne
opgave.
1.5 Programmering
Fysisk set ombygges computeren ikke mellem hver af de forskellige opgaver, den skal løse.
Det, der sker, er, at man udskifter dens program, det vil sige de ordrer, som styrer dens
virkem˚ade.
At programmere (eller, som man sagde før i tiden: kode) en computer g˚ar ud p˚a at
forsyne den med de ordrer, der skal til for at løse en forelagt opgave. Her st˚ar flere forskellige
principper eller beregningsmodeller til r˚adighed; vi omtaler nedenfor kort to af dem: det
imperative og det applikative princip.
1.5.1 Det imperative princip
N˚ar en beregningsopgave løses manuelt, har man ud over en regnemaskine brug for at kunne
notere mellemresultater ned, taste andre mellemresultater ind igen og eventuelt lade delresultater
styre de videre beregninger. En af de m˚ader, hvorp˚a man kan udbygge en regneenhed
til en computer, der er universel i den ovennævnte forstand, er derfor ved siden af regneenheden
at have et lager til mellemresultater.
12

Et vigtigt skridt i datamaskinernes udvikling blev taget, da Charles Babbage (1792–
1871) planlagde en mekanisk regnemaskine, som ud over datalager og regneenhed samt indog
udlæsningsenheder ogs˚a skulle have en styreenhed, hvori en sekvens af hulkort bestemte,
hvilke operationer der skulle udføres. Denne maskine kunne alts˚a programmeres: med forskellige
sekvenser af hulkort i styreenheden kunne den løse forskellige opgaver. Til assistance
ved planlægning af styringen havde han komtesse Augusta Ada Lovelace (den engelske digter
lord Byrons datter), som s˚aledes i en vis forstand blev verdens første programmør. Af
praktiske grunde forblev maskinen dog p˚a tegnebrættet — med datidens teknik var den
umulig at bygge.
Imperativ programmering, der ogs˚a kan kaldes tilstandsorienteret programmering eller
variabelbaseret programmering, g˚ar ud p˚a at supplere regnekapaciteten med et lager. Skudt
ind mellem de almindelige regneordrer (til addition, subtraktion, multiplikation og s˚a videre)
ligger der ordrer om at læse fra pladserne i lageret og at skrive til dem, s˚a lagerets indhold
hele tiden ændrer sig.
Fungerende datamaskiner har næsten alle denne opbygning, og skal man benytte s˚adan
en maskine, skal den alts˚a udføre et program, der bestemmer, hvordan lagerets indhold skal
bruges og ændres.
Efter den imperative model foreg˚ar en beregning ved, at en maskine (med sin regneenhed
og sit lager) præsenteres for to ingredienser: dels de aktuelle inddata, dels et program,
hvorefter maskinen behandler inddata i overensstemmelse med programmet og som resultat
leverer uddata:
x
inddata
p
program
1.5.2 Det applikative princip
✲
✲
datamaskine
M
(imperativ forst˚aelse)
✲ y
uddata
Almindelige regneudtryk form˚ar ikke at beskrive alle beregninger, og derfor skulle der i den
imperative model suppleres med et lager til “mellemresultater”.
En anden opfattelse g˚ar ud p˚a, at en beregning veksler mellem at inddrage forskellige
dele. Ved at identificere de forskellige dele med passende navne kan man sørge for, at de
kommer i brug til det rigtige tidspunkt. Mentalt arbejder denne model derfor med bindinger
mellem navne eller parametre og værdier. S˚a længe et b˚and best˚ar, ændres et navns værdi
ikke (i modsætning til forholdene i den imperative model, hvor en plads kunne skifte værdi).
I applikativ programmering, der ogs˚a kaldes funktionsorienteret programmering eller værdiorienteret
programmering, opn˚as universaliteten ved at udvide klassen af udtryk med nye
former og operationer, som gør det muligt at formulere en vilk˚arlig beregning som et udtryk.
Da disse nye operationer skal erstatte brugen af et eksplicit lager, er det klart, mange
af dem vil have karakter af nogle “omflytninger”, og den nødvendige udvidelse kaldes ogs˚a
“kombinatorisk logik”.
Det matematisk grundlag for det applikative synspunkt blev udviklet i 1930’erne af
Alonzo Church (1903–95) i form af den s˚akaldte lambda-kalkule, men den første, der foreslog
teorien benyttet i forbindelse med programmering, var John McCarthy, som omkring
1960 udviklede en kalkule for rekursive funktioner af symbolske udtryk og konstruerede
programmeringssproget Lisp.
13

I applikativ programmering formuleres den opgave, man vil have løst, som et generaliseret
regneudtryk, og man lader derefter det datamatiske system evaluere dette regneudtryk til
en værdi. Sagt p˚a en anden m˚ade skal inddata kapsles ind i et mere omfattende regneudtryk;
hvad der i det imperative paradigme var et program, svarer her til en kontekst: et generaliseret
udtryk med et “hul” (hvori inddata kan placeres).
f(x) ✲
inddata indkapslet i et
applikativt udtryk
datamaskine
A
(applikativ forst˚aelse)
1.5.3 Højere programmeringssprog
✲ y
uddata
Udviklingen inden for elektronik (radiorør) gjorde det muligt at bygge de første fungerende
datamaskiner i tiden omkring anden verdenskrigs slutning; disse maskiner havde dog stadig
et separat styrende program. Forud for hver ny anvendelse af maskinen skulle programmet
skiftes ud, hvilket kunne være en møjsommelig opgave. I 1940’erne fik en gruppe ingeniører,
hvis mest fremtrædende medlem var John von Neumann (1903–1957), den afgørende ide at
integrere data- og programlager, s˚aledes at de ordrer, som styrede dataprocessen, blev hentet
fra lageret, hvilket ogs˚a betød, at maskinen undervejs i en beregning kunne modificere sine
egne ordrer.
Selv om det skyldes den moderne elektronik (transistorer, integrerede kredse), at datamaskiner
er blevet hurtige og billige og dermed har f˚aet en s˚adan udbredelse, som tilfældet
er, har elektronik ikke principiel betydning i forbindelse med datateknik: man kunne ogs˚a
(og gør det i et vist omfang) bruge mekaniske, hydrauliske, pneumatiske (trykluft), magnetiske
eller optiske (lys) lagrings- og transportmedier; det afgørende er, at vi har at gøre
med en universel datamaskine, der fortolker sit program fra et lager, hvortil der
automatisk kan skrives.
Betegnelsen datamaskine eller datamat (eng.:computer) vil i det følgende blive brugt
om en s˚adan universel datamaskine med lagret program; datamatik (eng.:computer science)
drejer sig om egenskaber ved og brugen af s˚adanne maskiner.
Reglerne for, hvorledes en datamat fortolker et lagerindhold som en ordre, er bestemt
af maskinens ingeniørmæssige konstruktion og kaldes for dens maskinsprog. Da ordrer kan
behandles som data, behøver man imidlertid ikke at programmere maskinen i dette sprog:
et afviklingsprogram (der dog da selv m˚a være lagt ind i maskinsprog) kan oversætte eller
fortolke programmer udformet i et s˚akaldt højere programmeringssprog til maskinsprog,
og man siger da, at det højere programmeringssprog er implementeret p˚a den p˚agældende
datamat.
Hvis et afviklingsprogram for sproget L er lagt ind i en maskine M, ser det fuldstændig
ud, som om man havde at gøre med en L-maskine.
Fremkomsten af højere programmeringssprog har gjort det muligt at afvikle de samme
programmer p˚a meget forskellige datamater (og at afvikle programmer i mange forskellige
programmeringssprog p˚a samme datamat) — i princippet kan alle datamater det samme.
Siden implementeringen i 1958 af det første højere programmeringssprog Fortran (afledt
af “formula translator”) er der fremkommet et overordentlig stort antal af den slags
sprog. To af dem har navn efter de ovennævnte pionerer Pascal og Ada; et meget udbredt
sprog hedder C (videreudviklet til C++). Sammen med Algol, Cobol, PL/I, Basic og
14

mange andre tilhører alle de nævnte sprog klassen af imperative eller tilstandsorienterede
programmeringssprog. Fælles for disse sprog er et forholdsvis tro billede af datamatens lager
som opbygget af variable, der skifter værdi under en beregning.
I Objektorienteret programmering opfattes alle forhold og størrelse, programmet skal
arbejde med, som objekter med visse egenskaber. Objektorienterede programmeringssprog
er blandt andet Simula, Emerald, Java og C++.
Det sprog, der præsenteres i de følgende kapitler, tilhører klassen af s˚akaldte applikative,
værdiorienterede eller funktionsorienterede programmeringssprog, hvor program og inddata
bygges sammen til et udtryk, og den ønskede databehandling opfattes som evaluering af
dette udtryk til en værdi. De applikative sprog omfatter blandt andet Lisp, Scheme, ML,
Hope, Miranda og Haskell.
Logikprogrammering, g˚ar ud p˚a at beskrive de egenskaber, uddata skal have, p˚a en s˚adan
m˚ade, at denne beskrivelse kan danne grundlag for beregning; funktionsprogrammering og logikprogrammering
kan under et betegnes deklarativ programmering. Eksempler p˚a logikprogrammeringssprog
er Prolog og SQL.
Datamater med et applikativt sprog som maskinsprog har været konstrueret, men har
ikke vundet stor udbredelse. I praksis afvikles ethvert højere programmeringssprog, hvad
enten det er imperativt eller applikativt, p˚a traditionelle imperative maskinarkitekturer ved
hjælp af et passende afviklingsprogram.
1.5.4 Valg af programmeringssprog
At løse en opgave ved hjælp af en datamat betyder at realisere en bestemt dataproces K og
indebærer i praksis, at man vælger et bestemt højere programmeringssprog (imperativt eller
applikativt), som man har adgang til et afviklingsprogram for, og skriver passende kode (et
program pK eller en fK(. . .)).
Der er en tendens til, at programmører opdeler sig i “skoler”, der (undertiden nærmest
fanatisk) sværger til hver deres foretrukne programmeringssprog. Ved en mere nøgtern betragtning
m˚a det erkendes, at de forskellige sprog har hver deres styrker og svagheder.
Tilstandsorienterede sprog holder mest konkret styr p˚a, hvad der foreg˚ar i datamaten, og
giver derigennem mulighed for konstruktion af meget effektive programmer. Effektiviteten
opn˚as p˚a bekostning af, at der er flere detaljer, man selv skal tage stilling til, s˚a det bliver
mere omstændeligt at n˚a frem til en løsning og vanskeligere at overbevise sig om, at den er
korrekt.
Programmeres efter det funktionsorienterede princip, kan det være vanskeligere at gennemskue,
hvilke maskinaktiviteter der sættes i gang, og man kan uforvarende komme til at
skrive ineffektive programmer. Nyere forskning inden for omr˚adet betyder dog, at afviklingstiderne
i de senere ˚ar er reduceret betydeligt. Først og fremmest opvejes eventuelle ulemper
ved funktionsorienterede sprog af, at der er mange detaljer, man slipper for at tage stilling
til, s˚a man f˚ar langt større fleksibilitet, modularitet og udtrykskraft. Frem for et lager, hvis
indhold varierer gennem beregningsforløbet, er det mentalt set enklere at have at gøre med
bindinger mellem navne og værdier, hvor værdierne ikke ændrer sig, mens b˚andet best˚ar.
Funktionsudtryk er sædvanligvis velstrukturerede og lette at afprøve og at ræsonnere om.
Derfor er et funktionsorienteret sprog ogs˚a velegnet ved introducerende undervisning.
15

1.6 Ind- og udlæsning
Skal databehandlingsresultater forelægges mennesker, m˚a det ske ved p˚avirkning af en af
vore fem sanser — i praksis synet og/eller hørelsen. Inddata m˚a frembringes af vores bevægeapparat:
først og fremmest fingre og hænder, eventuelt tale.
De første seriefremstillede datamater var forbundet med en elektrisk skrivemaskine, s˚aledes
at inddata hentedes fra tastaturet, og uddata var maskinskrevet tekst p˚a papir.
Megen ingeniørmæssig energi og opfindsomhed er investeret i at udvikle hurtigere og
bedre m˚ader at kommunikere med maskinerne p˚a; i moderne datamater præsenteres resultater
som billeder p˚a en skærm, eventuelt i farver, og som lyd eller musik, mens inddata kan
komme fra tastaturet eller ved at der er brugt en “mus” og trykket p˚a musens knapper. Der
er ogs˚a skærme, som kan reagere, n˚ar der peges p˚a dem, og man kunne forestille sig mange
andre muligheder.
Alle signaler kan digitaliseres; bag de farvebilleder, skærmen viser, ligger en repræsentation,
som for hvert punkt p˚a skærmen angiver dets farve og lysintensitet. Psykologisk er
det naturligvis af stor betydning, om man præsenteres for et rigtigt billede eller bare for en
tabel af indgange af formen (x, y, farvekode), men det informationsteoretiske indhold er det
samme.
Programmer i et højere programmeringssprog formuleres som tekst, og i disse noter vil vi
ogs˚a g˚a ud fra, at ind- og uddata er tekster. I princippet er dette tilstrækkeligt til simulering
af enhver dataproces: Der er standard-programpakker, som kan sørge for, at brug af musen
bliver til indgangstekster a la “venstre museknap nedtrykket i skærmkoordinat (x, y)”, og
at udgangstekster med (x, y, farvekode) bliver vist som billeder p˚a skærmen.
Kernen i at lære at programmere g˚ar derfor ud p˚a at konstruere programmer med tekst
som ind- og uddata.
1.7 Alfabeter
Fejloversat fra engelsk kaldes et alfabet, som er en mængde af tegn (eng.:character set), ogs˚a
for et tegnsæt. Forskellen p˚a en mængde og et sæt er, at der ikke er nogen organisation i en
mængde, mens elementerne i et sæt er ordnet. Brugt som digitale data har tegn i et alfabet
imidlertid hver deres kode eller vægt, og betegnelsen “tegnsæt” giver da alligevel mening,
idet man kan tænke sig alfabetets tegn stillet op i rækkefølge efter vægt.
Hvordan noget skal repræsenteres, er kun i meget ringe grad naturligt og kan vælges
næsten fuldstændig frit. I begyndelsen, hvor hver computer var en autonom installation,
og hvert fabrikat derfor omtrent havde sit eget alfabet, var et stort antal alfabeter i brug.
Med udbredelsen af datakommunikation blev der behov for standardisering, og antallet af
forskellige alfabeter er efterh˚anden reduceret. I det følgende omtales de tre alfabeter, man
hyppigst støder p˚a i dag: ISOs 7 bit-kode, ISOs 8 bit-kode og “Unicode”.
1.7.1 ISO’s 7 bit-kode
Sædvanlig maskinskreven tekst er ogs˚a digital: Alfabetet best˚ar af de forskellige skrifttegn
(ogs˚a kaldet grafemer), maskinen kan frembringe, og positionerne er anslagene mod papiret.
En af mulighederne for en position er ikke at have noget grafem tilknyttet; denne mulighed
16

egnes med blandt skrifttegnene og kaldes et blanktegn. Det mest almindeligt anvendte grafiske
tegnsæt ASCII (American Standard Code for Information Interchange) har udviklet
sig fra det internationale fjernskriveralfabet og er i let modificeret form blevet anerkendt
af den internationale standardiseringsorganisation ISO som standarden ISO 646. Det har
128 forskellige tegn, som b˚ade omfatter grafiske tegn (blanktegn, cifre, bogstaver og specialtegn)
og forskellige ikke-grafiske tegn til opstilling, styring med mere, se tabel 1.1. Da man i
totalssystemet netop f˚ar 128 talord ved at bruge 7 bit, kaldes koden ogs˚a for ISOs 7 bit-kode.
kode 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
0 NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI
16 DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US
32 SP ! " £/# $/ ❡ % & ’ ( ) * + , - . /
48 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
64 @ A B C D E F G H I J K L M N O
80 P Q R S T U V W X Y Z Æ/[ Ø/\ ˚A/] ^
96 ` a b c d e f g h i j k l m n o
112 p q r s t u v w x y z æ/{ ø/| ˚a/} ¯/~ DEL
Tabel 1.1: DS/ISO 646 og DS 2089.
At alfabetet primært er konstrueret med henblik p˚a transmission, afspejler sig i det store
antal ikke-grafiske tegn; nogle af disse styrer tegnenes opstilling eller andre terminalfunktioner
og forklares i tabellen nedenfor (styretegnenes tilsigtede virkning kan ses i appendiks A).
Som man kan se, stammer mange af betegnelserne fra den gang, hvor en terminal var en
skrivemaskine med valse og slæde.
kode forkortelse navn virkning
7 BEL Bell egentlig “klokke”: f˚ar terminalen til at afgive lyd (sige
“bip”)
8 BS Backspace tilbagerykningstegn (én position mod venstre)
9 HT Horizontal tabuleringstegn: fremrykning mod højre til næste ta-
tabulation buleringsmærke
10 LF Line feed linjeskift: en linje nedad; egentlig uden ændring af
positionen i tværg˚aende retning (og skift til ny linje
styres da af to tegn, i rækkefølgen CR+LF), men hvis
udstyret tillader det, kan man vælge at lade dette
tegn (som da ogs˚a forkortes NL, New line) betyde
skift til forrest p˚a næste linje
11 VT Vertical tabulation
tabulering nedad
12 FF Form feed sideskift
13 CR Carriage
return
vognretur: tilbagerykning til linjens begyndelse
32 SP Space blanktegn
P˚a en skærm (og p˚a papir) er tegn stillet op i to dimensioner; omformningen til en endimensional
række finder sted ved, at teksten opfattes som en sekvens af vandrette linjer,
17

som opstilles efter hinanden, idet der efter hver linje indsættes et linjeskift; blanke dele
yderst til højre p˚a linjerne er uden betydning og kan udelades. Som et eksempel vil teksten
kunne sendes som sekvensen
Her er et
eksempel p˚a,
hvorledes en tekst transmitteres.
Her er et ✛eksempel ✁ p˚a, ✛hvorledes ✁ en tekst transmitteres. ✛✁
hvor blanktegn (kode 32) er vist som og ny-linje-tegn (kode 10) som ✛. ✁
Et tastatur behøver ikke at have en tast for hvert tegn, der skal kunne frembringes: flere
taster kan benyttes i kombination. Der kan være parallelle skiftenøgler, som skal holdes nede,
samtidig med at man trykker p˚a en anden tast. Princippet kendes fra den m˚ade, hvorp˚a man
p˚a en sædvanlig skrivemaskine frembringer de store bogstaver, men ud over denne nøgle,
betegnet “Shift”, kan en arbejdsplads have skiftenøgler betegnet “Option” (eller “Alt” eller
“Select”) og “Ctrl”. Det er almindeligt at lade “Ctrl” virke p˚a den m˚ade, at man f˚ar dannet
det tegn, hvis kode er 64 (eller 96) mindre end det tegn, man ellers ville f˚a (se tabel 1.1).
I mange programmeringssprog kan en beregning, der er løbet løbsk, standses ved, at man
sender ETX (kode 3); det sker s˚a ved, at “Ctrl” holdes nede, mens man taster c.
Et serielt ikke-l˚asende skiftetegn eller undvigelsestegn (eng.:escape character) ændrer det
umiddelbart efterfølgende tegns betydning; p˚a mange tastaturer fungerer accent-taster p˚a
den m˚ade: accenten placeres over det efterfølgende tegn; tasten “Esc”, der sender tegnet
ESC (kode 27), har en tilsvarende virkning. Man kan ogs˚a have l˚asende skiftetegn, hvor
et s˚akaldt skift-ud-tegn ændrer betydning for alle efterfølgende tegn, indtil der kommer et
skift-ind-tegn.
I modsætning til konstruktionen p˚a en gammeldags skrivemaskine er det p˚a en arbejdsplads
s˚adan, at den tast (mærket “Caps Lock”), der l˚aser til store bogstaver, ikke sætter
den normale skiftenøgle ud af funktion: det er nemlig kun tasterne med bogstaver p˚a, hvis
virkning ændres; for de andre taster er det stadig nødvendigt at kombinere med skiftenøglen,
hvis man vil frembringe tegnet for oven p˚a tasten.
Gruppering
Trods standardiseringsbestræbelserne er der en række forhold, man ikke har kunnet enes
om.
Linjeskift. Svarende til, at overgangen fra en linje til den næste egentlig kombinerer to
bevægelser (tilbage til venstre margin + en linje ned), skulle linjeskift oprindeligt angives
CR (kode 13) + LF (kode 10), og s˚adan er konventionen ogs˚a i operativsystemerne MS
Windows 95/98/. . .
Standarden˚abner mulighed for, at man kan nøjes med med LF (kode 10); dette alternativ
har man valgt under operativsystemet Unix.
Ogs˚a p˚a Macintosh nøjes man med ét tegn, men det er (i strid med standarden) CR
(kode 13).
18

Mellemrum. Horisontal tabulering og blanktegn (og kombinationer af dem) danner mellemrum
mellem de grafiske tegn, men der er ikke enighed om, hvorvidt blanktegnet selv skal
klassificeres som grafisk eller ej.
I programmeringssproget Standard ML har man en lang række prædikater til klassifikation
af tegn (se [5, D.3.3]), og man har valgt, at om blanktegn skal Char.isPrint (is a
printable character) være sandt, men Char.isGraph (is a graphical character) være falsk.
De danske bogstaver
Den oprindelige ide i ISO 646 var at holde syv pladser (koderne 64, 91, 92, 93, 123, 124,
125, med mulighed for udvidelse til ti pladser ved ogs˚a at inddrage kode 94, 96 og 126)
ledige til nationale udvidelser af alfabetet. Desuden kunne anførelsestegn, apostrof, komma,
pilespids-opad og overstregning i kombination med tilbagerykningstegn bruges som accenterne
henholdsvis trema (to prikker), aigu, cedille, cirkumfleks og tilde.
Dansk Standardiseringsr˚ad foreskrev derfor i DS 2089, at æ, ø, ˚a, Æ, Ø og ˚A skulle
placeres som vist i tabel 1.1.
Desværre er de tegn, som derved bliver utilgængelige — først og fremmest kantede og
krøllede parenteser — vanskelige at undvære inden for programmering, og det m˚a konstateres,
at den danske standard aldrig rigtig er sl˚aet an. Hertil kommer, at otte bit, svarende til
et repertoire p˚a 256 muligheder, er en mere naturlig enhed p˚a nutidens maskiner end syv 2 .
ISO 646-koden afløses derfor i stigende grad af mere omfattende tegnsæt.
1.7.2 ISO’s 8 bit-kode
En gruppe p˚a 8 bit, der kaldes en byte 3 og kan rumme 256 forskellige muligheder, er en naturlig
dataenhed for computere. Lagerstørrelser m˚ales som regel i byte, maskinens naturlige
repræsentationer af heltal, reelle tal og ordrer vil være et helt antal byte, og ofte er en byte
den mindste adresserbare lagerenhed.
ISO 8859 standardiserer en familie af alfabeter indeholdende lutter grafiske tegn med
koder mellem 0 og 255, s˚a de kan rummes inden for en byte. Af dem er det s˚akaldte “latinske
alfabet nummer 1” indrettet med henblik p˚a at indeholde alle de tegn, som kræves
i vesteuropæiske sprog (nærmere bestemt catalansk, dansk, engelsk, fransk, færøsk, irsk,
islandsk, italiensk, nederlandsk, norsk, portugisisk, spansk, svensk og tysk). Til gengæld er
det ikke meningen, at der skal bruges mere end én kode for noget grafisk tegn inden for
denne standard (bogstaver med accent regnes med andre ord for selvstændige tegn og m˚a
ikke dannes ved kombinationer og tilbagerykning). Som det fremg˚ar af tabel 1.2 er der ved
denne udvidelse ikke alene blevet plads til æ/Æ, ø/Ø og ˚a/˚A, men ogs˚a til svensk og tysk
ä/ Ä og ö/Ö, tysk ü/Ü og ß, islandsk og færøsk d-/D- med meget mere.
Al standardisering er et kompromis, men det er alligvel forbavsende, at fransk œ/Œ ikke
er lagt ind i steden for ÷/×. Forklaringen er, at medlemmerne af standardiseringskommissionen
har defineret Πsom ligatur (typografisk sammenskrivning) af O og E, ligesom (i
nederlandsk) ij og IJ er ligaturer, eller fi og fl er ligaturer for fi og fl.
2 selv om den ottende bit ved asynkron transmission kunne bruges som paritetskontrol.
3 De foresl˚aede fordanskninger til stavelse eller oktet er ikke sl˚aet an.
19

kode
0
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
16
0–31 ikke i tabel
32 SP ! " # $ % & ’ ( ) * + , - . /
48 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
64 @ A B C D E F G H I J K L M N O
80 P Q R S T U V W X Y Z [ \ ] ^
96 ` a b c d e f g h i j k l m n o
112 p
128
q r s t u v w x y z { | } ~
ikke i
tabel
144
127–159 ikke i tabel
160 NBSP ¡ c| £ ❡ Y= § ¨ c○ ā
>
Ë
^U
1
4
Ì
Ü
1
2
Í
´Y
3
4
^I
bp
¿
Ï
ß
224 à á ^a ~a ä ˚a æ ç è é ^e ë ì í ^ı ï
240 d- ~n ò ó ^o ~o ö ÷ ø ù ú ^u ü ´y bp ¨y
Tabel 1.2: ISO 8859 Part 1: Latin alphabet No. 1.
Vores æ/Æ blev ogs˚a i begyndelsen kaldt en ligatur og først ved en senere rettelse accepteret
som selvstændigt bogstav!
HTML-kodning
Ved at udnytte elektronisk lagrings muligheder for effektiv adgang til alverdens oplysninger
kan man bygge systemer, der ud fra henvisninger i en tekst hurtigt finder frem til det,
der henvises til. Med den slags systemer til r˚adighed ændrer begrebet “tekst” karakter:
snarere end en lineær strøm fornemmes den som en struktur med dybde i, og betegnelsen
“hypertekst” er foresl˚aet indført for at dække dette nye begreb. Kort kan en hypertekst
m˚aske forklares som en “tekst med aktive henvisninger”, og det er klart, at der s˚a bliver
brug for et særligt formuleringssprog, et “afmærkningssprog”, at skrive den slags tekster i.
HTML st˚ar for “HyperText Markup Language” og er dels en betegnelse for selve begrebet
(afmærkningssprog til at skrive hypertekster i), dels en betegnelse for et ganske bestemt
s˚adant sprog, der er vidt udbredt og blandt andet benyttes af systemerne “Netscape” og
“Internet Explorer”. De forhold, som omtales her, gælder version 2.0 af HTML. Sproget er
s˚adan indrettet, at man ved udformning af kildeteksterne bag HTML-dokumenter kan nøjes
med tegn fra ISOs 7 bit-sæt.
For i teksten “se DIKUs hjemmeside” i et HTML-dokument at f˚a ordene “DIKUs hjemmeside”
til at henvise til DIKUs hjemmeside skal man indføre et s˚akaldt “anker” i kildeteksten:
se

for eksempel . . . fremhævet tekst. . . og stærk fremhævelse (som regel med fedt)
angives . . . stærkt fremhævet tekst. . . .
Som det ses, bruger HTML vinkelparenteser til den slags direktiver, og tegnene “mindre
end” og “større end” kan derfor ikke bruges i en HTML-tekst i deres normale betydning,
men kodes som henholdsvis &lt; og &gt;. Det betyder igen, at og-tegnet (&)
ikke kan bruges, men kodes &amp;. Eksemplet ovenfor viser, at parametre i direktiver (her
http://www.diku.dk/index.html) skal sættes i anførelsestegn; et eventuelt anførelsestegn
i en s˚adan parameter skal derfor skrives &quot;. De grafiske tegn fra tabel 1.1, der ikke uden
videre kan indg˚a i en HTML-tekst, er dermed
tegnet skal i HTML-kildetekster skrives
& &amp;
< &lt;
> &gt;
" (i direktivparametre) &quot;
Ogs˚a alle tegnene i ISO 8859-1 Latin 1 kan i HTML beskrives via sekvenser af 7 bittegn.
Hovedreglen er, at tegnet med valør n (som decimalt talord) f˚as ved at skrive &#n;
— et paragraftegn skrives alts˚a for eksempel &#167; — men for bogstaverne er der ogs˚a
mnemotekniske koder som vist i nedenst˚aende tabel.
HTML HTML HTML HTML HTML HTML
À &Agrave; È &Egrave; Ì &Igrave; Ò &Ograve; Ù &Ugrave; Ç &Ccedil;
Á &Aacute; É &Eacute; Í &Iacute; Ó &Oacute; Ú &Uacute; ´ Y &Yacute;
 &Acirc; Ê &Ecirc; Î &Icirc; Ô &Ocirc; Û &Ucirc; D- &ETH;
à &Atilde; Õ &Otilde; Ñ &Ntilde;
Ä &Auml; Ë &Euml; Ï &Iuml; Ö &Ouml; Ü &Uuml;
˚A &Aring; Æ &AElig; Ø &Oslash; bp &THORN;
à &agrave; è &egrave; ì &igrave; ò &ograve; ù &ugrave; ç &ccedil;
á &aacute; é &eacute; í &iacute; ó &oacute; ú &uacute; ´y &yacute;
â &acirc; ê &ecirc; î &icirc; ô &ocirc; û &ucirc; d- &eth;
ã &atilde; õ &otilde; ñ &ntilde;
ä &auml; ë &euml; ï &iuml; ö &ouml; ü &uuml; ¨y &yuml;
˚a &aring; æ &aelig; ß &szlig; ø &oslash; bp &thorn;
1.7.3 Unicode
Selv med 256 muligheder er der ikke plads til alle ønskelige tegn, og i 1989 indledtes arbejdet
med at definere et mere omfattende tegnsæt. M˚alet var at løse problemet ved én gang for alle
at sørge for et tilstrækkelig stort rum af muligheder. I 1991 blev “The Unicode Consortium”
et aktieselskab med ansvar for at definere og vedligeholde en 16-bit-kode med plads til
alle tegn i alle verdens sprog. Den seneste version 2.0 af “The Unicode Standard” f˚as som
bog[16]; ud af de 65536 muligheder er mere end halvdelen udnyttet (helt præcist defineres
38885 pladser), men s˚a er der ogs˚a b˚ade blevet plads til kyrilliske og græske bogstaver,
lydskrift, arabiske tegn, thai, og til 20902 kinesisk-japansk-koreanske tegn samt en del mere.
Man har sørget for, at de forreste 256 pladser falder sammen med ISO’s 8-bit-kode.
21

Den internationale standardiseringsorganisation er g˚aet et skridt videre og har med standarden
ISO/IEC 10646 ˚abnet mulighed for en 31-bit-kode. Foreløbigt er dog kun pladser
blandt de første 2 16 udnyttet, og de stemmer overens med “Unicode”.
1.8 Funktionsbegrebet
Det fremg˚ar af betegnelsen, at begrebet funktion spiller en central rolle i funktionsprogrammering,
men det kan være p˚a sin plads at gøre opmærksom p˚a nogle forskelle mellem
matematikeres og datalogers brug af ordet.
1.8.1 Den matematiske opfattelse
Hvis to varierende størrelser x og y hører sammen p˚a en s˚adan m˚ade, at der til hver værdi
af x netop findes én værdi af y, siges y at være en funktion af x, og x kaldes den uafhængige
og y den afhængige variabel.
Ordet funktion bruges ogs˚a mere abstrakt om selve den sammenhæng, der er mellem x og
y, og i denne betydning taler man ogs˚a om en afbildning. Lad f betegne en abstrakt funktion
eller afbildning. Den til en forelagt værdi v (som i denne forbindelse ogs˚a kaldes funktionens
“argument”) af den uafhængige variabel hørende værdi af den afhængige variabel betegnes
da f(v) og læses “f af v” eller “f anvendt p˚a v”.
Fra skolen kendes funktioner, hvor x og y er tal, men funktionsbegrebet er ikke begrænset
hertil: størrelserne kunne ogs˚a være tegn, tekster, figurer, strukturer eller hvad som helst
andet.
Total funktionel relation
Mere generelt vil en matematiker kalde en forbindelse mellem en mængde af x-værdier og
en mængde af y-værdier for en relation. Mængden af værdier, x kan antage, kan man kalde
primærmængden for relationen, og mængden af mulige værdier af y betegnes da tilsvarende
sekundærmængden.
Relationen er en funktion, hvis der til hver værdi af x netop svarer én værdi af y. Dette
krav kan opløses i to dele: At der til hver værdi af x højst svarer en værdi af y udtrykker
man ved at sige, at relationen er funktionel, eller at y er en partiel funktion af x. At der til
hver værdi af x mindst findes en værdi af y, betyder, at relationen er total.
1.8.2 Den datalogiske opfattelse
Hvis y er en partiel funktion af x, vil der for hver værdi af x i primærmængden enten ingen
y-værdi findes, eller ogs˚a vil der netop findes én tilhørende værdi af y. Den partielle funktions
definitionsmængde best˚ar af de værdier af x, for hvilke der faktisk findes en tilhørende værdi
af y. En partiel funktion, der har hele primærmængden som sin definitionsmængde, siges at
være total (eller blot “at være en funktion”).
Funktioner er ofte nyttige ved beregninger, men for at kunne bruge en funktion i et
program m˚a man beskrive den, det vil sige i programmet medtage en tekst, som forklarer,
hvilken funktion der er tale om. At dataloger p˚a den m˚ade strengt taget ikke arbejder med
22

“funktioner”, men med “funktionsbeskrivelser” eller “funktionstekster”, giver anledning til
to vigtige afvigelser i forhold til det matematiske funktionsbegreb:
1. Det er for det første et centralt resultat inden for teoretisk datalogi, at intet automatisk
system ud fra en forelagt funktionstekst kan afgøre, om den beskrevne funktion er total
eller ej. N˚ar man i programmer anvender en funktion f p˚a et argument v, m˚a man
som hovedregel være forberedt p˚a, at det ikke nødvendigvis fører til en funktionsværdi
— f kunne ogs˚a være udefineret for værdien v.
For en datalog vil en “funktion” derfor næsten altid være det, en matematiker mere
korrekt ville kalde “en partiel funktion”.
2. Den anden forskel har at gøre med begrebet “lighed”. Vi vil i næste kapitel se, at
nedenst˚aende erklæringer er korrekte funktionsdefinitioner i programmeringssproget
Standard ML:
fun f(n) = n + n
fun g(n) = 2 * n
Matematisk set er de to funktioner f og g ens, idet de har identisk samme virkning
(de fordobler deres heltallige argument), men der er tale om to forskellige funktionsbeskrivelser
og dermed to forskellige realiseringer.
For dataloger er funktionsbeskrivelserne vigtige (forskellige realiseringer af samme matematiske
funktion kunne have vidt forskelligt forbrug af køretid og andre ressourcer), og i
datalogisk undervisningsmateriale skal termen “funktion” normalt forst˚as som “funktionsbeskrivelse”
(programtekst til beregning af en ikke nødvendigvis total funktion).
1.9 Litteratur
Den opfattelse af faget datalogi, som kommer til udtryk i dette kapitel, er i høj grad præget
af tanker, der i 1960’erne udgik fra en gruppe medarbejdere ved Regnecentralen (først et
institut under Akademiet for de Tekniske Videnskaber, senere omdannet til aktieselskab) og
blandt dem først og fremmest Peter Naur, senere professor ved Datalogisk Institut. Nogle af
disse tidlige overvejelser er formuleret i [4] og senere samlet i [10]. En række af Peter Naurs
bidrag til udformning af faget kan ses i [11].
23

Kapitel 2
Dialog med Standard ML
De første højere programmeringssprog (Fortran, Lisp og Algol) blev konstrueret omkring
1960. Helt s˚a gammelt er ML ikke, idet det blev fastlagt over en periode, der begyndte
cirka 1978. Varianten Standard ML, som vi benytter her, blev defineret præcist i 1990 [7],
[8] med en revision i 1997 [9]. I disse indledende noter benyttes dialekten Moscow ML (fra
omkring 1998), se [14].
Navnet er en forkortelse af Meta Language, og metasprog er logikeres betegnelse for
sprog brugt til at forklare eller behandle andre sprog i. Oprindeligt blev ML konstrueret
som et hjælpesprog i forbindelse med projektet LCF (Logic of Computable Functions), der
gik ud p˚a at føre beviser om funktioner. Meningen var, at man i ML skulle kunne finde,
udtrykke og f˚a verificeret beviser om et system af funktionsdefinitioner.
Tilbage fra LCF-projektet st˚ar formalismen ML, der viste sig velegnet til alle former for
beregninger. (Sproget ML er universelt i foreg˚aende kapitels forstand.)
2.1 Dialogen
Uden her at komme ind p˚a, hvordan det foreg˚ar (se eventuelt
http://www.dina.kvl.dk/~sestoft/mosml.html) vil vi g˚a ud fra, at man har f˚aet installeret
Moscow ML p˚a sin computer. N˚ar systemet mosml er blevet aktiveret og har
præsenteret sig, slutter det af med et klar-symbol (eng.:prompt) (her best˚aende af linjeskift,
bindestreg og blanktegn), hvorefter det afventer inddata fra brugeren. P˚a det tidspunkt, hvor
disse noter blev skrevet 1 , s˚a det s˚aledes ud p˚a skærmen (idet vi lader dollartegnet st˚a for
operativsystemets klar-symbol og viser den blinkende markør (eng.:cursor) som et udfyldt
rektangel):
$ > mosml
Moscow ML version 2.01 (January 2004)
Enter ‘quit();’ to quit.
-
Indtaster man her et udtryk (eng.:expression) (efterfulgt af semikolon og nylinjetegn),
vil systemet beregne dets værdi, udskrive en respons, der angiver denne værdi, og derefter
p˚any skrive et klar-symbol og s˚a afvente yderligere inddata:
1 juni 2005
25

2 + 2;
> val it = 4 : int
-
For ML har hver værdi en bestemt type, og 4 er et heltal (eng.:integer), i ML forkortet
til int. Det ses, at i tilgift til at beregne vores udtryks værdi oplyser systemet ogs˚a, hvilken
type værdien har. Kolonet mellem værdi og type kan læses “af type”.
Dette er ML-systemets grundlæggende virkem˚ade: I en fortsat dialog veksles der mellem,
at brugeren angiver en s˚akaldt top-niveau-erklæring, og at systemet som svar rapporterer sin
evaluering af den. En af de mulige former, en top-niveau-erklæring kan have, er et udtryk,
og systemet vil svare med udtrykkets værdi og type.
Læg mærke til, at indgangsudtryk skal afsluttes med semikolon. Man kan godt lade et
udtryk strække sig over flere linjer:
2 +
Selv om vi har tastet et linjeskift, sker der ingenting, for udtrykket er ikke afsluttet. Vi
fortsætter med den anden operand og et linjeskift:
2
men der sker stadig ikke noget: semikolonet mangler! N˚ar det sættes (og man bagefter taster
linjeskift), udløses beregningen:
;
> val it = 4 : int
-
Udtryk kan naturligvis indeholde mere end én operation (her og i de følgende eksempler
udelades klar-symbolet):
4 - (1 + 2 + 3);
> val it = ~2 : int
Der er fem indbyggede operationer p˚a heltal: + (addition), - (subtraktion), * (multiplikation),
div (heltallig divisionskvotient) og mod (rest ved heltalsdivision).
2.1.1 Foranstillede (monadiske) operatorer
P˚a nogle punkter afviger SML’s regler for, hvordan udtryk skal skrives, fra gængs matematisk
notation. Det er blandt andet s˚adan, at SML’s m˚ade at analysere og gruppere udtryk
p˚a gør det nødvendigt at kunne skelne mellem operatorer og funktioner: Intet symbol kan
samtidigt b˚ade fungere som operator (med to operander) og som funktion (med et argument).
Symboler, der skal kunne foranstilles en enkelt operand, klassificeres af SML som funktioner;
derfor er det ikke muligt at give en dyadisk operator (som skal skrives mellem sine
to operander) samme symbol som en monadisk operator (der stilles foran sin operand).
Eftersom symbolet + er den dyadiske additionsoperator, er det ikke lovligt at bruge
symbolet som monadisk operator:
26

+ 10;
! Toplevel input:
! + 10;
! ~~~~
! Ill-formed infix expression
Ulykken er naturligvis ikke s˚a stor; et foranstillet plus kan jo bare undværes. Værre er
det med foranstillet minus — det ville være irriterende at være nødt til at skrive minus ti
som 0 - 10. Den løsning, man har valgt i SML (men de fleste andre programmerinssprog
h˚andterer problemet p˚a anden vis), er at bruge symbolet ~ (tilde) som monadisk minus:
~ 10;
> val it = ~10 : int
Ud over monadisk minus er der en indbygget monadisk operator mere p˚a heltal: Den
numeriske eller absolutte værdi |n| af et tal n skal i SML skrives abs n.
Tilde har i øvrigt i princippet to forskellige funktioner i SML: Dels betegner symbolet
som nævnt funktionen til skift af fortegn; dels bruges det, n˚ar man skal anføre en negativ
talkonstant, hvor tilden skrives lige foran det forreste ciffer 2 .
Her er et eksempel til illustration af forskellen. Først som negativmærke i en talkonstant:
abs ~7;
> val it = 7 : int
Og derefter som monadisk operator:
abs ~ 7;
! Toplevel input:
! abs ~ 7;
! ~~~
! Overloaded abs cannot be applied to argument(s) of type int -> int
Fejlmeldingen skyldes, at SML (efter regler, vi senere vil forklare nærmere) vil gruppere de
tre symboler fra venstre: (abs ~) 7. SML tror med andre ord, at vi vil tage den numeriske
værdi af monadisk minus. N˚ar ~ bruges som fortegnsvendefunktion, kan det derfor være
nødvendigt med en parentes:
abs (~ 7);
> val it = 7 : int
2.1.2 Sandhedsværdi
Ligesom de hele tal udgør sandhedsværdierne en grundtype, men den har kun to egentlige
værdier: true og false:
3 < 5;
> val it = true : bool
2 Vi s˚a allerede denne anvendelse i de to foreg˚aende systemsvar ~2 og ~10.
27

Typen af sandhedsværdier eller logiske værdier (eng.:Booleans) forkortes bool, benævnt
efter den britiske matematiker George Boole (1815–1864), der blandt andet arbejdede med
algebraiske operationer med egenskaber analoge til logisk “og” og logisk “eller”.
I valgudtryk af formen if ... then ... else ... skal der mellem if og then anbringes
et udtryk af logisk type:
if 1 + 1 = 2 then ~3 + ~3 else ~3 - ~3;
> val it = ~6 : int
2.1.3 Værdierklæring
Eksemplerne har vist top-niveau-erklæringer i form af udtryk. En anden mulig form for
top-niveau-erklæring er en værdi-erklæring, der bruges til at benævne en beregnet værdi:
val Chr4aar = 1588 - 1648;
> val Chr4aar = ~60 : int
Herefter kan det indførte navn benyttes i udtryk, og virkningen vil være, som havde man
anført værdien direkte:
abs Chr4aar < 50;
> val it = false : bool
Systemets svar p˚a et indtastet udtryk har omtrent samme form som en værdierklæring
af navnet it, og en top-niveau-erklæring af formen
udtryk ;
er simpelt hen en forkortet skrivem˚ade for
val it = udtryk ;
Navnet it er med andre ord til r˚adighed, n˚ar udtryk skrives ned. P˚a den m˚ade kan man
bekvemt f˚a angivet mellemresultater, inden der regnes videre p˚a dem: (I hvilket omfang
parenteser er nødvendige, og i hvilket omfang de kan undværes, vil blive behandlet i de
følgende afsnit.)
(8 * 7) div (1 * 2);
> val it = 28 : int
- it * 6 div 3;
> val it = 56 : int
- it * 5 div 4;
> val it = 70 : int (alt i alt har vi nu f˚aet beregnet 8·7·6·5
1·2·3·4 )
2.1.4 Afslutning
For igen at forlade SML-systemet skrives (husk parenteser, semikolon og linjeskift)
$
quit();
hvorved man bringes tilbage til operativsystem-niveau.
28

2.2 Gruppering
Eksemplerne viser, hvordan udtryk i SML er bygget op af operatorer og operander, idet
operatoren placeres mellem sine to operander. N˚ar et udtryk har mere end én operator,
er yderligere afklaring nødvendig. Vi tillægger for eksempel 28 − 5 + 3 værdien 26 (nemlig
3 lagt til differensen 28 − 5) og ikke 20 (der ville blive resultatet, hvis man trak summen
♠+
5 + 3 fra 28). Man kan vise grupperingen entydigt i et udtrykstræ ♠−
❅
3
, men i
❅
28 5
lineær notation kan det være nødvendigt at sætte parenteser. Hvis det, man gerne vil have
♠−
❅
udregnet, er
28
♠+ , bliver man nødt til at skrive 28 − (5 + 3) (eller 28 − 5 − 3),
❅
5 3
mens parentesen i (28 − 5) + 3 kan underforst˚as.
2.2.1 Associering
Man udtrykker gerne de beskrevne grupperingsregler ved at sige, at operatorerne + og - associerer
fra venstre: i flerleddede konstruktioner med + og - virker operationerne fra venstre
mod højre; hvis det er en anden rækkefølge, man er ude efter, kan man sætte parenteser.
Ogs˚a operatorerne * og div associerer fra venstre: 120 div 4*3 vil i ML blive udregnet
som (120 div 4) * 3; hvis der b˚ade skal divideres med 4 og med 3, m˚a man skrive
120 div (4*3) (eller 120 div 4 div 3).
I eksemplet (8 * 7) div (1 * 2) ovenfor er den første parentes derfor overflødig, men
den anden ikke; uden parenteser kunne det skrives 8 * 7 div 1 div 2.
Associerer en binær operator fra højre, betyder det naturligvis helt analogt, at der i
et udtryk med flere forekomster af operatoren er underforst˚aet parenteser sat fra højre. Vi
vil senere i forbindelse med lister møde operatoren :: (hvis betydning kan udtrykkes: “sat
foran”), der i ML associerer fra højre. Udtrykket a :: b :: c :: x skal med andre ord
forst˚as som a :: (b :: (c :: x)).
Det har været hævdet, at konstruktioner i dagligsproget naturligt associerer fra højre
— siger man “indgang ad døren i huset p˚a toppen af bakken”, s˚a betyder det jo “indgang
ad (døren i (huset p˚a (toppen af bakken)))” — og i programmeringssproget APL tog man
konsekvensen og lod alle operatorer associere fra højre. Alligevel er associering fra venstre
langt det almindeligste i de fleste programmeringssprog og ogs˚a i SML (hvor vi kun skal
møde tre undtagelser fra denne regel).
2.2.2 Prioritet
Selv om b˚ade - og * associerer fra venstre, giver SML 52-5 * 7 værdien 17, i overensstemmelse
med den normale læsem˚ade.
Det, som her gør sig gældende, er, at operatorer kan binde med forskellig prioritet: * og
div binder stærkere end + og -. SML arbejder med ti forskellige prioriteter, som betegnes
med cifrene fra 0 til 9 med et højere nummer som betegnelse for stærkere binding. De
29

operatorer, der skal benyttes i denne del af kurset, er samlet i tabel 2.1, hvor de er vist efter
aftagende prioritet tillige med deres associeringsretning. (En tilsvarende tabel findes som
Table D.4 i lærebogen [5].)
prioritet operator retning
7 * div mod / associerer fra venstre
6 + - ^ associerer fra venstre
5 :: @ associerer fra højre
4 = < >= associerer fra venstre
3 o associerer fra venstre
Tabel 2.1: Binære operatorer i mosml og deres associeringsretning og bindingsprioritet.
Vi har ikke mødt alle disse symboler endnu, men =, , = benyttes i sammenligninger,
/ betegner division af reelle tal, ^ binder tekster sammen, :: og @ virker i
forbindelse med lister, og o betegner funktionssammensætning.
2.3 Funktioner
I et funktionsprogrammeringssprog opfattes en funktion som en værdi p˚a linje med andre
værdier s˚asom tal, tekster, lister osv. Et udtryk kan s˚aledes godt evaluere til en værdi, der er
en funktion (vi vil ikke længere anføre de tegn (- og >), som henholdsvis indleder brugerens
inddata og systemets svar):
abs;
val it = fn : int -> int
Selve værdien af udtrykket er det alt for omfattende at skrive ud 3 , s˚a vi f˚ar bare med
forkortelsen fn at vide, at der er tale om en funktion, men ligesom for simple værdier gives
der udførlig besked om typen: Betegnelsen τ -> τ ′ (hvor τ og τ ′ er typer) er MLs notation
for typen af funktioner med argument af type τ og værdi af type τ ′ . Her f˚ar vi alts˚a at vide,
at abs kan anvendes p˚a et heltal og i s˚a fald giver et heltal som funktionsværdi.
(Hvis man ikke kan huske en funktions type, er det smart, at man bare kan bede om at
f˚a evalueret selve funktionen (uden argumenter): s˚a vil systemets svar angive typen.)
Tilde betegner funktionen til beregning af det modsatte af et tal:
~ (Chr4aar);
val it = 60 : int
~;
val it = fn : int -> int
Man kan konstruere valgudtryk, der vælger mellem hvilke som helst værdier af samme type,
ogs˚a for eksempel funktioner:
3 En funktion fra mængden A til mængden B kan opfattes som en mængde af par (a, b) med lige s˚a mange
par, som der er elementer i A.
30

if 3 = 5 then ~ else abs;
val it = fn : int -> int
it (24);
val it = 24 : int
selv om det nok sjældent vil forekomme i praktiske anvendelser.
2.3.1 Funktionserklæring
I Standard ML er et stort antal nyttige funktioner defineret p˚a forh˚and. Vi har allerede
mødt abs og ~, men man kan for eksempel i Appendix D i [5] se nogle af de mange andre
biblioteksfunktioner.
Man kan imidlertid ogs˚a konstruere sine egne funktioner (og størstedelen af et SMLprogram
vil netop typisk best˚a af funktionserklæringer). En funktion lader til et argument
svare en entydigt bestemt funktionsværdi, og i et programmeringssprog kan man naturligvis
kun h˚andtere funktioner, hvor funktionsværdien kan beregnes ud fra argumentet. For at
fastlægge en funktion kræves derfor
• funktionens navn (s˚a den senere kan kaldes)
• en anvisning p˚a, hvordan funktionsværdien findes ud fra argumentet
En mulig m˚ade at præsentere disse oplysninger p˚a er
fun funktionsnavn parametermønster = krop (2.1)
Parametermønsteret kan indeholde et eller flere navne, som da kaldes funktionserklæringens
formelle parametre; i simpleste tilfælde best˚ar parametermønsteret blot af en enkelt formel
parameter. Ved igen at bruge de formelle parameternavne i funktionskroppen kan det vises,
hvordan funktionsværdien skal beregnes.
Her er nogle eksempler:
fun kvadrat x = x * x
fun skat indtgt = indtgt * 0.09 + (indtgt - 2125.0) * 0.42;
val kvadrat = fn : int -> int
val skat = fn : real -> real
Vi bemærker, at selv om funktionerne blev defineret med nøgleordet “fun”, behandler systemet
ikke funktioner anderledes end andre værdier: i kvitteringerne bruges “val” ligesom
i taleksemplerne. Systemets svar viser ogs˚a, at det er funktionsnavnet, der huskes, mens
parameternavne ikke omtales (de er kun “midlertidige pladsholdere” eller “bundne variable”,
som man ogs˚a siger). Som nævnt ovenfor kan svaret ikke angive funktionens virkning (men
blot skrive “fn” for “dette er en funktion”), hvorimod typen (efter kolonet) præciseres.
Efter at man selv har defineret en funktion, kan den kaldes p˚a fuldstændig samme m˚ade
som en biblioteksfunktion:
kvadrat (317);
val it = 100489 : int
skat (15000.00);
val it = 6757.5 : real
31

De argumenter, funktionsnavne medgives, n˚ar de kaldes (her 317 og 15000.00), benævnes
ogs˚a aktuelle parametre.
2.3.2 Funktionskald, parenteser og prioritet
I matematisk notation markeres funktionskald sædvanligvis ved, at der sættes parentes om
argumentet: funktionen f kaldt med argumentet x skrives f(x).
I Standard ML har man vedtaget, at funktionskald (som m˚a formodes at være den
hyppigste operation i et funktionsprogrammeringssprog) kan underforst˚as og blot angives
ved, at et udtryk (der derved opfattes som en funktion) stilles foran et andet (som s˚a
opfattes som argument). I SML bruges parenteser først og fremmest til gruppering 4 , s˚a et
deludtryk holdes sammen som en helhed. Ved funktionskald er det derfor tilladt, men ikke
altid nødvendigt, at sætte parentes om argumentet:
|123| kan i SML skrives abs 123 eller abs(123) eller (abs)123 eller (abs)(123)
En eller anden form for adskillelse er der dog brug for: udtrykket abs123 ville blive opfattet
som et nyt selvstændigt navnesymbol.
Forestiller man sig et udtryk bygget op skiftevis af (ope)rander og (ope)ratorer
rand ratorsymbol rand ratorsymbol rand . . . rand ratorsymbol rand
s˚a har operationen “funktionsanvendelse” slet ikke noget symbol: Der kommer bare to operander
lige efter hinanden.
I udtryk, hvor der er flere funktionsanvendelser eller b˚ade funktionsanvendelse og almindelige
operatorsymboler, bliver det nødvendigt med regler for associeringsretning og
prioritet. Gruppering afklares af:
Dette forklarer
kvadrat 3+4;
val it = 13 : int
Funktionsanvendelse associerer fra venstre
og har højere prioritet end nogen operator.
— var det 7, man ville have kvadreret, skulle det have været skrevet kvadrat (3+4). Selv
om det i starten kan føles lidt sært, er det nyttigt at lære sig SML’s regler, s˚a man kan
slippe for at sætte s˚a mange parenteser; man vænner sig hurtigt til at skrive for eksempel
f 1 + f 2 + f 3 i steden for f(1) + f(2) + f(3).
M˚aske bør det nævnes, at selv om man normalt godt kan sætte parentes omkring funktionsdelen
af et funktionskald (som i (f)317), er dette ikke tilladt i selve erklæringen (2.1).
Alle udtryk underkastes en omhyggelig typekontrol: For at acceptere en funktionsanvendelse
F -udtryk A-udtryk kræver SML, at F -udtryk har type τ → τ ′ og A-udtryk type
τ; hele funktionsanvendelsesudtrykket f˚ar s˚a type τ ′ .
4 Parenteser bruges ogs˚a i forbindelse med sæt (se afsnit 4.2) og sekvenser (se [7], [9] eller [12]).
32

Som tidligere nævnt kan tilde indg˚a i en talkonstant, idet symbolet skrives umiddelbart
foran det forreste ciffer som for eksempel i ~7. Skilles tilden fra det efterfølgende tal, bliver
det til et applikationsudtryk med ~ som funktion og tallet som argument. Det samme
gælder, hvis tilde st˚ar foran andet end et ciffer; ogs˚a ~Chr4aar vil blive opfattet som fortegnsskiftsfunktionen
anvendt p˚a et argument (her Chr4aar). Dette er forklaringen p˚a, at
selv om kvadrat ~7 lader sig beregne, g˚ar det galt, hvis man skriver kvadrat ~ 7 eller
kvadrat ~Chr4aar: Eftersom funktionsanvendelse associerer fra venstre, ser systemet disse
udtryk som (kvadrat ~) 7 henholdsvis (kvadrat ~) Chr4aar, hvilket ikke giver mening.
(Kvadreringsfunktionen skal anvendes p˚a en heltallig værdi og kan ikke anvendes p˚a fortegnsskiftefunktionen.)
2.3.3 Argumentsæt
Funktioner af flere variable kan defineres, som disse eksempler viser:
fun gaar op i (d,n) = n mod d = 0;
val gaar op i = fn : int * int -> bool
fun gnsnt (x,y,z) = (x + y + z) / 3.0;
val gnsnt = fn : real * real * real -> real
gaar op i (3,16);
val it = false : bool
gnsnt (1.2,~4.1,5.7);
val it = 0.933333333333 : real
Placerer man i en parentes to eller flere udtryk, adskilt af kommaer, dannes et sæt
(eng.:tuple), hvis type er “det kartesiske 5 produkt” af de indg˚aende udtryks type. SML
opfatter de viste funktionserklæringer som specialtilfælde af (2.1), hvor argumentets type
blot er et sæt.
2.4 Sprogsystemets faser
Hvis parenteser skal sættes p˚a en bestemt m˚ade, for at et udtryk kan blive typemæssigt
korrekt (s˚adan som tilfældet var med abs ~ 7 ovenfor), kunne man mene, at SML burde
kunne bruge typeinformationen til at regne ud, hvor parentesen er underforst˚aet.
Et af grundprincipperne i SML er imidlertid, at det normalt ikke skal være nødvendigt
for en bruger at angive typen for navne og værdier, men at systemet af sammenhængen
udleder, hvilken type de enkelte dele nødvendigvis m˚a have.
En forudsætning for, at denne typeudledning kan lykkes, er, at udtryk er grupperet
korrekt. Sprogsystemets rækkefølge er derfor, at først grupperes udtrykkets dele, og derefter
udledes typerne. Følgelig kan typeinformation ikke styre grupperingen.
I store træk kan man sige, at sprogsystemets evaluering af et udtryk gennemløber fire
faser
1. Strømmen af enkelttegn, som danner programmet, opdeles i grundsymboler
5 efter René Descartes (1596–1650), koordinatsystemets opfinder.
33

2. Grundsymbolerne grupperes i større helheder. (Man kan forestille sig, at alle de underforst˚aede
parenteser nu tilføjes)
3. Typer udledes og kontrolleres
4. Udtrykkets værdi beregnes
Flere detaljer af disse faser behandles senere 6 ; i dette kapitel er der kun grund til at
nævne et enkelt forhold i forbindelse med skanderingen i grundsymboler, fordi det kan give
anledning til fejlmeldinger, der ellers kan være svære at forst˚a.
2.4.1 Navne
Som et bogstav regner sprogsystemet de 26 latinske bogstaver (sm˚a og store bogstaver er
forskellige) a. . . z og A. . . Z, og et ciffer er et af de decimale cifre 0. . . 9. Et alfanumerisk tegn
er et bogstav, et ciffer, en understregning ( ) eller en apostrof (’).
I Standard ML kan et navn (eng.:identifier) være af to forskellige former: Et alfanumerisk
navn (eng.:alphanumeric identifier) er en sekvens af alfanumeriske tegn, der begynder med
et bogstav 7 .
Et symbolsk navn (eng.:symbolic identifier) er en sekvens af et eller flere af følgende tyve
navnetegn:
! % & $ # + - / ; < = > ? @ \ ~ ‘ ^ | *
Operatorer betegnes ogs˚a med navne; vi har ovenfor b˚ade mødt operatorer med alfanumeriske
navne (div og mod) og operatorer med symbolske navne (for eksempel +, -, *).
Lange navne Større programmer opdeles bekvemt i separate programdele, som kaldes
strukturer og navngives med alfanumeriske navne. For at f˚a fat i et navn, der er ligger inde
i en struktur, benyttes et s˚akaldt langt navn (eng.:qualified identifier)
strukturnavn.navn
eller mere generelt (for et navn inde i struktur1 inde i struktur2 . . . )
strukturnavnn. . .strukturnavn2.strukturnavn1.navn
Skandering Selv om et udtryk som for eksempel Chr4aar · a1 − a0 opskrives helt uden
adskillelse:
Chr4aar*a 1-a 0
kan SML-systemet godt finde ud af at skille det rigtigt ad i grundsymboler
Chr4aar * a 1 - a 0
fordi der skiftevis bruges alfanumeriske og symbolske navne.
I andre tilfælde kan det g˚a galt. Vi kan nu forst˚a den fejlmelding, som fremkommer, hvis
man forsøger at omdøbe fortegnsvendefunktionen p˚a følgende m˚ade:
6 I teorien for formelle sprog svarer de fire faser henholdsvis til 1. leksikalsk analyse, 2. kontekstfri syntaksanalyse,
3. kontekstsensitiv syntaksanalyse og 4. semantisk analyse. (De to sidste faser kaldes ogs˚a 3. statisk
semantik og 4. dynamisk semantik.)
7 Teknisk set henregner sprogdefinitionen ogs˚a typevariable, som er en sekvens af alfanumeriske tegn, der
begynder med en apostrof, til alfanumeriske navne.
34

fun modsat(n)=~n;
! Toplevel input:
! fun modsat(n)=~n;
! ^
! Syntax error.
De to navnetegn lige efter hinanden opfattes af systemet som et nyt symbolsk navn =~.
Man bør gøre sig det til en vane at skille operatorer og operander fra hinanden med
blanktegn, og alle programeksempler i disse noter vil s˚a vidt muligt blive noteret p˚a den
m˚ade. Eksemplet bør alts˚a skrives
fun modsat n = ~ n;
val modsat = fn : int -> int
2.5 Fem simple typer
I Standard ML er der fem simple grundtyper 8 : heltal int, brudne tal real, sandhedsværdier
bool, tegn char og tekster string.
Nye typer kan blandt andet dannes som produkttyper τ1 * τ2 * . . . * τn, som funktionstyper
τ -> τ ′ og som listetyper τ list ud fra tidligere typer τ, τ ′ , τ1, τ2, . . . , τn. I senere
kapitler vil vi have mere at sige om produkttyper, funktionstyper og listetyper.
Figur 2.1 giver en oversigt over de fem simple typer og deres standardoperatorer og
-funktioner. Vi vil senere vende tilbage med flere detaljer, men for at man hurtigt skal
kunne komme i gang med at skrive sm˚a programmer, følger her en foreløbig gennemgang.
2.5.1 To typer tal
I de fleste programmeringssprog er hele og reelle tal to disjunkte typer. Det kan virke underligt,
hvis man er vant til det matematiske synspunkt, hvor de hele tal regnes som en
delmængde af de reelle ( Z ⊆ R), men kan m˚aske forsvares ud fra et modeldannelsessynspunkt:
N˚ar man i en beskrivelse bruger tal, vil det normalt enten være om fænomener, der er
kombinatoriske eller kan optælles (et antal personer, trappetrin, et kontant ørebeløb eller
lignende) og derfor kan angives ved et heltal — eller det vil være om et eller andet fysisk
fænomen (afstand, temperatur, tryk, tidsinterval, osv.), der kan angives ved et reelt tal. Et
ark papir har 2 sider, men selv om man m˚aske angiver en bordplades længde som heltallet
2 meter, s˚a er længden ikke p˚a samme m˚ade “to af en ting”. Bordet er muligvis 2.00 m og
m˚aske ogs˚a 2.000 m langt, men næppe 2.0000 m — i praksis er m˚alinger af fysiske fænomener
altid behæftet med en vis usikkerhed, og det er mere korrekt at sige, at bordpladens længde
m˚alt i meter er det reelle tal 2.
I Standard ML er der to taltyper 9 : int og real, og allerede talkonstanter tillægges en
bestemt af de to typer. Konventionen er, at hvis der kun bruges cifre, eventuelt med en tilde
umiddelbart foran
8Sprogdefinitionen kræver ogs˚a typerne unit og word, og implementationen Moscow ML føjer hertil
order og word8.
9samt word og i Moscow ML yderligere word8. Disse typer skal vi dog ikke beskæftige os med her.
35

~
abs
✬
✣
✫
✬
❄
✫
+ - *
div mod
chr
int
char
✻❖
ord
✩
✎
✪
size
=
< >=
=
< >=
✩
✪
ceil
floor
round
trunc
real
str
✬
✲
✫
=
< >=
✬
❄
❥
✯
✫
✒
=
< >=
✬
✲
✫
+ - *
/
real
=
bool
^
string
✢
✢
✩
~
abs
✪
✩
not
✪
✩
✪
Figur 2.1: Grundtyperne og deres p˚a forh˚and ˚abnede standardoperatorer og -funktioner.
36

5, 12, ~44, 007 : int
s˚a er typen hel. Konstanter med enten en decimaldel eller en eksponentdel eller begge dele
gives reel type:
5.0, ~1.4142, 3e12, 1E~6, 0.67194e~22 : real
Formerne mantisse e eksponent og mantisse E eksponent skal forst˚as som mantisse·10eksponent .
Hver del af et regneudtryk skal enten have hel eller reel type, og regneoperatorernes to
operander skal have samme type (som ogs˚a bliver resultatets type). For +, - og * skal enten
begge operander være hele, eller de skal begge være reelle. Divisionsoperatoren / kræver, at
begge operander er reelle, mens div og mod kun virker p˚a to hele værdier. Dette er illustreret
af pilene i figur 2.1.
Man kan derfor ikke skrive for eksempel x / 2 + 1, men m˚a enten vælge x div 2 + 1,
hvor x s˚a tillægges hel type (og resultatet rundes ned med 1,
hvis x er ulige), eller skrive
2
det x / 2.0 + 1.0 for x af reel type.
En anden mulighed er x / real 2 + 1.0, idet real ud over at betegne typen af brudne
tal ogs˚a er navnet p˚a den funktion, der omsætter fra hel til bruden type.
Den anden vej, fra reel til hel type, kan man i SML vælge mellem hele fire funktioner:
floor afrunder til det største heltal, der ikke er større (“afrunding mod −∞”), ceil afrunder
til det mindste heltal, der ikke er mindre (“afrunding mod ∞”), trunc bortkaster brøkdelen
(afskæring eller “afrunding mod 0”), og round tager det nærmeste heltal:
floor ~2.6 = ~3; floor 2.6 = 2;
ceil ~2.6 = ~2; ceil 2.6 = 3;
trunc ~2.6 = ~2; trunc 2.6 = 2;
round ~2.6 = ~3; round 2.6 = 3;
Værdier, som ligger nøjagtig midt imellem to hele tal, afrundes til det nærmeste lige heltal:
round 0.5 = 0; round 1.5 = 2; round 2.5 = 2;
Et stort antal funktioner til regning med reelle tal finder man i biblioteksmodulerne Real
og Math, som vil blive nærmere omtalt i næste kapitel.
2.5.2 Sandhedsværdier
Som figur 2.1 viser, er der en standardfunktion not : bool -> bool. Den ombytter de to
sandhedsværdier.
2.5.3 Tegn
Enkelttegn (eng.:characters) er en grundtype i Standard ML 10 . Tegnkonstanter skrives s˚aledes:
#"C" (bogstavet C), #"9" (et nital), # (et blanktegn). Funktionen ord giver koden for et
forelagt tegn, og chr giver omvendt tegnet med en forelagt kode. Sammenligninger mellem
tegn med

2.5.4 Tekster
En sekvens af tegn kaldes en tekst (eng.:string). For at danne en tekstkonstant sætter man
bare sekvensen i anførselstegn: "sekvens i anførselstegn". Antallet af tegn i en tekst
findes med size, og operatoren ^ sætter to tekster sammen til en:
"vand"^ "ring- "vandring"
Ved sammenligning af tekster med ordningsoperatorerne

Opgave 2.2 Definer den funktion 11 , som giver negative heltal værdien -1, positive heltal
værdien 1 og nul værdien 0.
Opgave 2.3 Definer den funktion af type int -> bool, som ud fra en persons alder afgør,
om personen har stemmeret.
Opgave 2.4 Definer en funktion, der afgør, om et heltal ender p˚a “5”. (Egentlig har tal
først cifre, n˚ar de repræsenteres som talord, s˚a opgaven skal naturligvis forst˚as som “. . . om
et heltal, hvis det blev skrevet som talord i titalssystemet, ville ende p˚a “5”.)
Opgave 2.5 Definer den funktion af type real -> real, som for et forelagt beløb (brudent
tal) i kroner tillægger 25 % moms og afrunder resultatet til et betalbart kronebeløb (et
multiplum af 25 øre).
Opgave 2.6 Definer den funktion af type int -> int, som ud fra antallet af deltagere p˚a
et kursus beregner, hvor mange øvelseshold der skal oprettes, n˚ar antallet af hold skal være
mindst muligt, men der højst m˚a være 25 p˚a hvert hold.
Opgave 2.7 Det er gratis at ringe til telefonnumre, hvis to første (af de otte) cifre er 80.
Definer en funktion af type int -> bool, der undersøger, om det er gratis at ringe til det
opgivne nummer.
Opgave 2.8 Definer en funktion, der omsætter en temperaturangivelse fra grader fahrenheit
til grader celsius (sammenhængen er lineær 12 og fremg˚ar af 0 ◦ C = 32 ◦ F og 100 ◦ C =
212 ◦ F).
Opgave 2.9 Definer en funktion, som finder det største af sine tre argumenter.
Opgave 2.10 Definer en funktion, som for et engelsk navneord i ental danner flertalsformen.
(Du kan g˚a ud fra, flertalsformen dannes ved tilføjelse af “s”, bortset fra ordene man,
woman, mouse og sheep, der i flertal hedder men, women, mice og sheep.)
Opgave 2.11 Definer en funktion af type char -> int, der beregner et bogstavs nummer
i alfabetet. [Vink: brug biblioteksfunktionen ord.]
Opgave 2.12 Definer en funktion, der undersøger, om et navn ender p˚a "sen". [Vink:
brug biblioteksfunktionerne size og String.substring.]
11Denne funktion er faktisk til r˚adighed i biblioteksmodulet Int under navnet Int.sign, men opgaven
her er selv at definere den.
12y siges at være en lineær funktion af x, hvis y = ax + b.
39

Kapitel 3
Programmeringssproget Standard ML
Forrige kapitel gav netop tilstrækkeligt med oplysninger til, at man kunne komme i gang med
praktiske programmeringsopgaver i Standard ML. I dette kapitel bliver disse oplysninger
uddybet og suppleret med flere detaljer om sproget. I kapitlets sidste afsnit omtales den
fuldstændige defintion af Standard ML.
3.1 Funktionsdefinition med valg mellem flere parametermønstre
Funktionsdefinitioner kan antage en mere generel form end den tidligere viste (2.1):
fun funktionsnavn parametermønster 1 = krop 1
| funktionsnavn parametermønster 2 = krop 2
| . . .
| funktionsnavn parametermønster n = krop n
(3.1)
Ved kald af en funktion, som er defineret p˚a den m˚ade, sammenholdes det aktuelle argument
med parametermønstrene. Hvis parametermønster i er det første mønster, der passer,
evalueres funktionskaldet ved hjælp af krop i. Læg mærke til, at mønstrene i (3.1) prøves
forfra 1, 2, . . . , n; hvis mønstrene overlapper hinanden, har den rækkefølge, man anfører tilfældene
i, derfor betydning.
Her er et eksempel:
fun reciprok 0 = 0.0
| reciprok n = 1.0 / real n;
val reciprok = fn : int -> real
reciprok 4;
val it = 0.25 : real
reciprok 0;
val it = 0.0 : real
Ved at anføre de to mønstre 0 og n i den viste rækkefølge sikrer man sig mod division
med 0.
41

3.2 Evaluering af funktionskald
Af hensyn til det følgende er det nyttigt at sl˚a helt fast, hvordan evaluering af funktionskald
foreg˚ar: Møder systemet under sine beregninger et applikationsudtryk, det vil sige to udtryk
F A, der er stillet sammen uden nogen operator imellem, opfattes F som funktionsdel og
A som argumentdel i et funktionskald, der udføres p˚a følgende m˚ade:
1. Den igangværende beregning stilles midlertidigt i bero.
2. Funktionsdelen F evalueres, s˚a det bliver klart, hvilken funktion det er, der kaldes.
Lad os tænke os, det er funktionen funktionsnavn med erklæringen (3.1).
3. Argumentdelen A evalueres til en værdi a 1 .
4. Et for et sammenholdes parametermønstrene i (3.1) med værdien a. Lad
parametermønster i være det første, der passer. Dette mønster tilpasses nu værdien,
hvilket indebærer, at mønsterets formelle parametre bindes til bestemte værdier.
5. Med de etablerede bindinger i kraft evalueres krop i til en værdi v.
6. Nu kan parameterbindingerne brydes og den suspenderede beregning genoptages, idet
applikationsudtrykket F A erstattes med værdien v.
Den beskrevne fremgangsm˚ade benyttes helt konsekvent; ogs˚a hvis funktionskaldet for
eksempel selv st˚ar i en funktionskrop. Her er et simpelt eksempel:
fun kvadrat x = x * x;
fun kvadratsum (a,b) = kvadrat a + kvadrat b;
kvadratsum (1+2,4);
Beregningen af kvadratsum (1+2,4) foreg˚ar p˚a følgende m˚ade: Funktionsdelen er allerede
en bestemt funktion (kvadratsum). Argumentdelen evalueres til (3,4). Sammenholdning af
mønsteret (a,b) med (3,4) vil binde a til 3 og b til 4, hvorefter kvadrat a + kvadrat b
skal evalueres. Da første del af dette udtryk p˚any er et funktionskald, m˚a denne beregning
umiddelbart igen suspenderes, for at vi med x bundet til 3 kan evaluere x * x. Det bliver
9, og den suspenderede beregning kan genoptages, idet vi nu skal beregne 9 + kvadrat b.
Det kræver evaluering af kvadrat b, s˚a beregningen m˚a p˚any suspenderes, mens vi med x
bundet til 4 beregner x * x. Resultatet er 16, s˚a den suspenderede beregning kan genoptages
som evaluering af 9 + 16 til det ønskede udtryks værdi 25.
3.3 Virkefelt
N˚ar man i et programmeringssprog kan bruge navne, er det vigtigt at gøre sig klart, hvor
disse navne er lovlige. Man taler om sprogets “virkefeltsregler”, idet man ved virkefeltet
1 At argumentdelen ubetinget evalueres, inden det vides, om kroppen overhovedet skal bruge argumentet,
er et særkende for de programmeringssprog, der som Standard ML siges at være ivrige eller strikse (eng.:eager
eller strict). Sprogene C og Java er ogs˚a strikse.
42

(eng.:scope) for et navn forst˚ar de steder i programmet, det p˚agældende navn kan bruges (i
den p˚agældende betydning).
Hovedreglen i SML er, at navne skal indføres, før de kan bruges. Vi har foreløbigt mødt to
“navneindførende” konstruktioner, nemlig værdierklæringer (med val) og funktionserklæringer
(med fun). Som defineret i Standard ML er formen for en værdierklæring i øvrigt
lidt mere generel end nævnt i afsnit 2.1.3, idet venstre side kan være et generelt mønster.
(Hvordan det kan udnyttes, vil vi komme nærmere ind p˚a i afsnit 4.4.1.)
Værdi- og funktionserklæringer har forskellige virkefeltsregler (og det er netop for at
minde om denne forskel, systemet tvinger os til at bruge to forskellige nøgleord):
En værdierklæring
val mønster = udtryk A ;
Resten af programmet B
indfører de navne, som indg˚ar i mønster og derved bliver til r˚adighed i resten af programmet
B.
Ved en funktionserklæring
fun fnavn m1 = k1 A1
| fnavn m2 = k2 A2
| . . .
| fnavn mn = kn An
Resten af programmet B
forekommer der flere navne. Virkefeltet for de formelle parametre, som indg˚ar i mønsteret
m1 er A1 (det vil sige kroppen k1). For de formelle parametre i m2 er virkefeltet A2, og
s˚a videre frem til de formelle parametre i mn, der har virkefelt An. Virkefeltet for selve
funktionsnavnet fnavn er b˚ade A1, A2, . . . An og resten af programmet B.
3.3.1 Redefinition
Hvert navn bør normalt kun defineres én gang, men det er ikke forbudt at definere et navn
flere gange. Hvis der inde i virkefeltet for et navn p˚any optræder en definition af dette navn,
er reglen, at den nye defnition “skygger” for den gamle, som derved bliver utilgængelig i det
nye virkefelt. Nytten heraf er først og fremmest, at fejl kan rettes med en redefinition (kun
nogle af systemets kvitteringer vises):
val rabatpct = 10;
fun studenterpris bogpris = bogpris + bogpris * rabatpct div 100;
val studenterpris = fn : int -> int
studenterpris 31000 (* øre *);
val it = 34100 : int
(* Hovsa! Rabat skal ikke lægges til, men trækkes fra: *)
fun studenterpris bogpris = bogpris - bogpris * rabatpct div 100;
val studenterpris = fn : int -> int
studenterpris 31000;
val it = 27900 : int
43

I en værdidefinition kan det navn vnavn, man er ved at definere, naturligvis ikke bruges
i det definerende udtryk A, men er der tale om en redefinition, følger det af reglerne, at
vnavn eventuelt kunne bruges i sin gamle betydning.
Her udregnes en pris før og efter en momsnedsættelse p˚a 3%. Redefinitionen, hvor den
nye værdi af navnet defineres ved hjælp af den gamle, er understreget (kun nogle af systemets
kvitteringer vises):
val bogpris = 648.00;
val moms = 0.25;
bogpris + moms * bogpris;
val it = 810.0 : real
val moms = moms - 0.03;
bogpris + moms * bogpris;
val it = 790.56 : real
Denne form for redefinitioner harmonerer d˚arligt med applikativ programmeringsstil og
bør undg˚as.
Advarsel til tilstandsprogrammører
Har man tidligere prøvet at programmere i et tilstandsorienteret sprog, er det vigtigt at
notere sig, at definitioner i SML binder navne til værdier og ikke som i visse andre programmeringssprog
til lagerpladser. Denne udbygning af et af de tidligere eksempler illustrerer
forskellen:
val rabatpct = 10;
fun studenterpris bogpris = bogpris - bogpris * rabatpct div 100;
val studenterpris = fn : int -> int
studenterpris 50000;
val it = 45000 : int
val rabatpct = 12;
50000 - 50000 * rabatpct div 100;
val it = 44000 : int
studenterpris 50000;
val it = 45000 : int
I definitionen af funktionen studenterpris indgik rabatpct, men p˚a det tidspunkt var
konstanten bundet til 10, og studenterpris bindes derfor til den funktion, som trækker
10% fra prisen. Selv om bindingen af rabatpct senere ændres, forandrer det ikke værdien
af studenterpris!
Hvordan skal man da programmere det, hvis studenterprisen ogs˚a afhænger af en (varierende)
rabatprocent?
Svaret er simpelt: At studenterprisen afhænger af rabatprocenten vil med andre ord sige,
at studenterprisen er en funktion af rabatprocenten, og s˚a skal definitionen tage rabatprocent
med som funktionsparameter:
fun studenterpris (bogpris,rabatpct)
= bogpris - bogpris * rabatpct div 100;
44

val studenterpris = fn : int * int -> int
studenterpris (50000,10);
val it = 45000 : int
studenterpris (50000,12);
val it = 44000 : int
3.3.2 Rekursion
Af reglerne i afsnit 3.3 ovenfor fremgik det, at et funktionsnavns virkefelt ogs˚a omfattede
funktionsdefinitionens egen krop. En funktionsdefinition, der i sin egen krop kalder den
funktion, som er ved at blive defineret, siges at være rekursiv. Rekursion giver mulighed
for ulovlige cirkulære definitioner, men skal naturligvis bruges p˚a den m˚ade, at de indre
funktionskald i en eller anden forstand skal være simplere end det kald, hvis værdi man er
ved at definere.
I virkeligheden er forholdene i denne situation, hvor en funktion f defineres ved kald af
funktionen f, ikke spor anderledes, end hvis funktionen f defineres ved kald af en anden
funktion g. Ovenfor blev kvadratsum defineret ved kald af kvadrat, som var en simplere
funktion end kvadratsum. Hvis værdien af f for en vis parameterværdi p fastlægges ud fra
kald af den samme funktion f, skal det naturligvis være kald, hvor argumenterne er simplere
end p. Desuden m˚a der være nogle parameterværdier, de s˚akaldte basistilfælde, for hvilke
værdien af f kan beregnes uden rekursive kald.
N˚ar reglerne for evaluering af funktionskald ovenfor blev gennemg˚aet med s˚a stor omhu,
er det, fordi disse regler fuldstændig uændret ogs˚a dækker tilfældet med rekursive funktionskald.
Eksempel For et ikke-negativt heltal n kan dets bageste ciffer 2 (“eneren”) beregnes som
n mod 10, og de øvrige cifre, efter at det bageste ciffer er fjernet, findes af n div 10.
Ved et tals tværsum forst˚as summen af dets cifre (n˚ar det er skrevet i titalssystemet).
Her er en funktion til beregning af et tals tværsum:
fun tvaersum n
= if n < 10 then n else tvaersum (n div 10) + n mod 10;
val tvaersum = fn : int -> int
tvaersum 79;
val it = 16 : int
Svaret er fundet p˚a følgende m˚ade:
• n bindes til 79.
• I disse omgivelser evalueres kroppen if n < 10 then n else tvaersum (n div 10)
+ n mod 10. Da 79 < 10 er falsk, fører det til tvaersum (n div 10) + n mod 10
med et indledende funktionskald.
2 Begrebsmæssigt bør man skelne mellem et tal, som er det matematiske objekt, og et talord, som er dets
repræsentation, og i steden for “n’s bageste ciffer” burde man sige “sidste ciffer i repræsentationen af n som
decimalt talord”.
45

• n div 10 evalueres til 7, og beregningen suspenderes.
• – n bindes til 7.
– I disse omgivelser evalueres kroppen if n < 10 then n else tvaersum (n div
10) + n mod 10. Da 7 < 10 er sand, fører det til n, som var bundet til 7, hvilket
afslutter den indskudte beregning.
• Den suspenderede beregning (den, hvor n var bundet til 79) kan nu genoptages, idet
7 + n mod 10 nu skal evalueres. Det fører via 7 + 9 til facit 16.
3.4 Navnerum; biblioteksmoduler
Det er vanskeligt at holde styr p˚a de mange navne, som optræder i et program, og det kan
være svært at finde p˚a gode navne, som alle er forskellige. De fleste programmeringssprog
giver derfor mulighed for, at beslægtede navne p˚a en eller anden m˚ade kan holdes sammen
og benævnes med en fælles komponent.
I SML kan værdier samles i moduler; nyttige biblioteksmoduler er blandt andet Char,
Int, List, Math, Mosml, Random, String og TextIO.
For at angive en værdi i et modul benyttes et langt navn med formen
modulnavn.værdinavn
Udvalgte dele af biblioteket fremg˚ar af [5, Appendix D]; en fuldstændig oversigt gives i [15].
Man kan kun f˚a fat i værdier i moduler, der er “hentet ind”. I Mosml er følgende moduler
hentet ind p˚a forh˚and: Array, Char, List, String, TextIO og Vector. Andre moduler hentes
ind ved at skrive
load "modulnavn";
Funktionen, der omsætter alle bogstaver til sm˚a bogstaver, er for eksempel umiddelbart
tilgængelig, mens π og √ først kan bruges, efter at matematikmodulet er hentet ind:
(Char.toLower #"P",Char.toLower #"s");
val it = (#"p", #"s") : char * char
load "Math";
val it = () : unit
fun cirkelareal radius = Math.pi * radius * radius;
val cirkelareal = fn : real -> real
fun cirkelradius areal = Math.sqrt (areal / Math.pi);
val cirkelradius = fn : real -> real
3.5 Typen af heltal
Figur 2.1 viste de p˚a forh˚and ˚abnede standardoperatorer og -funktioner for heltal (typen
int). Ved at hente modulet Int ind
load "Int";
46

f˚ar man adgang til flere nyttige funktioner (se [5, Appendix D.2] eller [15]), af hvilke vi her
blot anfører tre:
navn type virkning
Int.min int * int -> int det mindste af de to tal
Int.max int * int -> int det største af de to tal
Int.toString int -> string tallet fremstillet som decimalt talord
3.5.1 Heltalsdivision
Inden for de hele tal behøver division ikke at g˚a op; n div d er det hele antal gange, d er
indeholdt i n, og n mod d er den tilhørende divisionsrest:
365 div 7;
val it = 52 : int
365 mod 7;
val it = 1 : int
For q = n div d og r = n mod d gælder identisk
n = q · d + r (3.2)
og man vil normalt sørge for at skaffe sig en rest, der er mindre end divisor:
0 ≤ |r| < |d| (3.3)
Hvorledes heltalsdivision skal defineres, hvis dividend eller divisor er negativ, er der ikke
enighed om. Det er klart, at kvotienten q skal findes som en afrunding af den reelle brøk n
d ,
men i afsnit 2.5.1 mødte vi jo hele fire forskellige afrundingsfunktioner!
Standardoperatoren div svarer til afrunding mod minus uendelig, det vil sige
n div d = floor (real n / real d). Resten n mod d fastlægges herudfra, s˚adan at (3.2)
kommer til at gælde. Man kan indse, at det betyder, at divisionsresten altid f˚ar samme fortegn
som divisor:
For eksempel gælder
0 ≤ n mod d < d eller d < n mod d ≤ 0
17 div ~4 = ~5 og 17 mod ~4 = ~3
Undertiden ønsker man, at divisionsresten skal have samme fortegn som dividenden. Det
bliver resultatet, hvis kvotienten i stedet dannes ved afrunding mod nul, og de tilhørende
funktioner er til r˚adighed som Int.quot og Int.rem. Med andre ord gælder Int.quot (n,d)
= trunc (real n / real d) og Int.rem (n,d) = n - Int.quot (n,d) * d, idet man
stadig sørger for at opretholde (3.2).
Eksempel:
Int.quot (17,~4) = ~4 og Int.rem (17,~4) = 1
47

3.5.2 Euklids algoritme
Ligningen (3.2) viser, at hvis et tal g˚ar op i d, vil det ogs˚a g˚a op i n hvis og kun hvis det
ogs˚a g˚ar op i r. Dette forhold benyttede den græske matematiker Eυ ✁ κλε´ιδης (som levede i
Alexandria omkring 300˚ar før vor tidsregning) til at beskrive en effektiv metode til beregning
af to tals største fælles divisor (eller “største fælles m˚al”, som man tidligere sagde).
Lad gcd (a,b) betegne den største fælles divisor for to heltal a og b (eng.:greatest
common divisor). Da alle tal g˚ar op i 0, gælder
gcd (a,0) = |a| for a = 0 (3.4)
mens gcd (0,0) er udefineret. Ud over at være den største fælles divisor for a og b har
gcd (a,b) imidlertid ogs˚a den egenskab at være det (ikke negative) tal, hvis divisorer netop
er de fælles divisorer for a og b. Tager man udgangspunkt i denne egenskab, skal gcd (0,0)
være 0, og gyldigheden af (3.4) kan udvides til alle hele tal a.
Euklids metode er som følger: Lad a og b være to hele tal. Hvis det ene er 0, er deres
største fælles divisor den numeriske værdi af det andet tal. Ellers kan vi antage 0 < |a| ≤ |b|,
og i henhold til (3.2) kan vi i stedet for at opsøge største fælles divisor for a og b løse den
opgave at finde største fælles divisor for b mod a og a, som ifølge (3.3) vil være numerisk
mindre tal:
fun gcd (a,b) = if a = 0 then abs b else gcd (b mod a,a);
val gcd = fn : int * int -> int
gcd (24,15);
val it = 3 : int
(I en opgave spørges der om, hvorfor programmet ikke sørger for at ordne |a| ≤ |b|.)
3.6 Standardundtagelser
At dividere med 0 er ikke matematisk muligt 3 . Forsøger man det i SML
5 mod 0;
! Uncaught exception:
! Div
reagerer systemet med en s˚akaldt undtagelse (eng.:exception). En undtagelse er ikke en
egentlig værdi (standardnavnet it berøres ikke) og kan opfattes som en fejlmelding fra
systemet. Hvis et deludtryk resulterer i en undtagelse (eller “rejser en undtagelse” eller
“kaster en undtagelse”, som man ogs˚a siger), afbrydes beregningerne med melding om denne
undtagelse.
Matematiske funktioner kan kaste undtagelsen Domain:
load "Math";
val it = () : unit
Math.sqrt ~1.0;
! Uncaught exception:
! Domain
3 a
Grunden til forbuddet mod division med 0 er jo, at uanset hvilken værdi man ville tillægge 0
sædvanlige regneregler ikke kunne opretholdes, herunder først og fremmest, at a
b · b = a.
48
, ville de

3.6.1 Ikke-udtømmende parametermønstre
Vi har mødt endnu en konstruktion, som kan give anledning til fejlmeldinger. I den udvidede
form for funktionsdefinition (3.1) bør man tilstræbe at klassedele de mulige parameterværdier.
Reaktionen p˚a overlappende mønstre var som nævnt, at det første, der passede, blev
benyttet.
Hvis mønstrene ikke udtømmer (eng.:exhaust) alle muligheder, udsteder systemet i første
omgang en advarsel:
fun klokken 0 = "midnat"
| klokken 12 = "middag"
! Toplevel input:
! ....klokken 0 = "midnat"
! | klokken 12 = "middag".
! Warning: pattern matching is not exhaustive
val klokken = fn : int -> string
Ikke-udtømmende parametermønstre behøver ikke at være en fejl — programmets logik
kunne jo være s˚adan, at der aldrig blev brug for de manglende tilfælde — men hvis intet
mønster passer, kastes undtagelsen Match:
klokken 24;
! Uncaught exception:
! Match
3.6.2 Overløb
Mængden Z af alle hele tal har uendeligt mange elementer, men maskinens model af dem,
som her er typen int, kan naturligvis kun være endelig. Nogle programmeringssprog kan
regne eksakt med meget store hele tal, idet det accepteres, at heltalsord kan fylde en
varierende del af lageret, men i Moscow ML har man valgt, at heltal kun m˚a fylde
31 bit. Der er derfor 2 31 forskellige heltalsord, med værdier fra −2 30 = −1073741824 til
2 30 − 1 = 1073741823. Beregninger, der fører ud over dette interval, siges at “løbe over” eller
“give overløb” og rejser undtagelsen Overflow:
val toi10 = 1024;
val toi10 = 1024 : int
~ toi10 * toi10 * toi10;
val it = ~1073741824 : int
it - 1;
! Uncaught exception:
! Overflow
val stoerste = ~1 - it;
val stoerste = 1073741823 : int
stoerste + 1;
! Uncaught exception:
! Overflow
49

Muligheden for overløb betyder, at mange af de sædvanlige matematiske omskrivningsregler
mister deres gyldighed. Man kan for eksempel ikke være sikker p˚a, at
~ (1 + stoerste);
! Uncaught exception:
! Overflow
~1 - stoerste;
val it = ~1073741824 : int
− (a + b) = − a − b
3.7 Typen af sandhedsværdier
Den vigtigste anvendelse af udtryk af logisk type har vi allerede mødt flere gange, nemlig
som betingelser, placeret mellem if og then i et valgudtryk.
3.7.1 Striks eller efterladende strategi?
I
if betingelse then mulighed else alternativ
vil betingelsen altid blive evalueret, men styret af dens værdi vil derefter kun det ene af
udtrykkene mulighed og alternativ blive evalueret.
Selv om et valgudtryk har tre ˚abne pladser, afviger det herved fra en funktion med tre
argumenter. Man kunne godt definere en tilsvarende funktion if then else , men ingen
funktion kan erstatte brugen af valgudtryk:
fun if then else (i,t,e) = if i then t else e;
val ’a if then else = fn : bool * ’a * ’a -> ’a
fun gcd’ (a,b) = if then else (a = 0,abs b,gcd’ (b mod a,a));
val gcd’ = fn : int * int -> int
gcd’ (2,4);
! Uncaught exception:
! Div
(Typevariablen ’a i systemets svar forklares i det senere afsnit 4.5.)
Vi kopierede jo blot definitionen af gcd fra afsnit 3.5.2, s˚a hvad er dog g˚aet galt?
Som nævnt i afsnit 3.2 udregnes funktionskald p˚a den m˚ade, at de aktuelle argumenter
evalueres, for at man kan etablere de bindinger, der skal være i kraft under udregning af
funktionskroppen.
Helt konkret kræver gcd’ (2,4), at man først evaluerer
• 2 = 0 (værdi false),
• abs 4 (værdi 4) og
• gcd’ (4 mod 2,2).
Beregningen af gcd’ (2,4) m˚a derfor suspenderes, indtil man har f˚aet beregnet gcd’
(0,2), hvilket igen kræver evaluering af
• 0 = 0 (værdi true),
50

• abs 2 (værdi 2) og
• gcd’ (2 mod 0,0).
Men her sker den division med nul, som fejlmeldes!
At de aktuelle argumenter altid evalueres, beskriver man ved at sige, at ML har striks
eller ivrig (eng.:strict eller eager) parameteroverføring. Alternativet, hvor argumenterne
overføres som uevaluerede udtryk (og som blandt andet benyttes i funktionsprogrammeringssprogene
Miranda og Haskell), kaldes efterladende (eng.:lenient eller non-strict)
parameteroverføring.
Valgkonstruktionen if betingelse then mulighed else alternativ er kun striks i betingelsen,
men efterladende i de to andre deludtryk.
3.7.2 Betingelse som skildvagt
I den korrekte gcd-funktion er det tydeligt, hvordan deludtrykket
if a = 0 then abs b else gcd (b mod a,a)
forhindrer, at der nogen sinde kan blive divideret med 0: “b mod a” evalueres kun, hvis “a
= 0” ikke var sand. Man kan sige, at “a = 0” her st˚ar som en slags “skildvagt”, der sikrer
mod division med 0.
Denne brug af udtryk af logisk type: som skildvagter, der vogter mod ulovlige deludtryk,
er meget almindelig.
3.7.3 Konjunktion og disjunktion
Oversigten 2.1 over operatorer og funktioner viste, at negation (der i matematik ofte noteres
som en overstregning eller med symbolet ¬) fandtes i ML under navnet not. Derimod viste
figuren ikke de to andre almindelige logiske operationer konjunktion (logisk “og”, ofte noteret
∧ eller &) og disjunktion (logisk “eller”, noteret ∨ eller |).
Konjunktion og disjunktion er i SML sekventielle, det vil sige kun strikse i første operand,
og kan derfor ikke opfattes som funktioner. For at man kan blive mindet om, at de evalueres
sekventielt, har man ogs˚a valgt omstændelige navne til disse operationer i SML: konjunktion
skal skrives andalso 4 og disjunktion orelse.
a andalso b er kun sand, hvis b˚ade a og b er sande, men hvis a er falsk, bliver b slet
ikke evalueret; p˚a samme m˚ade er a orelse b kun falsk, hvis b˚ade a og b er falske, men
hvis a er sand, bliver b ikke evalueret. Man kan sige, at
a andalso b evalueres som if a then b else false
a orelse b evalueres som if a then true else b
Eksempel Lad os kontrollere, om de tre variable (aar,maaned,dag) angiver en korrekt
dato, det vil sige om m˚aneden ligger mellem 1 og 12, og om dagen ligger mellem 1 og
m˚anedens længde (systemsvarene vises ikke):
4 Faktisk findes and ogs˚a som reserveret ord, men det bruges til parallelle definitioner.
51

val skudaar
= if aar mod 100 = 0
then aar mod 400 = 0
else aar mod 4 = 0;
val maanedslgd
= if maaned = 2
then if skudaar then 29 else 28
else if maaned = 4 orelse maaned = 6
orelse maaned = 9 orelse maaned = 11
then 30 else 31;
1

større end for heltal, men det er stadig begrænset: Der findes en største og en mindste værdi
af type real, og overskridelse af talomr˚adet giver (ligesom for heltal) overløb (her forsøges
beregning af 101010): load "Math";
val it = () : unit
Math.pow (10.0,10.0);
val it = 10000000000.0 : real
Math.pow (10.0,it);
! Uncaught exception:
! Overflow
Hertil kommer en anden defekt: I maskinens model af de reelle tal ligger værdierne ikke
uendelig tæt; fra et maskintal er der en vis endelig afstand hen til det nærmeste større og
det nærmeste mindre maskintal. Regneoperationer kan derfor ikke altid udføres eksakt, men
kan indebære afrundingsfejl. N˚ar det drejer sig om typen real, kan systemet med andre ord
komme til at “regne forkert”. At lægge beregninger til rette, s˚a afrundingsfejl kun f˚ar ringe
betydning, behandles i det selvstændige fagomr˚ade numerisk analyse.
Afrundingsfejl er mere problematiske end de andre fejl, vi hidtil har mødt (for eksempel
division med nul), fordi man ikke af resultatet kan se, at der er noget galt. I disse noter vil
vi ikke gøre mere ud af emnet, men problemet kan illustreres med et lille eksempel, hvor
man f˚ar to forskellige resultater ud af at beregne det samme udtryk p˚a to forskellige m˚ader:
val lilletal = Math.pow (2.0,~53.0);
val lilletal = 1.11022302463E~16 : real
1.0 - 1.0 + lilletal;
val it = 1.11022302463E~16 : real
1.0 + lilletal - 1.0;
val it = 0.0 : real
3.8.2 Typerne af tegn og tekster
I vores brug af SML vil data til og fra programmer i sidste ende være tekster opbygget af
tegn. Hvis man selv vil styre formaterne for ind- og uddata, er det derfor vigtigt at kunne
manipulere med værdier af typerne string og char. Da tekster er nært beslægtede med
lister af tegn, udskydes detaljerne om disse typer imidlertid til efter indføring af typen af
lister.
3.9 Overlæssede symboler
Man kan undre sig over typen i systemets svar p˚a definitionen
fun sum (a,b) = a + b;
val sum = fn : int * int -> int
eftersom mange af eksemplerne ovenfor brugte “+” til addition af værdier af type real.
Forklaringen er, at symbolet “+” i SML i virkeligheden st˚ar for to forskellige operatorer
53

(to forskellige funktioner med infiks-status), idet op + b˚ade har type int * int -> int og
type real * real -> real. Hvis den rigtige funktion fremg˚ar entydigt af sammenhængen,
bruger systemet den, men hvis ikke 5 , formodes man at ønske den variant, der bruger
heltallige operander og har et heltalligt resultat.
Et symbol, der p˚a den m˚ade har flere betydninger, siges at være overlæsset (eng.:overloaded).
For subtraktion og multiplikation er forholdet det samme, idet ogs˚a “-” og “*” b˚ade
kan bruges mellem heltallige operander og give et heltalligt resultat og mellem operander
af type real med et resultat af type real. Hertil kommer for “*”, som vi har set, tillige en
tredje betydning som kartesisk produkt af typer. (Denne sidste brug af symbolet kan altid
skelnes fra de andre, idet det vil være klart, om “*” er placeret mellem værdier eller mellem
typer.)
Der er yderligere tre grupper af overlæssede symboler:
Funktionerne “abs” og “~”, som blev brugt i de indledende eksempler, har b˚ade type
int -> int og type real -> real. Desuden kan “~” som nævnt indg˚a i negative talkonstanter.
De fire ordningsoperatorer “=” kan b˚ade bruges p˚a typerne int, real,
char og string.
Lighedsoperatorerne “=” og “” kan bruges p˚a alle s˚akaldte “lighedstyper”, hvilket groft
sagt vil sige alle typer, der ikke indeholder funktioner.
Ogs˚a for “abs”, “~”, de fire ordninger samt “=” og “” gælder, at hvis typen ikke
fremg˚ar af sammenhængen, falder SML tilbage p˚a heltalsudgaven.
Man kan ikke selv definere nye overlæssede symboler.
3.9.1 Typebegrænsning
Hvis man i stedet for et udtryk u skriver u : τ, hvor τ er en type, tvinges udtrykket til at
have type τ (og reglerne for typeudledning kan betyde, at typekravet forplanter sig videre
til andre deludtryk). Med denne konstruktion (en “typebegrænsning”, (eng.:type constraint
eller type cast)) kan man omg˚a den underforst˚aede heltalstype. Hver af linjerne nedenfor vil
definere en funktion til addition af to reelle tal:
fun sumr (a : real,b) = a + b;
fun sumr (a,b) : real = a + b;
fun sumr (a,b) = a + (b : real);
fun sumr (a,b) = a + b : real;
3.10 Definitionen af Standard ML
Programmer i et højere programmeringssprog bør (som nævnt i afsnit 1.5.3) med uændret
effekt kunne flyttes mellem forskellige implementerende systemer. En betingelse for, at det
kan lade sig gøre, er imidlertid, at programmeringssproget er s˚a præcist defineret, at der ikke
kan herske tvivl om, hvilke sprogkonstruktioner der er lovlige, og hvorledes de skal virke.
5 Dette er en af nyhederne i SML97 [9] i forhold til SML90 [7].
54

Antallet af programmeringssprog er meget stort, og langt de fleste af dem er ikke fastlagt
mere præcist, end at der har været mulighed for at fortolke definitionen p˚a forskellige m˚ader,
s˚adan at sprogets implementationer realiserer forskellige “dialekter”.
Standard ML indtager en særstilling i denne henseende; ved at bruge en stringent matematisk
notation sikrer det definerende dokument [9] en usædvanlig grad af entydighed.
3.10.1 Skandering i grundsymboler
ML er defineret med henblik p˚a, at programmer skal kunne skrives med tegnene fra ASCII
(se afsnit 1.7.1). De 94 ikke-blanke grafiske tegn fra dette alfabet grupperes s˚aledes:
bogstav a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
ciffer 0 1 2 3 4 5 6 7 8 9
alfanum.tegn ’ bogstav ciffer
navnetegn ! # $ % & * + - / : < = > ? @ \ ^ ‘ | ~
specialtegn , ; . "( ) [ ] { }
Der skelnes mellem sm˚a og store bogstaver, men læg mærke til, at de danske æ, ø, ˚a, Æ, Ø
og ˚A ikke regnes med. Ud over de viste tegn kan man i programmer bruge blanktegn (kode
32), tabuleringstegn (kode 9) og linjeskift (kode 10); desuden kan kommentarer (se 3.10.1)
samt tekst- og tegnkonstanter (se afsnit 7.1 nedenfor) i mosml indeholde andre tegn med
koder mellem 0 og 255.
Som nævnt samles enkelttegn til grundsymboler, og dem er der fire arter af: reserverede
ord, typevariable, navne og konstanter.
Reserverede ord
De reserverede ord udgøres i mosml af følgende 58 enkelttegn eller følger af tegn. Intet af
dem (med undtagelse af “=”) m˚a bruges som navn:
abstype and andalso as case do datatype else end eqtype exception
fn fun functor handle if in include infix infixr let local nonfix
of op open orelse raise rec sharing sig signature struct structure
then type val where with withtype while : :> | = => -> # , ; ...
( ) [ ] { }
Typevariable
Reserverede ord i mosml
En typevariabel er en apostrof efterfulgt af et eller flere alfanumeriske tegn, for eksempel:
’a. Vi vil først møde typevariable i kapitel 4 nedenfor.
Navne
De to former for navne, alfanumeriske og symbolske, blev forklaret i afsnit 2.4.1 ovenfor.
De reserverede ord er ikke med i klassen af navne; mens es, ## og |=| s˚aledes er navne,
er as, # og | det ikke.
55

Konstanter
I mosml er der fem former for konstanter: Heltalskonstanter, flydende talkonstanter, tekstkonstanter,
tegnkonstanter og ordkonstanter.
Konstanter for hele og brudne tal blev forklaret i afsnit 2.5.1.
Tekstkonstanter og tegnkonstanter behandles i afsnit 7.1 nedenfor.
Ordkonstanter skal ikke benyttes p˚a dette kursus (se [14]).
Kommentarer
Selv om programmer skrives for at blive fortolket af maskiner, bliver de til i et konstruktionsforløb
med stadige rettelser og udbygninger, hvorunder de i høj grad ogs˚a læses af
mennesker, og et program skal ikke være ret langt, før det bør suppleres med forklaringer.
At f˚a et program i hænde, man skrev for ˚ar eller blot f˚a m˚aneder siden, er en lærerig oplevelse:
det er forbavsende, hvor lang tid det tager at komme ind i de gamle tankebaner og
igen forst˚a, hvad der, dengang man konstruerede programmet, syntes s˚a oplagt.
Et program skal derfor ikke være særlig omfattende, før det kan betale sig at forsyne
det med kommentarer. I ML benyttes to-tegns-symbolerne “(*” og “*)” til henholdsvis at
indlede og afslutte en kommentar, og imellem disse to symboler kan man skrive hvad som
helst — tegn fra og med “(*” og til og med “*)” vil blive oversprunget, n˚ar ML skal fortolke
et program.
Beskrivelsen af, hvad der er en kommentar, er ikke helt præcis; her er en nøjagtig forklaring:
Lad os bruge betegnelsen kommentarsymbol om enten en kommentar eller en følge af
nul eller flere tegn, der ikke indeholder noget af symbolerne “(*” eller “*)”. En kommentar
er da en vilk˚arlig følge af (nul eller flere) kommentarsymboler indesluttet mellem symbolerne
“(*” og “*)”.
˚Arsagen til denne omstændelige definition er, at ved siden af at give mulighed for indsættelse
af forklaringer er der ogs˚a er en anden nyttig anvendelse af kommentarer:
Skal man finde ud af, hvor i et program en fejl befinder sig, kan der være brug for at sætte
dele af et program ud af kraft. Direkte at slette de p˚agældende dele er ikke attraktivt, for
man risikerer senere møjsommeligt at skulle indtaste dem igen. Her kan man benytte sig af,
at programdele fra “(*” til “*)” overspringes: det, som ønskes sat ud af kraft, “kommenteres
ud” ved at blive omgivet af symbolerne “(*” og “*)”, der let igen senere kan fjernes. Den
s˚aledes indesluttede programtekst kunne imidlertid selv indeholde kommentarer, og hvis reglen
blot var, at en kommentar sluttede, s˚a snart systemet mødte symbolet “*)”, ville det g˚a
galt. Derfor forlanges det, at “(*” og “*)” skal danne en korrekt indlejret parentesstruktur.
Opstilling
De enkelte tegn i et grundsymbol skal følge lige efter hinanden, men bortset herfra kan MLprogrammer
stilles helt frit op p˚a linjerne: mellem grundsymboler kan man sætte vilk˚arlige
følger af blanktegn, tabuleringstegn, linjeskift og kommentarer.
Reglen er, at hvert grundsymbol strækker sig s˚a langt mod højre, som det er muligt i
henhold til beskrivelserne ovenfor. Hvis to p˚a hinanden følgende grundsymboler kan læses
som ét grundsymbol, m˚a de alts˚a adskilles af blanktegn, tabuleringstegn, linjeskift eller
kommentar.
56

3.10.2 Gruppering i syntaktiske helheder
Som nævnt i afsnit 2.4 grupperes grundsymbolerne i større helheder. Til beskrivelse af syntaksen
for SML benyttes en ret suggestiv formel grammatik, der er en variant af den s˚akaldte
“Backus-Naur-form” (forkortet BNF 6 ), som blev brugt i rapporten om programmeringssproget
Algol 60.
Grammatikken definerer nogle forskellige syntaktiske klasser, blandt andet udtryk exp,
infiks-udtryk infexp, typer ty, alternativer match og alternativ mrule.
Hver syntaktisk klasse defineres i en eller flere linjer, som angiver de forskellige mulige
udformninger af den klasses elementer. En lille del af grammatikken gengives i tabel 3.1,
der viser definitionerne af exp 7 og match. Mange af de viste konstruktioner har endnu ikke
været behandlet; vi vil møde dem senere.
exp ::= infexp
exp : ty typebegrænsning
exp 1 andalso exp 2 konjunktion
exp 1 orelse exp 2 disjunktion
exp handle match gribning af undtagelse
raise exp kast af undtagelse
if exp 1 then exp 2 else exp 3 binært valg
case exp of match flerdelt valg
fn match funktion
match ::= mrule 〈 | match〉
Tabel 3.1: En lille del af syntaksen for udtryk i Standard ML
Tekst med skrivemaskinetype skal anføres bogstaveligt; kursiverede navne er syntaktiske
klasser, som grammatikken definerer. Dele i vinkelparenteser 〈. . .〉 kan medtages eller
udelades. Den rækkefølge, mulighederne anføres i, har betydning, idet de først anførte binder
stærkest. Grammatikken viser derfor, at konjunktion binder stærkere end disjunktion; i
udtrykket
a orelse b andalso c
er parentesen underforst˚aet omkring konjunktionen:
a orelse (b andalso c)
Mere om definitionen af Standard ML kan findes i [5, Appendix B].
3.11 Sammenfatning
Funktionsdefinitioner kan bruge flere parametermønstre; de forskellige tilfælde adskilles da
af en lodret streg. Mønstrenes variable har kun deres eget tilfælde som virkefelt; funktionsnavnet
har alle mulighederne samt resten af programmet som virkefelt; et navn, der defineres
med val, har resten af programmet som virkefelt.
6 oprindeligt en forkortelse for “Backus normalform”.
7 En enkelt mulighed (iteration), som hører til den imperative del af sproget, er udeladt her.
57

Division med nul, argumenter uden for definitionsomr˚adet og overløb afbryder udførelsen
med besked om en “undtagelse”.
Logisk konjunktion og disjunktion er i SML ikke funktioner eller operatorer, men sekventielle
og hedder andalso og orelse.
Regning med reelle tal giver risiko for afrundingsfejl.
Overlæssede funktioner og operatorer bruger hel type, hvis konteksten ikke p˚atrykker
andet. Det kan ændres med en typebegrænsning.
Tvivl om sprogkonstruktioner afklares fuldstændigt af sprogets formelle definition.
3.12 Opgaver
Opgave 3.1 Skriv en funktion, som finder ud af, om et naturligt tal n indeholder cifferet
“5”. (Mere præcist: . . . som for en parameter n : int finder ud af, om “5” ville indg˚a, hvis
n blev skrevet som talord i titalssystemet.)
Opgave 3.2 Definer funktionen pythagoras : real * real * real -> bool, som undersøger,
om tre tal kan være sidelængder i en retvinklet trekant. Der kan ikke forudsættes
nogen bestemt ordning af tallene; man kan alts˚a ikke vide, hvilket af de tre tal der (i givet
fald) er hypotenusen.
Opgave 3.3 Ved en matrix forst˚as en rektangulær opstilling af elementer. Hvis opstillingen
(for to positive hele tal m og n) har m rækker og n søjler, taler man om en m × n-matrix.
Tallene m og n kan være ens, og s˚a er matricen kvadratisk, men de behøver ikke at være det.
Matricen indeholder alts˚a mn elementer, og det er almindeligt at give elementerne to
indices: det første for nummeret p˚a den række og det andet for nummeret p˚a den søjle,
elementet st˚ar i. Det j-te element i den i-te række noteres derfor ai,j eller blot aij.
I første del af denne opgave vil vi g˚a ud fra, rækker og søjler er nummereret startende
med 0, s˚a matricen kommer til at se s˚aledes ud:
⎧
n
⎧
j
⎪⎨
a0,0 . . . a0,j−1 a0,j . . . a0,n−1
i .
. .
.
⎪⎨
ai−1,0 . . . ai−1,j−1 ai−1,j . . . ai−1,n−1
m ⎪⎩
⎪⎩
ai,0 . . . ai,j−1
.
am−1,0 . . . am−1,j−1
.
ai,j
.
am−1,j
. . .
. ..
. . .
ai,n−1
.
am−1,n−1
Fordelen ved at begynde nummerering med 0 er, at der da kommer til at gælde den simple
lovmæssighed, at der for ethvert naturligt tal k netop g˚ar k elementer forud for elementet
med indeks k.
58

Hvis elementerne i en matrix skal opstilles lineært, er det almindeligt at benytte enten
rækkevis eller søjlevis udlægning. Lagt ud række for række bliver den viste matrix til (oven
over nogle af elementerne vises deres løbenummer mellem 0 og mn − 1):
0 . . . j − 1 j . . . n − 1 n . . . (i − 1)n . . . . . . in − 1
. . .
a0,0 . . . a0,j−1 a0,j . . . a0,n−1 a1,0 . . . ai−1,0 . . . ai−1,j−1 ai−1,j . . . ai−1,n−1
in . . . . . . (i + 1)n . . . (m − 1)n . . . . . . mn − 1
. . .
ai,0 . . . ai,j−1 ai,j . . . ai,n−1 ai+1,0 . . . am−1,0 . . . am−1,j−1 am−1,j . . . am−1,n−1
mens søjlevis udlægning naturligvis betyder, at elementerne kommer i rækkefølgen
0 . . . i − 1 i . . . m − 1 m . . . (j − 1)m . . . . . . jm − 1
. . .
a0,0 . . . ai−1,0 ai,0 . . . am−1,0 a0,1 . . . a0,j−1 . . . ai−1,j−1 ai,j−1 . . . am−1,j−1
jm . . . . . . (j + 1)m . . . (n − 1)m . . . . . . mn − 1
. . .
a0,j . . . ai−1,j ai,j . . . am−1,j a0,j+1 . . . a0,n−1 . . . ai−1,n−1 ai,n−1 . . . am−1,n−1
Skriv en funktion, som ud fra antallet af rækker og søjler og et elements nummer i
den rækkevise udlægning beregner, hvilket nummer det samme element vil have i søjlevis
udlægning.
a11 a12 . . . a1n
a21 a22 . . . a2n
.
.
. ..
am1 am2 . . . amn
En matrix med mn elementer i m rækker og n søjler
a11 a12 . . . a1n a21 a22 . . . a2n . . . . . . am1 am2 . . . amn
Elementerne udlagt rækkevis
a11 a21 . . . am1 a12 a22 . . . am2 . . . . . . a1n a2n . . . amn
Elementerne udlagt søjlevis
Løs derefter samme opgave, hvor nummereringen begynder med 1 (se figuren).
Opgave 3.4 Funktionen gcd (afsnit 3.5.2) følger ikke helt Euklids algoritme som beskrevet
i teksten; blandt andet sørges der ikke for at ordne parametrene, s˚a |a| ≤ |b|. Hvorfor er det
ikke nødvendigt?
Opgave 3.5 Største fælles divisor for to tal a og b har følgende egenskaber (hvor der først
og fremmest skelnes imellem, om tallene er lige eller ulige). For nemheds skyld vil vi her
59
.

antage, at hverken a eller b er negativt:
gcd(a, 0) = a og tilsvarende, hvis det er a, som er 0
gcd(a, b) = 2 · gcd( a
gcd(a, b) =
b , ) 2 2
gcd(
hvis a og b begge er lige
a,
b) 2 hvis a er lige og b ulige (og tilsvarende, hvis
det omvendt er a, der er ulige, og b er lige)
gcd(a, b) = gcd(a − b, b) hvis b˚ade a og b er ulige, og a ≥ b. (Tilsvarende,
hvis de begge er ulige, og b ≥ a)
Programmer den s˚akaldte binære gcd-funktion, der bygger p˚a de nævnte egenskaber.
Opgave 3.6 Definer den faldende potensfunktion, for hvilken
i SML.
(a) Definitionen kan benytte egenskaberne
x n = x · (x − 1) · · · (x − n + 1)
n
x 0 = 1
x n = x · (x − 1) n−1 for n > 0
Det er klart, at n skal være af hel type. Indret definitionen, s˚a x f˚ar reel type.
(b) Udvid den faldende potensfunktion til negative hele eksponenter via definitionen
x −n = 1
(x+n) n = 1
(x+1)···(x+n) for n > 0
Opgave 3.7 Omform disse udtryk til en mere hensigtsmæssig form:
if not a then b else true;
if n mod 2 0 then false else if n mod 3 0 then false else true;
Opgave 3.8 Argumenter for, at under evaluering af de to udtryk
a andalso (b andalso c)
og
(a andalso b) andalso c
udløses de samme beregninger. (Husk at medtage muligheden for, at a, b eller c kunne g˚a
i uendelig løkke.) Udled heraf, at de to udtryk altid har samme værdi (alts˚a at sekventiel
konjunktion er associativ).
Analogt for sekventiel disjunktion.
60

Kapitel 4
Produkttype. Terminering. Blokke
4.1 Strukturerede typer
I ML er der en række grundtyper (for eksempel int og bool) og en række m˚ader at danne
nye typer p˚a ud fra eksisterende typer (for eksempel funktionstypen τ -> τ ′ ud fra τ og τ ′ ).
Tabel 4.1 viser de former for typer, vi vil bruge i dette kursus. (En fuldstændig oversigt
kan ses i [5, Appendix B] eller [7, 9, 12, 14].) Et par af typerne skal vi først møde senere,
men for overskuelighedens skyld er de taget med i tabellen.
ty ::= unit enhedstypen
bool sandhedsværdi
order sammenligningsresultat
int heltalsord
real flydende talord
char tegn
string tekst
tyvar typevariabel
ty list liste
ty 1 * ty 2 * . . . * ty n
sæt (n ≥ 2)
ty -> ty ′ funktion
( ty )
Tabel 4.1: Forenklet syntaks for typer i ML.
Som nedskrevet er syntaksen ikke entydig, men flertydighederne løses ved at give konstruktionerne
prioritet i den rækkefølge, de st˚ar i tabellen, s˚aledes at tidligere konstruktioner
har forrang frem for senere. Desuden lader man operatorsymbolet “->” for funktionstypekonstruktion
associere fra højre. (Hvad dette nærmere indebærer, vender vi tilbage til i
kapitel 6.)
4.2 Sæt
En af typekonstruktionerne danner par, tripler, kvadrupler og s˚a videre, n-sæt for vilk˚arligt
n = 2, 3, 4, . . .: Hvis u1 er et udtryk af type τ1, u2 et udtryk af type τ2, . . . , un et udtryk af
61

type τn, betegner (u1,u2,. . .,un) sættet (eng.:tuple) af de n udtryks værdier, og typen af
dette sæt betegnes τ1 * τ2 * . . . * τn.
Som typekonstruktør er asterisk ikke associativ: Der skelnes mellem triplet (1,2,3) af
type int * int * int, parret (1,(2,3)) af type int * (int * int) og parret ((1,2),3)
af type (int * int) * int.
Alle funktioner er af én variabel I tidligere eksempler har vi defineret funktioner “af
flere variable”, for eksempel i afsnit 2.3.3 funktionerne gaar op i : int * int -> bool
og gnsnt : real * real * real -> real og i afsnit 3.5 omtaltes biblioteksfunktionen
Int.min : int * int -> int. Vi ved nu, at disse funktioners typer skal grupperes henholdsvis
(int * int) -> bool, (real * real * real) -> real og (int * int) -> int.
Der er med andre ord “i virkeligheden” ikke tale om funktioner af flere variable, men om
funktioner af ét argument, hvor dette argument er et sæt (i eksemplerne: et par eller et
tripel).
At det forholder sig s˚adan, kommer frem i dette eksempel:
val femtenfem = (15,5);
val femtenfem = (15, 5) : int * int
gaar op i femtenfem;
val it = false : int
Int.min femtenfem;
val it = 5 : int
I definitionerne af gaar op i og af gnsnt er der p˚a venstre side af lighedstegnet som
mønster brugt et par og et tripel. Ved kald af disse funktioner er virkningen da (som nævnt
i afsnit 3.2), at argumentets aktuelle værdi tilpasses dette mønster, hvorved man kan bestemme,
hvilke værdier de formelle parametre skal bindes til i funktionens krop.
Her er en udbygning af eksemplet:
fun divmod (n,d) = (n div d,n mod d);
val divmod = fn : int * int -> int * int
divmod femtenfem
val it = (3,0) : int * int
gaar op i (divmod femtenfem);
val it = true : bool
4.2.1 Enhedstypen
Typen bool havde to egentlige værdier, og som et udartet tilfælde er der i ML ogs˚a defineret
en type, der kun har én egentlig værdi. Typen betegnes unit, og dens værdi skrives som et
“tomt sæt”: ().
I en type med kun én mulig værdi ligger naturligvis ingen information, men unit bruges
i ML i de tilfælde, hvor man har brug for andre systemaktiviteter end at f˚a evalueret et
udtryk til en værdi.
Brugere af Moscow ML vil allerede have mødt et eksempel herp˚a, nemlig i den funktion,
der kaldes, n˚ar man vil forlade systemet:
62

quit;
val it = fn : unit -> unit
quit ();
$ >
Et andet eksempel er systemfunktionen load til indhentning af biblioteksmoduler som
nævnt i afsnit 3.4. Som parameter skal den have navnet p˚a det modul, der skal hentes, men
selve funktionsværdien skal ikke bruges; det er funktionens “bivirkning” p˚a navnerummet,
man har glæde af. Det forklarer funktionens type:
load;
val it = fn : string -> unit
4.3 Komponentvalg
De eneste operationer, der fra systemets side er defineret p˚a sæt, er projektionsfunktionerne
#1, #2, #3, . . . , der er specielle tilfælde af Standard MLs feltvalg (eng.:record-selectors).
Virkningen af #n er simpelt hen at udvælge den n-te komponent af et sæt (idet nummerering
begynder med 1). Vi fortsætter eksemplet fra før:
femtenfem;
val it = (15,5) : int * int
#1 femtenfem;
val it = 15 : int
#2 femtenfem;
val it = 5 : int
#3 femtenfem;
! Toplevel input:
! #3 femtenfem;
! ^^^^^^^^^
! Type clash: expression of type
! int * int
! cannot have type
! {1 : int, 2 : int, 3 : ’a, ...}
! because record label 3 is missing
Forsøg p˚a at udvælge en komponent med større nummer end sættets længde er naturligvis
en fejl. N˚ar den melding, man f˚ar om fejlen, kan forekomme lidt kryptisk, hænger det sammen
med, at sæt i ML opfattes som specialtilfælde af en mere generel konstruktion af poststrukturer
(eng.:records), som vi ikke her vil komme nærmere ind p˚a.
NB Læg mærke til, at der efter nummertegnet skal skrives en konstant. Man kan alts˚a ikke
beregne sig frem til, hvilken komponent man vil bruge: beslutningen træffes, n˚ar et program
skrives ned.
63

4.3.1 Projektionsfunktionerne
I forhold til andre funktioner indtager projektionsfunktionerne #1, #2, #3, . . . en særstilling;
man kan ikke anføre dem helt isoleret:
#1;
! Toplevel input:
! #1;
! ^^
! Unresolved record pattern
Problemet er, at man ikke af en projektionsfunktion kan se, hvor langt et sæt den skal
vælge fra. Da sæt af forskellig længde har forskellig type, kan systemet ikke bestemme typen
af udtrykket, og det giver en fejlmelding.
Definerer man selv sine projektionsfunktioner, opst˚ar problemet ikke:
fun fst2 (x,y) = x;
val (’a, ’b) fst2 = fn : ’a * ’b -> ’a
fst2;
val (’a, ’b) it = fn : ’a * ’b -> ’a
(4.1)
At den definerede funktion fst2 kan anvendes p˚a et hvilketsomhelst par, viser sig ved,
at der forekommer typevariable i den af systemet udledte type. Udtryk, i hvis type der
forekommer typevariable, siges at være polymorfe (egentlig fra græsk: af flere former). Vi vil
have mere at sige om polymorfi i afsnit 4.5 nedenfor.
I konkrete anvendelser fst2 x kan x have en hvilken som helst partype — for eksempel
int * int, bool * int, (int * int) * int eller (bool -> int) * bool
En anden mulighed for at undg˚a fejlmeldingen “Unresolved record pattern” er med
den konstruktion
exp : type
der i afsnit 3.9.1 blev kaldt en “type-begrænsning”, at informere systemet om, hvilken type
det drejer sig om:
#1 : ’foerste * ’anden -> ’foerste;
val (’foerste, ’anden) it = fn : ’foerste * ’anden -> ’foerste
#1 : int * bool -> int;
val it = fn : int * bool -> int
En typebegrænsning kan lægges p˚a hele udtrykket eller p˚a deludtryk, og det er ofte
tilstrækkeligt at indføre en begrænsning et enkelt sted — resten kan systemet udlede:
fun fst2 (x,y) = x : int;
val ’a fst2 = fn : int * ’a -> int
64

Sætmønster eller projektioner?
Om man vil bruge et sætmønster som parameter eller foretrækker at indsætte de nødvendige
projektioner, er et spørgsm˚al om programmeringsstil; man skal naturligvis bruge den notation,
som forekommer klarest. Her er flere forskellige udgaver af en funktion, der viser et
klokkeslæt som timer og minutter:
fun visKlokken (t,m)
= Int.toString t ^ "timer og "^ Int.toString m ^ "minutter";
val visKlokken = fn : int * int -> string
Bruges projektionsfunktioner, skal længden af sættet p˚a en eller anden m˚ade fremg˚a. Her
er to muligheder:
fun visKlokken (kl : int * int)
= Int.toString (#1 kl) ^ "timer og "
^ Int.toString (#2 kl) ^ "minutter";
val visKlokken = fn : int * int -> string
fun visKlokken (0,0) = "midnat"
| visKlokken kl
= Int.toString (#1 kl) ^ "timer og "
^ Int.toString (#2 kl) ^ "minutter";
val visKlokken = fn : int * int -> string
4.3.2 Joker
Hvis der ikke er brug for at referere til en del af (eller hele) et mønster, kan man spare sig
at finde p˚a et navn og det p˚agældende sted blot sætte et understregningstegn, der da vil
fungere som joker (eng.:wildcard), det vil sige passe med enhver værdi. Funktionen fst2 fra
(4.1) kunne have været erklæret
fun fst2 (x, ) = x
4.4 Blok
Ofte skal det samme deludtryk bruges flere gange i en større kontekst
. . . deludtryk . . . deludtryk . . . deludtryk . . .
men hvis udtrykket er omfattende, er det ikke hensigtsmæssigt blot at indsætte det hver
gang; dels kan man let komme til at skrive forkert en af gangene, og dels vil der g˚a tid
med at genevaluere hver forekomst af deludtrykket (selv om alle evalueringer vil give samme
resultat).
Det er bedre med en værdierklæring at give deludtrykkets værdi et eller andet navn, og
s˚a bruge dette navn i den større kontekst:
val navn = deludtryk;
. . . navn . . . navn . . . navn . . .
65

— p˚a den m˚ade vil værdien kun blive beregnet én gang, og det omfattende deludtryk skal
kun nedskrives én gang.
Nu vil navn imidlertid være til r˚adighed i resten af dialogen, selv om der kun var brug
for det inde i konteksten. For at undg˚a denne uhensigtsmæssighed er det i Standard ML
med en s˚akaldt blok muligt at angive, at en erklæring kun skal have lokal effekt. Det ser
s˚aledes ud
let val navn = deludtryk in . . . navn . . . navn . . . navn . . . end
Som nævnt i afsnit 3.3 har erklæringer p˚a yderste niveau gyldighed i resten af programmet.
For lokale erklæringer markerer end afslutningen af deres virkefelt:
let
Indledende erklæringer A
val mønster = udtryk B
Øvrige erklæringer C
in Blokkens krop D end
Resten af programmet E
Virkefeltet for de navne, som indg˚ar i mønster, er C og D.
let
Indledende erklæringer A
fun fnavn . . .
| fnavn mønster i = funktionskrop Bi
| fnavn . . .
Øvrige erklæringer C
in Blokkens krop D end
Resten af programmet E
Virkefeltet for de parameternavne, der indg˚ar i mønster i er Bi, og for fnavn er det Bi,
C og D.
Læg mærke til, at der godt kan st˚a mere end en erklæring mellem let og in, og at hver
erklæring i s˚a fald har adgang til de tidligere definerede navne.
Eksempel Lad os konstruere en funktion, der ud fra et begyndelsestidspunkt (t0, m0, s0)
angivet i timer, minutter og sekunder og en varighed s i sekunder beregner sluttidspunktet
som et tilsvarende tripel.
Her er funktionen:
fun sluttid ((t0,m0,s0),s)
= let val ss = s0 + s
val mm = m0 + ss div 60
val tt = t0 + mm div 60
in (tt mod 24,mm mod 60,ss mod 60) end;
val sluttid = fn : (int * int * int) * int -> int * int * int
sluttid ((23,35,00),1800);
val it = (0, 5, 0) : int * int * int
66

Udgangsformat Det ville passe bedre med normal skrivem˚ade, hvis resultatet ovenfor
var blevet vist som (0,05,00) , men hvordan man mere nuanceret selv kan styre uddatas
format, kommer vi først ind p˚a i kapitlet om tegn og tekster.
4.4.1 Analytisk brug af val
Som nævnt i afsnit 3.3 kan venstre side af en værdierklæring være et mønster indeholdende
flere navne. N˚ar dette mønster tilpasses højresiden, tillægges alle navnene værdi p˚a en gang.
Denne “analytiske” brug af val illustreres ved, at vi bygger videre p˚a eksemplet fra
afsnit 4.2:
val (m,n) = femtenfem;
val m = 15 : int
val n = 5 : int
fun spejltocifret n = let val (c1,c2) = divmod (n,10)
in c2 * 10 + c1 end;
fun spejltocifret = fn : int -> int
spejltocifret 43;
val it = 34 : int
4.4.2 Udtryk og erklæringer; let og local
Standard ML skelner mellem en erklæring (eng.:declaration) (som definerer et eller flere
navne) og et udtryk (eng.:expression) (til beregning af en værdi). Konstruktionen
let erklæring in udtryk end
bruges, n˚ar en erklæring (som godt kan være flere erklæringer) skal virke lokalt i et udtryk.
Der er en fuldstændig tilsvarende konstruktion, hvor let blot er skiftet ud med local
local erklæring in erklæring end
som man kan bruge, hvis en erklæring skal virke lokalt i en erklæring.
Eksempel Her defineres en funktion, som omsætter en tidsangivelse i timer, minutter og
sekunder til sekunder:
local fun omregn60 (a,b) = a * 60 + b
in fun sekunder (t,m,s) = omregn60 (omregn60 (t,m),s)
end;
val sekunder = fn : int * int * int -> int
sekunder (9,15,00);
val it = 33300 : int
67

4.5 Polymorfi
Betragt disse eksempler:
fun id x = x;
val ’a id = fn : ’a -> ’a
fun f n = 0;
val ’a f = fn : ’a -> int
fun g n = g (n + 1);
val ’a g = fn : int -> ’a
fun vendpar (x,y) = (y,x);
val (’a, ’b) vendpar = fn : ’a * ’b -> ’b * ’a
ML-systemet udleder den mest generelle type, et udtryk kan have. Det kan føre til, at
typen skal udtrykkes med typevariable, der i ML skrives som en apostrof efterfulgt af et eller
flere alfanumeriske tegn. I afsnit 4.3.1 var ’foerste og ’anden for eksempel typevariable.
Skal systemet generere typevariable, bruger det ’a, ’b, ’c, . . . (Nogle lærebøger bruger de
græske bogstaver α, β, γ, . . . som typevariable.)
Muligheden for at konstruere polymorfe funktioner er et afgørende element i ML’s store
anvendelighed og fleksibilitet.
4.5.1 Værdipolymorfi
For at undg˚a problemer, n˚ar polymorfi kombineres med referencer, som er en avanceret
ML-facilitet, vi ikke skal komme nærmere ind p˚a her, har det vist sig nødvendigt i bestemte
situationer at begrænse polymorfien i udtryk.
Pakker man linjerne (4.1) ovenfor sammen i en blok, kan det for eksempel give anledning
til følgende overraskende dialog:
let fun fst2 (x, ) = x in fst2 end;
! Warning: Value polymorphism:
! Free type variable(s) at top level in value identifier it
val it = fn : ’a * ’b -> ’a
val f = it;
val f = fn : ’a * ’b -> ’a
f (1.41,true);
! Warning: the free type variable ’b has been instantiated to bool
! Warning: the free type variable ’a has been instantiated to real
val it = 1.41 : real
f femtenfem;
! Toplevel input:
! f femtenfem;
! ^^^^^^^^^
! Type clash: expression of type
! int * int
! cannot have type
! real * bool
68

Svarene fra Moscow ML er forholdsvis udførlige: Værdipolymorfi betyder, at konstruktionen
omkring den lokale fst2 ikke er “rigtig polymorf”. Dens type indeholder typevariable,
men de er bare pladsholdere for typer, som endnu ikke er lagt fast. Første gang, funktionen
kaldes, fastfryses disse typer, og man kan ikke senere anvende funktionen p˚a andre end dem.
Da identitetsfunktionen id jo bare kopierer sit argument, skulle man ogs˚a tro, id id
igen ville give en identitetsfunktion, der var lige s˚a anvendelig (og specielt lige s˚a polymorf)
som den oprindelige. Men s˚adan er det ikke:
id id;
! Warning: Value polymorphism:
! Free type variable(s) at top level in value identifier it
val it = fn : ’c -> ’c
it it;
! Toplevel input:
! it it;
! ^^
! Type clash: expression of type
! ’d -> ’d
! cannot have type
! ’d
! because of circularity
Man siger, at ML har værdipolymorfi (eng.:value polymorphism) (se [5, afsnit 5.5], [13,
afsnit 7] og [12, side 178 og 323–324]), hvorved forst˚as, at typesystemet er udbygget med
en regel, ifølge hvilken kun visse udtryksformer, nemlig de s˚akaldt ikke-ekspansive udtryk
(eng.:non-expansive expressions) (i [12] kaldet syntaktiske værdier (eng.:syntactic values) og
i [5] værdiudtryk (eng.:value expressions)) p˚a yderste niveau m˚a have typevariable i deres
type.
Kort forklaret omfatter de ikke-ekspansive udtryk dem, der “har sig selv som værdi” og
ikke kan beregnes yderligere, det vil sige navne, konstanter og lambdaudtryk (se afsnit 6.3).
Blokke (let ...), betingede udtryk (if ..., ... orelse ..., ... andalso ...) og applikationsudtryk
hører derimod ikke med blandt de ikke-ekspansive udtryk.
Med passende typebegrænsninger kan man undg˚a de generelle typevariable og dermed
fejlmeldingerne.
4.6 Kast af standardundtagelse
Standardundtagelser blev nævnt i afsnit 3.6. At kaste en undtagelse er ikke forbeholdt systemet:
Med sprogelementet
raise undtagelse
kan man selv skrive programmer, der kaster undtagelser. Standardundtagelsen Fail skal
have en tekst som parameter, s˚a man kan indbygge fejlmeldinger fra sine programmer med
konstruktionen
raise Fail tekst
69

(Vi skal senere se, at man ogs˚a selv kan definere nye undtagelser.)
Her kontrolleres et timetal før udskrift, mens umulige timetal fejlmeldes:
fun visTimer timetal
= if 0 string
visTimer 11;
val it = "11 timer": string
visTimer ~2;
! Uncaught exception:
! Fail "ulovligt timetal"
4.7 Robusthed
Arealet T af en trekant med sidelængderne a, b og c kan findes af Herons formel
T = s(s − a)(s − b)(s − c)
idet s = a+b+c betegner trekantens halve omkreds. Vi programmerer beregningen (under
2
antagelse af, at man allerede har hentet kvadratrodsfunktionen ind med load "Math"):
fun areal (a,b,c)
= let val s = (a + b + c) / 2.0
in Math.sqrt (s * (s - a) * (s - b) * (s - c))
end;
val areal = fn : real * real * real -> real
areal (3.0,4.0,5.0);
val it = 6.0 : real
areal (2.1,3.2,5.4);
! Uncaught exception:
! Domain
Stillede man dette program til r˚adighed for en bruger, der skulle beregne trekantsarealer,
kunne systemundtagelsen “Domain” virke meget forvirrende.
Lad os kalde et program korrekt, hvis det giver det rigtige svar for de inddata, det er
beregnet til at virke p˚a. Ved programmelkonstruktion kan man ønske sig mere end korrekthed:
Vi vil sige, at et program er robust, hvis det ud over at være korrekt ogs˚a reagerer p˚a
en rimelig m˚ade for inddata uden for sit virkningsomr˚ade (s˚a alle værdier af argumentets
type f˚ar et rimeligt svar).
Typesystemet i Standard ML hjælper i høj grad med til, at programmer bliver robuste:
Inddata af forkert type bliver jo afvist af relevante fejlmeddelelser. I nogle tilfælde udgør
korrekte inddata imidlertid kun en delmængde af de data, hvis type passer.
Funktionen areal ovenfor er korrekt, men ikke robust. Fejlmeldingen skyldes, at man
forsøger at tage kvadratroden af et negativt tal, hvilket igen bunder i, at der ikke findes
nogen trekant med sidelængder 2.1, 3.2 og 5.4 (fordi 2.1 + 3.2 < 5.4).
Her er en robust udgave af arealfunktionen:
70

local fun tjek (a,b,c) = 0.0 < a andalso a < b + c
in fun areal (a,b,c)
= if tjek (a,b,c) andalso tjek (b,c,a) andalso tjek (c,a,b)
then let val s = (a + b + c) / 2.0
in Math.sqrt (s * (s - a) * (s - b) * (s - c))
end
else raise Fail "umulig trekant"
end;
val areal = fn : real * real * real -> real
areal (2.0,2.0,2.0);
val it = 1.73205080757 : real
areal (2.1,3.2,5.4);
! Uncaught exception:
! Fail "umulig trekant"
Funktioner, der stilles til r˚adighed for andre brugere, bør gøres robuste. Ofte indeholder
et program ogs˚a hjælpefunktioner, der kun kaldes “internt” af andre af programmets
funktioner. S˚adanne hjælpefunktioner skal ikke nødvendigvis gøres robuste; ofte betyder
programmets indre logik, at de ikke kan blive kaldt med ugyldige parametre 1 .
4.8 Uendelig løkke
Antallet af indbyrdes forskellige permutationer (opstillinger) af n forskellige objekter betegnes
n! (læses: “n fakultet”) og har værdien n! = 1 · 2 · · · n.
Fakultetsfunktionen er defineret for alle naturlige tal 2 gennem
n! =
og denne definition kan direkte nedskrives i ML:
fun fact 0 = 1
| fact n = n * fact (n - 1);
val fact = fn : int -> int
1 hvis n = 0
n · (n − 1)! hvis n = 1, 2, 3, . . .
Det har tidligere været nævnt, man bør tilstræbe at f˚a funktioner korrekte (i den forstand,
at funktionssvarene er de rigtige) og robuste (s˚a der altid fremkommer et forst˚aeligt svar).
Vores fakultetsfunktion er oplagt korrekt (idet den afspejler den matematiske definition),
men den er ikke robust:
Skridtene i beregningen fact 3 ❀ 6 kan sammenfattes s˚aledes:
fact 3 ❀ 3 * fact 2 ❀ 3 * (2 * fact 1)
❀ 3 * (2 * (1 * fact 0)) ❀ 3 * (2 * (1 * 1)) ❀ 3 * (2 * 1)
❀ 3 * 2 ❀ 6.
1Det følger af et resultat inden for teoretisk datalogi, at man ikke altid kan afgøre, om en funktion vil
kunne blive kaldt med ugyldige parametre.
2Overalt i disse noter betegner de naturlige tal IN mængden af ikke-negative heltal.
71

Evaluering af fact ~1 vil føre til:
fact ~1 ❀ ~1 * fact ~2 ❀ ~1 * (~2 * fact ~3)
❀ ~1 * (~2 * (~3 * fact ~4)) ❀ ...
Beregningen vil fortsætte i det uendelige og aldrig returnere et resultat. En s˚adan s˚akaldt
uendelig løkke er en af mulighederne, n˚ar en beregning er sat i gang. Forst˚ar man derfor
“værdi” som alt, hvad beregning kan føre til, er “uendelig løkke” ogs˚a en værdi. Ligesom
undtagelser er den en uegentlig værdi; den betegnes med symbolet ⊥ (læses: bund
(eng.:bottom)), alts˚a: fact ~1 ❀ ⊥.
Beregningsresultater kan ordnes indbyrdes efter, hvor lidt eller hvor meget definerede de
er. I den sammenhæng er ⊥ den mindst definerede af alle værdier; den ligger “i bunden” af
den nævnte ordningsrelation — deraf navnet.
Pladsmangel Prøver man det nævnte eksempel af i praksis, vil man opdage, at udredningen
ovenfor er forkert. Formentlig vil man finde noget i retning af
fact ~1;
! Uncaught exception:
! Out of memory
Afvigelsen skyldes, at vi har ræsonneret, som om datamaten havde ubegrænset meget
lager til r˚adighed, hvilket aldrig vil være tilfældet i praksis. At holde styr p˚a evalueringen af
fact ~1 lægger beslag p˚a stadig mere af maskinens arbejdslager, og før eller siden slipper
det op.
Ogs˚a i den anden ende er der forskel p˚a teori og praksis: idet der (som nævnt i afsnit 3.6.2)
er en snæver grænse for, hvor stor en værdi af type int kan blive, kan kun op til 12! beregnes
p˚a den angivne m˚ade; fact 13 vil give overløb.
Forskellige maskiner har forskellig kapacitet, og at tage en maskines kapacitet med i
betragtning i denne form for overvejelser er vanskeligt. Vores forklaringer af sproget ML g˚ar
derfor ud fra, lageret er s˚a stort, som der bliver brug for, og at hele tal kan blive vilk˚arligt
store. Vi vil fastholde
fact n ❀
n! for alle naturlige tal n
⊥ ellers
Udefineret. Der kan være grund til at understrege den særlige natur af beregningsresultatet
⊥: En p˚astand af formen exp ❀ ⊥ for et eller andet udtryk exp m˚a altid bygge p˚a
et ræsonnement uden for beregningerne selv. Man kan naturligvis godt starte en evaluering
af exp, men det er ikke i almindelighed muligt at sætte en øvre grænse for, hvor lang tid en
beregning kan tage. Uanset, hvor længe man har ventet forgæves p˚a et beregningsresultat,
er det derfor umuligt at vide, om der virkelig aldrig vil komme et, eller om beregningen ville
være blevet færdig sekundet efter, at ens t˚almodighed var brugt op.
Inden man sætter en beregning i gang, er det nyttigt at gøre sig klart, hvordan den kan
standses, hvis man ved en fejltagelse skulle være kommet til at starte en uendelig løkke. Ved
vores terminaler benyttes den udbredte konvention, at man kan sende tegnet ETX (End of
TeXt; tegnet kan dannes som “Ctrl”+c) som nødstop. I implementeringen af Moscow ML
p˚a Macintosh bruges punktet “Interrupt” i Command-menuen. Muligheden for at afbryde
72

kan man ogs˚a have glæde af ved meget langvarige beregninger (fra et praktisk synspunkt
er der ingen forskel p˚a en uendelig løkke og en beregning, der tager meget lang tid — for
eksempel 100 ˚ar).
N˚ar beregningen afbrydes, kvitterer ML med svarlinien
> Interrupted.
Her er et eksempel:
fun bund n = bund n;
val (’a, ’b) bund = fn : ’a -> ’b
bund 2;
Efter at have sluttet af med semikolon og linieskift-tegn venter man i meget lang tid,
uden at der sker noget som helst, og n˚ar ens t˚almodighed er brugt op, tastes c med Ctrl
nedtrykket.
Interrupted.
4.9 Sammenfatning
Par, tripler, og s˚a videre skrives med runde parenteser og kommaer og kan indg˚a som andre
værdier: De kan navngives, de kan være funktionsparametre, og de kan være funktionsresultater.
Deres type er et produkt (vist med * (asterisk)) af komponenternes type. Komponenter
kan udvælges med projektionsfunktionerne #1, #2, . . .
Typen unit indeholder netop én værdi, som noteres ().
Mønsteret er en joker, der passer p˚a alt.
Med let . . . in . . . end kan man indføre en erklæring lokalt i et udtryk, og med
local . . . in . . . end kan man indføre en erklæring lokalt i en erklæring.
Fejlmeldinger gives med raise Fail tekst.
Funktioner, man stiller til r˚adighed for andre, bør ud over at være korrekte ogs˚a være
robuste, det vil sige give forst˚aelige fejlmeldinger for inddata uden for definitionsomr˚adet.
En beregning kan afbrydes med “Ctrl”+c (p˚a Macintosh med punktet “Interrupt” i
Command-menuen).
4.10 Opgaver
Opgave 4.1 Skriv en funktion, der kontrollerer, om dets argument er et korrekt klokkeslæt
p˚a formen (timetal ,minuttal ,sekundtal ).
Opgave 4.2 Skriv en robust ML-definition af n!.
Opgave 4.3 Hvorfor kan man ikke ved passende valg af en værdi for (−1)! udvide ligningen
n! = n · (n − 1)! til at gælde alle hele tal n ≥ 0 (det vil sige alle naturlige tal)?
73

Opgave 4.4 Skriv en funktion, der ud fra et naturligt tal som argument danner produktet
af tallets cifre (n˚ar det fremstilles som talord uden foranstillede nuller).
Opgave 4.5 Skriv en funktion, der for et vilk˚arligt helt tal ≥ 2 finder det mindste hele
tal større end 1, der g˚ar op i tallet (med andre ord tallets mindste primfaktor).
Opgave 4.6 Indtast denne definition
fun halve 0 = 0
| halve n = if n mod 2 = 0 then 1 + halve (n - 2)
else halve (n - 2);
og prøv at kalde funktionen dels med lige tal, dels med ulige tal som argument.
Hvad mon programmøren har ment?
74

Kapitel 5
Konstruktion af funktioner
5.1 Problemløsning
Opgaver, der skal løses med et SML-program, g˚ar ud p˚a at konstruere en funktion, der fører
fra visse inddata (af en bestemt SML-type) til visse uddata (af den samme eller en anden
SML-type). Undertiden er der en standardoperator eller standardfunktion, som direkte løser
opgaven, men i langt de fleste tilfælde er det nødvendigt at g˚a indirekte frem og bruge
en kombination af indbyggede funktioner, eventuelt suppleret med funktioner, man selv
definerer undervejs.
5.1.1 Et eksempel: Hexadecimale tegnkoder
Vi varmer op med et lille eksempel, der drejer sig om manipulation med nogle tegnkoder.
En grundig gennemgang af tegn og tekster kommer i kapitel 7. Vi f˚ar her blot brug for,
at tegnkonstanter noteres i SML som disse eksempler viser:
bogstavet “N” #"N"
cifferet “5” #"5"
et lighedstegn #-"
og at biblioteksfunktionerne chr : int -> char og ord : char -> int formidler den omsætning
mellem tegn og de tilhørende koder, som fremg˚ar af tabel 1.2.
Tænkte man sig tabel 1.2 udvidet til at dække hele talomr˚adet fra 0 til 255 (standarden
mangler koderne 0–31 og 127–159), ville det blive en tabel med 16 rækker og 16 søjler.
Størrelser, der har 10 mulige værdier, kan betegnes med et af de sædvanlige decimale
cifre fra 0 til 9. N˚ar der er 16 mulige værdier, bruger man undertiden et s˚akaldt hexadecimalt
ciffer, det vil sige en værdi blandt
0 1 2 3 4 5 6 7 8 9 A B C D E F
To hexadecimale cifre kan derfor bruges til angivelse af henholdsvis en række og en søjle
i den udvidede version af tabel 1.2.
Opgave Konstruer en funktion iso8 : char * char -> char, som ud fra et par af hexadecimale
cifre, der betegner en række og en søjle i ISO-tabellen, angiver tegnet p˚a den
p˚agældende plads. Der skal for eksempel gælde
iso8 (#"3",#"D") = #-"
75

iso8 (#"E",#"6") = #"æ"
Løsning 1 Ingen biblioteksfunktion løser direkte opgaven, men den kan klares med en
sindrig kombination af standardfunktioner. I stedet for at kode hexadecimale cifre ind i
løsningen som “magiske konstanter” g˚ar vi ud fra 1 , at cifrene fra 0 til 9 har koder, der følger
lige efter hinanden, og at bogstaverne fra A til Z har koder, der følger lige efter hinanden:
fun iso8 (cr,cs)
= chr ((if ord cr - ord #"0≪ 10 then ord cr - ord #"0"
else ord cr - ord #"A"+ 10)
* 16 +
(if ord cs - ord #"0≪ 10 then ord cs - ord #"0"
else ord cs - ord #"A"+ 10))
Selv om dette program løser opgaven, kan man rette en del indvendinger imod det:
• det giver anledning til en del gentagne (og derfor overflødige) beregninger
• i de mange linjer, som ligner hinanden, men alligevel ikke er helt ens, kan man let
komme til at skrive forkert
• hvis man laver fejl, kan den skjule sig i den lange formel og være svær at finde
• funktionens virkem˚ade er uoverskuelig
Det sidste punkt kunne afhjælpes med kommentarer eller andre ledsagende forklaringer,
men det er bedre at dele funktionen op i flere mindre dele. Den overordnede gang i funktionen
er, som figuren viser, at de to indkomne tegn første omsættes til tal, dernæst sættes de to
tal sammen til et, og ud fra det findes det resulterende funktionsværditegn.
char ✲ int
char ✲ int
❍ ❍ ❍❥
✟ ✟ ✟✯ int ✲ char
Løsning 2 Det er bedre at uddelegere de indg˚aende omformninger. Lad for eksempel
fromChar : char -> int omsætte et hexadecimalt ciffer til dets værdi, og lad
hex2 : int * int -> int beregne værdien af et tocifret hexadecimalt talord:
fun fromChar c
= let val n = ord c
val d = n - ord #"0"
in if d < 10 then d else n - ord #"A"+ 10 end
fun hex2 (h1,h0) = h1 * 16 + h0
fun iso8 (cr,cs) = chr (hex2 (fromChar cr,fromChar cs))
I denne version af programmet har vi sørget for ikke unødigt at gentage beregninger. Desuden
er det lettere at f˚a programmet korrekt, n˚ar hver af de indg˚aende dele er en selvstændig
funktion, der kan konstrueres og afprøves isoleret.
1 hvad der vil være opfyldt for mange andre koder end netop ISO
76

5.2 Rekursion
Under nedbrydning af et problem i delproblemer kan man komme ud for, at et eller flere af
delproblemerne er af samme art som det oprindelige problem.
Helt magen til det oprindelige problem m˚a det nye problem selvfølgelig ikke være, for s˚a
er man inde i en “ond cirkel”, der ikke kommer løsningen nærmere, men meget ofte er det
nye problem mindre eller p˚a anden m˚ade simplere end det oprindelige.
I funktionsprogrammering, hvor et “problem” udtrykkes som en funktion (fra inddata til
uddata), vil denne situation vise sig ved, at en funktions definition indeholder kald af denne
selvsamme funktion.
I en definitionsligning
begreb = redegørelse
vil det jo normalt være s˚adan, at der p˚a venstre side af lighedstegnet st˚ar noget ukendt, der
nu skal lægges fast, mens den definerende højreside indeholder lutter kendte størrelser.
En definition, der i sin redegørelse benytter det, man er ved at definere, siges at være
rekursiv (af lat. re- = tilbage, igen og currere = løbe). Selv om det kan være uvant og p˚a
nogen nærmest virke mystisk eller selvmodsigende at bruge en rekursiv beskrivelse, behøver
den ikke at være det ringeste suspekt. Det kræves blot, at forklaringen i en eller anden
forstand er enklere end det, der skal forklares.
Har man forst˚aet, hvordan funktionskald foreg˚ar i SML (den igangværende beregning
suspenderes, en beregning af funktionskaldets værdi skydes ind, hvorefter den suspenderede
beregning genoptages med værdien p˚a funktionskaldets plads), s˚a ved man ogs˚a, hvad
der sker ved et rekursivt funktionskald. Der er nemlig slet ingen forskel! Det foreg˚ar p˚a
fuldstændig samme m˚ade.
Lad os betragte et eksempel.
5.2.1 Fakultetsfunktionen
Antallet af indbyrdes forskellige permutationer (opstillinger) af n forskellige objekter betegnes
n! (læses: “n fakultet”) og har værdien n! = 1 · 2 · · · n.
Fakultetsfunktionen er fastlagt for alle naturlige tal gennem
n! =
1 hvis n = 0
n · (n − 1)! hvis n = 1, 2, 3, . . .
og disse egenskaber kan direkte nedskrives i ML:
fun fakultet n = if n = 0 then 1 else n * fakultet (n - 1);
val fakultet = fn : int -> int
(5.1)
(5.2)
Definitionerne (5.1) og (5.2) ses at være rekursive.
Vi indser, at fakultetsfunktionen alligvel er veldefineret for alle naturlige tal, idet 0! har
en fastlagt værdi, hvilket ogs˚a giver 1! en værdi, som igen fastlægger værdien for 2!, og s˚a
videre. Ved matematisk induktion indser man, at n! har en entydig værdi for alle naturlige
tal n.
77

5.2.2 Virkning af funktionskald
Den her forklarede fremgangsm˚ade kan bruges, hvad enten der er tale om en rekursiv funktion
eller ej, men nogle vil finde det illustrativt at se, hvordan kald af fakultetsfunktionen afvikles.
Ved at bruge notationen udtryk ❀ værdi for at betegne evaluering af et udtryk til en
værdi og notationen udtryk ❀ udtryk ′ for et enkelt skridt undervejs i en evaluering kan vi
forklare, hvordan evaluering af fakultet 2 finder sted:
fakultet 2 ❀ [p˚a grund af definitionen (5.2)]
if 2 = 0 then 1 else 2 * fakultet (2 - 1) ❀ [idet 2 = 0 ❀ false]
if false then 1 else 2 * fakultet (2 - 1) ❀
[idet if false then d else e ❀ e]
2 * fakultet (2 - 1) [beregningen suspenderes]
fakultet (2 - 1) ❀ [subtraktion]
fakultet 1 ❀ [p˚a grund af definitionen (5.2)]
if 1 = 0 then 1 else 1 * fakultet (1 - 1) ❀ [idet 1 = 0 ❀ false]
if false then 1 else 1 * fakultet (1 - 1) ❀
[idet if false then d else e ❀ e]
1 * fakultet (1 - 1) [beregningen suspenderes]
fakultet (1 - 1) ❀ [subtraktion]
fakultet 0 ❀ [p˚a grund af definitionen (5.2)]
if 0 = 0 then 1 else 0 * fakultet (0 - 1) ❀ [idet 0 = 0 ❀ true]
if true then 1 else 0 * fakultet (0 - 1) ❀
[idet if true then d else e ❀ d]
1
❀ [den suspenderede beregning genoptages]
1 * 1 ❀ [multiplikation]
1
❀ [den suspenderede beregning genoptages]
2 * 1 ❀ [multiplikation]
2
5.2.3 Rekursiv problemløsning
I funktionsprogrammering benytter man ofte rekursive funktioner. De dukker op i de situationer,
hvor et problem ikke kan løses “i et snuptag” ved passende kombination af biblioteksfunktioner
og allerede dannede funktioner. Den rekursive funktionskrop viser da, hvordan
man uden at løse problemet til bunds dog kan komme løsningen “et lille skridt nærmere”.
I tilfældet med fakultetsfunktionen er ræsonnementet: Vi skal gange tallene fra 1 til n
sammen, men der er ikke nogen standardfunktion, som danner dette produkt p˚a en gang.
Hvis vi imidlertid allerede kendte værdien af fakultetsfunktionen for argument n−1, s˚a ville
man kunne finde den ønskede værdi ved at gange dette tal med n.
Mere almindeligt har den rekursive problemløsningstankegang denne form: I simple tilfælde
kan løsningen direkte angives, men for mere komplicerede inddata beskriver vi, hvordan
man ville kunne bygge en løsning op under forudsætning af, at løsning(er) p˚a et eller flere
simplere tilfælde af problemet allerede var kendt.
78

5.2.4 Ræsonneren om funktionskald
Rammerne viser, hvordan systemet ved at suspendere og genoptage beregninger udfører de
rekursive kald, men sin forst˚aelse af en funktion bør man ikke bygge p˚a dette dynamiske billede.
Antallet af “rammer indlejret i hinanden” vil afhænge af de aktuelle argumentværdier,
og ræsonnementer om et program bør derfor bygge p˚a programteksten.
Argumentation for egenskaber ved en rekursiv funktion kan have form af induktionsræsonnementer:
Under beviser for, funktionen har en vis egenskab, antages alle indre kald
allerede at have egenskaben.
5.3 Indsættelse
S˚a snart der bliver brug for mere end et par linjers definitioner, er det ubekvemt at indtaste
dem direkte til ML-systemet. Hertil kommer, at alle definitioner tabes, n˚ar systemet forlades,
og alts˚a m˚a indtastes p˚any, hvis de senere skal bruges igen.
Sædvanligvis arbejder man derfor p˚a den m˚ade, at definitioner udarbejdes i en eller flere
filer ved hjælp af et s˚akaldt tekstbehandlingsprogram eller redigeringsprogram (eng.:editor).
P˚a øvelserne og i det tilhørende undervisningsmateriale beskrives tekstredigeringsværktøjerne
nedit, vi, vim og emacs.
Nogle tekstbehandlingsprogrammer er beregnet til at styre opstilling af tekst i kapitler
og afsnit, med overskrifter i flere niveauer, skriftvarianter som fed og kursiv, hævede og
sænkede tegn og mange andre raffinementer. Den form for tekstbehandlingsprogrammer (for
eksempel Microsoft Word eller L ATEX) er ikke relevante ved skrivning af programmer. I den
situation skal man bare bruge de simple værktøjer, som gratis følger med operativsystemet.
P˚a Macintosh er det SimpleText og under Microsofts operativsystemer Notepad.
Under operativsystemet Unix kan filnavne blandt andet indeholde bogstaver, cifre, punktum
og bindestreg; filer med ML-erklæringer bør gives navne, hvis fire sidste tegn er .sml.
N˚ar man er tilfreds med sine definitioner, kan de indsættes p˚a topniveau med standardfunktionen
“use”. Antag, vi med tekstbehandlingsprogrammet har konstrueret filen
“fak.sml”:
fun fakultet n
= if n = 0 then 1
else n * fakultet (n - 1);
I en ML-dialog kan man da skrive:
use "fak.sml";
[opening file "fak.sml"]
val fakultet = fn : int -> int
[closing file "fak.sml"]
val it = () : unit
← Indholdet af filen
“fak.sml”
og virkningen vil være den samme, som hvis man direkte havde tastet linjerne fra filen ind.
Læg mærke til, at filnavnet skal omgives af anførelsestegn, hvorved det kan behandles af
ML som data af type “tekst” (eng.:string). (I et senere kapitel vil vi komme nærmere ind
p˚a tekster.) Dette forklarer typen af “use”:
79

use;
val it = fn : string -> unit
Funktionen “use” har (ligesom tilfældet var for “quit” og “load”) kun interesse p˚a grund
af sin bivirkning; funktionskaldet selv evalueres bare til det tomme sæt (af enhedstypen).
5.4 Programnedskrivning
Selv om et program er en instruks til en maskine om, hvordan beregninger skal styres, læses
programmer i vidt omfang ogs˚a af mennesker: som regel er programmer ikke korrekte, første
gang de skrives ned, og at finde fejl i et program kan kræve omhyggelig nærlæsning; ofte
gennemg˚ar programmer ogs˚a mange tilpasninger, hvor de afstemmes i forhold til ændrede
eller udvidede specifikationer.
N˚ar programmer skrives ned, er det derfor vigtigt, at man ikke kun overholder de formelle
syntaksregler (som er en forudsætning for, at systemet vil acceptere programmet), men ogs˚a
benytter en læsevenlig programmeringsstil. At f˚a et program i h˚anden, man selv har skrevet
for nogle m˚aneder siden, og opdage, hvor vanskeligt det er at komme tilbage i de tankebaner,
som syntes s˚a klare, dengang programmet blev skrevet, kan være en frustrerende oplevelse.
I dette afsnit gives nogle gode r˚ad med hensyn til navnevalg, opstilling og kommentarer.
5.4.1 Navnevalg
Som afsnit 2.4.1 viste, er der stor frihed med hensyn til, hvorledes funktioner, konstanter og
parametre benævnes. Prøv ikke at finde p˚a “morsomme” navne (som “hyl” eller “idiot”),
men vælg betydende navne, der alligevel ikke er for lange; prøv eventuelt at følge en eller
anden systematik. I et program til skatteberegning kan man f˚a brug for “bundbeskatningsgrundlag”,
“mellembeskatningsgrundlag”, “topbeskatningsgrundlag” og “indkomstbeskatningsgrundlag”.
I sig selv vil disse navne normalt være for lange, men det er heller ikke smart
at kalde dem “a”, “b”, “c” og “d” eller “bg”, “tg”, “mg” og “ig”. Navne som “bundgrundl”,
“top grundl”, “melmgrundl” og “indkgrundl” kunne m˚aske bruges.
5.4.2 Opstilling
For ML tjener mellemrum (sekvenser af blanktegn, tabuleringstegn og ny-linje-tegn) blot
til at adskille grundsymboler. For afviklingssystemets skyld kunne fakultetsfunktionen godt
skrives
fun fakultet
n= if n=0then
1else
n * fakultet(n-1);
men man st˚ar sig ved at stille programmer systematisk op.
80

5.4.3 Kommentarer
Som det blev nævnt i afsnit 3.10.1, kan vilk˚arlig tekst indsættes som kommentar i et program.
Denne mulighed for at gøre en programtekst klarere ved hjælp af kommentarer bør man altid
benytte sig af.
Kommentarer skal vælges, s˚a de støtter forst˚aelsen af programmet uden at gentage, hvad
man direkte kan læse sig til af programkonstruktionerne. Her er et eksempel p˚a, hvordan
kommentarer ikke bør udformes:
NB D˚ARLIGE KOMMENTARER NB
NB NB
NB fun fakultet n = NB
NB if n = 0 then 1 NB
NB (* hvis n er 0, da 1 *) NB
NB else n * fakultet (n - 1); NB
NB (* og ellers n gange fakultet taget af n-1 *) NB
NB NB
NB D˚ARLIGE KOMMENTARER NB
Som et mindstem˚al bør hver funktionsdefinition ledsages af en kort kommentar, der
forklarer, hvad det er, den beregner, men ofte kan kommentarer derudover ogs˚a være nyttige.
Kommentarer bør formidle en overordnet indsigt, der ikke direkte fremg˚ar af programmet,
men støtter forst˚aelsen af det. Her er en acceptabel udgave af fakultetsfunktionen:
(* Fakultetsfunktionen n! er
produktet 1*2*...*n *)
fun fakultet n =
if n = 0 then 1
else n * fakultet (n - 1);
Her i noterne er mange eksempler ikke forsynet med de kommentarer, de i henhold til
r˚adene i dette afsnit burde have, idet den omgivende tekst fungerer som kommentar!
5.4.4 Systematik
Vær under nedskrivning af et program opmærksom p˚a, at det skal kunne læses og forst˚as
(af et menneske og ikke kun af en maskine). Brug de enklest mulige konstruktioner, som
tjener det givne form˚al.
Hvis et delproblem kan løses p˚a flere forskellige m˚ader og dukker op flere gange, s˚a vælg
konsekvent samme løsning hver gang. Hvis løsningen ikke er oplagt eller fylder mere end
omkring en linje, kan det ofte betale sig at trække et delproblem ud som en ny selvstændig
funktion. Vi vil have mere at sige om programkonstruktion i et senere afsnit.
5.5 Afprøvning
N˚ar man arbejder med EDB, vil man gøre den forbavsende iagttagelse, at man jævnligt
beg˚ar fejl. Fejl i programmer kan vise sig p˚a flere m˚ader:
81

En s˚akaldt syntaksfejl ytrer sig ved, at ML-systemet giver en fejlmelding, fordi teksten
ikke overholder reglerne. Strengt taget er det forkert at tale om en “fejl i programmet”, for
i det tilfælde er teksten jo slet ikke et program! og det er sjældent, der kun er én mulig
rettelse, som vil gøre den til et program.
Husk, at ML-systemet vil melde fejl hvor de findes, og at det ikke behøver at være der,
hvor de skal rettes.
For at syntaksfejl ikke skal blive for svære at finde, er det vigtigt at opbygge et program
af sm˚a overskuelige dele, der kan fortolkes af ML hver for sig.
Hvis et program overholder syntaksreglerne, men alligevel ikke virker som forventet, taler
man om semantiske fejl. En semantisk fejl kan ytre sig ved, at uddata ikke er de rigtige, eller
(og det er den allervanskeligste type fejl at finde) ved, at programmet slet ingen resultater
giver og tilsyneladende er g˚aet i uendelig løkke. I det tilfælde er der ingen anden udvej end
at g˚a systematisk frem og prøve at isolere fejlen, idet man hele tiden m˚a huske, systemet jo
ikke kan gætte, hvad man har i tankerne, men blot slavisk udfører de nedskrevne ordrer.
5.5.1 Bevis eller afprøvning?
Mens funktionsdefinitioner konstrueres, er det vigtigt, man overbeviser sig om, at de er
korrekte, og i princippet kunne man sikre sig mod programfejl ved at føre et formelt bevis
for, at programmet overholdt sin specifikation. I praksis er den vej ikke fremkommelig:
Formelle beviser er b˚ade for vanskelige og for omfattende, og ligesom ved programmering er
der tale om symbolmanipulation, som man kunne komme til at beg˚a fejl i!
Ved siden af at ræsonnere om sit program kommer man derfor ikke uden om ogs˚a at
afprøve det. Et ML-program best˚ar af en række erklæringer, og afprøvning af det g˚ar ud p˚a
at anvende de definerede funktioner p˚a udvalgte argumenter og sammenligne resultaterne
med det forventede.
Det kan stærkt tilr˚ades, at man tilegner sig en bevidst og hensigtsmæssig afprøvningsdisciplin.
I næste del af dette kursus vil spørgsm˚alet om programafprøvning blive taget mere
systematisk op; her er foreløbigt opsamlet en række gode r˚ad om det, som sidenhen vil
blive kaldt intern afprøvning. Nogle af r˚adene er, at man bør prøve med eksempler med
kendt forventet udfald, og at b˚ade testdata og det forventede resultat bør indarbejdes i selve
programteksten.
5.5.2 Afprøvningsdata i programteksten
Anbefalingen g˚ar ud p˚a, at man i programfilen umiddelbart efter hver definition af en funktion
f indsætter passende kald f a1 = b1; f a2 = b2; . . .
I den førnævnte fil “fak.sml” med fakultetsfunktionens definition kunne der for eksempel
st˚a:
fun fakultet n
= if n = 0 then 0
else n * fakultet (n - 1);
fakultet 0 = 1;
fakultet 1 = 1;
fakultet 3 = 6;
82

N˚ar filen ved et kald af “use” læses ind, giver selve definitionen anledning til oplysning
om funktionens type, og hver af afprøvningslinjerne resulterer i en sandhedsværdi. I det
aktuelle tilfælde f˚as
use "fak.sml";
[opening file "fak.sml"]
val fakultet = fn : int -> int
val it = false : bool
val it = false : bool
val it = false : bool
[closing file "fak.sml"]
val it = () : unit
som klart afslører, at der er en fejl. Nøjere undersøgelse af funktionsdefinitionen viser, at vi
er kommet til at skrive forkert i anden linje, hvor der skulle have st˚aet
= if n = 0 then 1
5.5.3 Udformning af testdata
Det betaler sig at ofre lidt opmærksomhed p˚a at lægge afprøvning fornuftigt til rette. Her
er nogle tommelfingerregler, som efterfølgende kommenteres:
1. Brug simple testeksempler
2. Sørg for at prøve alle dele af programmet
3. Afprøv i en s˚adan rækkefølge, at det er let at henføre fejl til bestemte programdele
4. Konstruer testdata sideløbende med, at funktionen konstrueres
5. Udnyt al den information, systemets fejlmeldinger giver
ad 1: Det kan være fristende at prøve en funktion af p˚a noget “rigtigt svært” og for
eksempel skrive
fakultet 10 = 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10;
snarere end
fakultet 3 = 6
men fra et programmeringsmæssigt synspunkt prøver første eksempel ikke større dele af
programmet end sidste, og hvis der optræder en fejl, er den meget nemmere at lokalisere,
n˚ar man kan følge beregningerne i hovedet.
ad 2: Først og fremmest skal man sørge for, at hvert valgudtryk if b then d else e b˚ade
bliver prøvet med falsk og med sand betingelse b. Kan dette ikke lade sig gøre, indeholder
programmet jo overflødige dele!
Er der rekursive kald (hvad enten der er tale om direkte kald af funktionen i dens egen
krop eller om en kæde af funktionskald, som gensidigt kalder hinanden og til sidst kalder
funktionen selv igen), bør der b˚ade være testdata, for hvilke det rekursive kald ikke bliver
83

udført, og testdata, for hvilke det bliver (eventuelt b˚ade nogle, hvor det bliver udført netop
én gang, og andre, hvor der kaldes mere end en gang).
De tre test, vi valgte for fakultetsfunktionen:
fakultet 0 = 1;
fakultet 1 = 1;
fakultet 3 = 6;
vil netop b˚ade prøve med falsk og med sand værdi af n = 0 og sørge for henholdsvis ingen,
netop et og flere end et rekursivt kald.
For disjunktion og konjunktion gælder noget tilsvarende. Hvis ens funktion indeholder
et deludtryk af formen u1 orelse u2 orelse u3, bør fire forskellige tilfælde dækkes med
testdata: u1 sand; u1 falsk, men u2 sand; u1 og u2 falske, u3 sand; alle tre udtryk u1, u2 og u3
falske. Hvis ikke alle fire tilfælde kan forekomme, er et eller flere af udtrykkene overflødige!
For konjunktioner (med andalso) forholder det sig p˚a samme m˚ade, blot med omvendte
sandhedsværdier.
ad 3: Hvis filen fak.sml havde indeholdt
fun fakultet n
= if n = 0 then 0
else n * fakultet (n - 1);
fakultet 1 = 1;
fakultet 0 = 1;
fakultet 3 = 6;
ville et forsøg “use "fak.sml";” p˚a at indsætte den stadig fejle for alle tre testlinjer, men
da n = 0 med denne testsekvens først er falsk og siden (for det indre rekursive kald) sand,
er det umuligt at lokalisere fejlen til en bestemt del af funktionen. Det er meget bedre at
starte med den testlinje “fakultet 0 = 1;”, som kun berører programlinje 2.
ad 4: Programkonstruktion er s˚a fængslende en aktivitet, at det er let at blive grebet af
den og udskyde afprøvning til behovet opst˚ar, det vil sige indtil der dukker fejl op. M˚aske
ligger fejlen i en funktion, man skrev for længe siden, og det kan øge vanskelighederne med
at finde fejlen.
Det anbefales stærkt, at man skriver afprøvningsdata ned med det samme. Lige n˚ar man
har konstrueret en funktion i ML, er man godt inde i den, og da kan man uden stort besvær
skrive nogle testdata ned til afprøvning af den. Dem skal man lade blive st˚aende i samme
fil som funktionen, s˚a ML-systemet vil udføre testene, n˚ar funktionen hentes ind, og r˚abe
gevalt, hvis noget g˚ar galt.
Skal funktionen senere udbygges eller modificeres, er det en stor fordel at have de gamle
testdata til r˚adighed til afprøvning af den nye udgave af funktionen.
Arbejdsformen med integrering af konstruktion og afprøvning bevirker, at man kun
behøver beskæftige sig indg˚aende med hver funktion én gang (forudsat man f˚ar den udtrykt
korrekt). Tager man i stedet programmering for sig og afprøvning for sig, skal man
beskæftige sig med hver funktion to gange: n˚ar man konstruerer den, og n˚ar man afprøver
den. For at kunne lave en fornuftig afprøvning er det da nødvendigt at genlæse og “genforst˚a”
hver funktion, hvilket er spild af tid.
84

5.6 Programkonstruktion
Fakultetsfunktionen har været det gennemg˚aende eksempel. Efterrationalisering af, hvordan
vi bar os ad med at programmere den, kan tage sig s˚aledes ud:
Fakultetsfunktionen er egentlig defineret ved
n! = 1 · 2 · · · n (5.3)
men s˚adan en definition “med prikker i” kan ikke forst˚as af en maskine 2 . For sm˚a værdier af
n finder man af (5.3) 3! = 6, 2! = 2 og 1! = 1. Hvilken værdi 0! skal have, er mindre oplagt.
Ved at gruppere de første n − 1 faktorer i (5.3) sammen er det imidlertid simpelt at udlede
gældende for hele tal n ≥ 3, s˚a man samlet har
n! = (1 · 2 · · · (n − 1)) · n = (n − 1)! · n (5.4)
⎧
⎪⎨
n! =
⎪⎩
den for 0! valgte værdi for n = 0
1 for n = 1
2 for n = 2
(n − 1)! · n for n ≥ 3
Værdien af 0! vælges ud fra et grundlæggende logisk princip:
Læg definitioner og ræsonnementer til rette, s˚a antallet af specialtilfælde
bliver s˚a lille som muligt, og s˚a identiteter og andre
egenskaber f˚ar det størst mulige gyldighedsomr˚ade.
(5.5)
Følges dette princip, f˚ar man mindst at tænke over, og programmer bliver nemmere at
overskue og nemmere at f˚a korrekte.
I det foreliggende tilfælde kan antallet af linjer i ligning (5.5) reduceres fra fire til to
under forudsætning af, at vi vælger 0! = 1; derved genfindes ligning (5.1):
n! =
1 for n = 0
n · (n − 1)! for n ≥ 1
Fakultetsfunktionens program dannedes nu simpelt hen ved, at egenskaben (5.1) blev
ophøjet til definition.
Med valget 0! = 1 er gyldigheden af ligning (5.4) udvidet til alle hele tal n ≥ 1.
5.6.1 Hanois t˚arn
Lad os illustrere dette delafsnit om rekursiv programkonstruktion ved at løse puslespillet
“Hanois t˚arn” (eng.:Tower of Hanoi). Det best˚ar af otte cirkelskiver, der har forskellig
størrelse og i midten er forsynet med et hul, s˚a de kan sættes ned over spillebrættets tre
pinde.
Ved spillets begyndelse ligger alle otte skiver efter størrelse p˚a den første pind. Opgaven
g˚ar ud p˚a at flytte dem over p˚a pind nummer to under iagttagelse af følgende regler:
2 I hvert tilfælde ikke uden inddragelse af teknikker fra omr˚adet “simuleret intelligens” (eng.:artificial
intelligence), hvilket falder uden for dette kursus.
85

Figur 5.1: Udgangsstillingen i puslespillet “Hanois t˚arn”.
• Et træk best˚ar i at flytte den øverste skive fra en af pindene til en af brættets andre
pinde (kun en skive ad gangen).
• Ingen skive m˚a lægges oven p˚a en mindre skive.
Løs den tilsvarende opgave med to og med tre skiver (men stadig med tre pinde), inden
du læser videre 3 .
Det er rimeligt at søge at udtrykke løsningen for et vist antal skiver ved hjælp af løsninger
for færre skiver, men i modsætning til det der sker, n˚ar puslespillet faktisk løses, er det ikke
den mindste skive, man skal se bort fra. (Se dog opgave 5.4.) Det er væsentlig mere frugtbart
at fokusere p˚a den største skive. Hvis alle skiverne skal flyttes fra pind 1 til pind 2, m˚a der
være et træk, i hvilket den underste skive flyttes fra pind 1. Løsningen f˚ar færrest træk, hvis
den da flyttes over p˚a pind 2. I det træk, som flytter den største skive fra pind 1 til pind
2, m˚a alle de øvrige skiver befinde sig p˚a pind 3. Hele løsningen kan derfor opsplittes i tre
dele: Først flyttes de 7 mindste skiver i et vist antal træk (hvorunder den største skive bliver
liggende) fra pind 1 til pind 3, s˚a den største skive i et enkelt træk fra pind 1 til pind 2,
og til sidst flyttes igen de 7 mindste skiver i et vist antal træk (hvorunder den største skive
bliver liggende), nu fra pind 3 til pind 2.
Ræsonnementet er ikke specielt for et t˚arn af 8 skiver, men kan bruges i en generel rekursiv
løsning. Man kunne vælge n = 2 eller n = 1 som basistilfælde, men i overensstemmelse
med princippet om at søge den størst mulige enkelhed gennem den bredest mulige generalisering
indser vi, at man faktisk kan lade basistilfældet være et tomt t˚arn, n = 0. Bemærk,
at hvis pindene nummereres 1, 2, 3, og i og j er to af pindene, bliver 6 − i − j nummeret p˚a
den tredje pind.
fun hanoi (0, , ) =
| hanoi (n,fra,til)
= let val tredje = 6 - fra - til
in hanoi (n - 1,fra,tredje)
^ Int.toString fra ^ ---> "^ Int.toString til ^ "\n"
^ hanoi (n - 1,tredje,til)
end
3 Den franske matematiker Edouard Lucas, som lancerede spillet i 1883, ledsagede det af følgende skrøne:
Ved tidernes begyndelse opstillede Gud “Brahmas t˚arn” med 64 skiver af det pure guld og tre diamantn˚ale,
og han forordnede, at en gruppe munke skulle flytte dem over p˚a en af de andre n˚ale efter de nævnte regler.
Munkene arbejder uophørligt dag og nat p˚a opgaven, og n˚ar den er løst, vil t˚arnet falde sammen og jorden
g˚a under.
86

Funktionen hanoi (n,i,j) genererer som en tekst de træk, der skal til for at flytte
n skiver fra pind i til pind j. Den bedste m˚ade at f˚a trækkene at se p˚a er at kalde
print (hanoi (n,1,2)) p˚a yderste niveau (print bliver forklaret nærmere i kapitel 7).
Prøv at indtaste og køre programmet.
5.6.2 Egenskaber og definitioner
N˚ar en egenskab ophøjes til definition, g˚ar det enten godt eller grumme galt. Her er et eksempel
p˚a det sidste: Ligning (5.4) (nu for alle hele tal n ≥ 1) kan formuleres som egenskaben
n! =
(n + 1)!
n + 1
(5.6)
gældende for alle naturlige tal n. Man kan sige, at det var denne egenskab, vi sørgede for at
opretholde i definitionen af 0!. Ophøjes (5.6) til definition
fun fakultet’ n = fakultet’ (n + 1) div (n + 1); (5.7)
finder man imidlertid
fakultet’ 3 ❀ fakultet’ 4 div 4
❀ fakultet’ 5 div 5 div 4
❀ fakultet’ 6 div 6 div 5 div 4 ❀ ...
og det er klart, at fakultet’ 3 ❀ ⊥.
Den indledende bemærkning om, at det enten g˚ar “godt” eller “grumme galt”, kan mere
præcist formuleres
Antag, f er en funktion, om hvilken der gælder en egenskab af formen
f x = . . ., og at denne egenskab ophøjes til definition. For hvert aktuelt
argument a vil beregningen af f a da enten finde den korrekte
funktionsværdi eller g˚a i uendelig løkke.
Tager man alts˚a for eksempel en eller anden egenskab n! = . . ., hvor n og ! kan indg˚a
p˚a højre side, og bruger den til definition af fakultet, vil der for hvert tal n enten gælde
fakultet n ❀ n! eller fakultet n ❀ ⊥.
5.7 Kaldtræer
Den sidstnævnte mulighed: at en beregning g˚ar i uendelig løkke, prøver man naturligvis at
undg˚a. Mere almindeligt er man interesseret i, at en beregning ud over at være korrekt ogs˚a
forløber effektivt, det vil sige ikke tager unødigt lang tid og i øvrigt har et lavt ressourceforbrug.
Et af de forhold, som har stor betydning for, hvor lang tid et funktionskald tager, er,
hvilke andre funktionskald det giver anledning til. Dette kan bekvemt vises i et s˚akaldt
kaldtræ, hvor man lader et funktionskald f x svare til et punkt (en s˚akaldt knude i træet)
og for hvert indre funktionskald g y, som f x direkte giver anledning til, tegner en streg
(en s˚akaldt kant i træet) fra knuden for f x ned til en ny underliggende knude for g y.
87

fakultet 4
fakultet 3
fakultet 2
fakultet 1
fakultet 0
fakultet’ 4
fakultet’ 5
fakultet’ 6
Figur 5.2: Kaldtræerne for fakultet 4 og for fakultet’ 4
Figur 5.2 viser kaldtræerne for fakultet 4 og for fakultet’ 4; sidstnævnte træ er
uendeligt — som billede p˚a, at beregningen ikke standser.
For at vise, kaldtræer kan forgrene sig, betragtes et kombinatorisk eksempel: Antallet
af m˚ader, hvorp˚a en mængde med n elementer kan inddeles i netop k delmængder (ingen
af dem tomme) skrives { n k} og kaldes Stirlingtallet af anden art af n og k. Med simple
kombinatoriske ræsonnementer kan man indse følgende identiteter:
{ n n} = 1 { n 0} = 0 for n > 0
{ n k} = k · { n−1
k } + {n−1 k−1 } for 0 < k < n
som man kan bygge en funktionsdefinition p˚a:
fun stirlto (n, k)
= if k = n then 1
else if k = 0 then 0
else k * stirlto (n - 1, k) + stirlto (n - 1, k - 1);
val stirlto = fn : int * int -> int
Uden at komme nærmere ind p˚a, hvilke værdier funktionen har, kan vi se, at dens kaldtræ
for argumentparret (4,2) er som vist i figur 5.3.
{ 4 2}
✘✘
✘✘✘
{ 3 ❳ ❳❳❳❳
2}
{ 3 1}
✟
✟✟
{ 2 ❍
❍❍
2} { 2 ✟
✟✟
1} { 2 ❍
❍❍
1} { 2 0}
{ 1 1}
❅
{ 1 0}
{ 1 1}
❅
{ 1 0}
Figur 5.3: Kaldtræet hørende til { 4 2}.
Læg mærke til, at funktionskald som for eksempel { 1 1} forekommer flere gange; for større
værdier af n og k vil der være overordentlig mange gentagelser i kaldtræet.
88
.

At beregne samme funktionskald flere gange er naturligvis spild af tid (resultatet m˚a
nødvendigvis blive det samme hver gang), men med de dele af ML, vi har mødt indtil nu,
er det meget vanskeligt at undg˚a de gentagne kald — det bliver lettere, n˚ar lister og andre
strukturerede værdier st˚ar til r˚adighed.
Spørgsm˚alet om at konstruere funktioner effektivt vender vi tilbage til i kapitel 11.
5.8 Opgaver
Opgave 5.1 Skriv en funktion, som for et helt tal n beregner det største hele tal m, for
hvilket m 2 ≤ n. Der er ikke noget krav om, at funktionen skal være særlig snedig eller
effektiv.
Opgave 5.2 Antallet af delmængder med k elementer af en mængde med n elementer
betegnes ( n k) (læses: n over k) og kaldes ogs˚a antallet af k-kombinationer af n elementer.
Symbolet ( n k) defineres for alle hele tal n og k, og simple kombinatoriske ræsonnementer
(som det ikke er opgaven at gennemføre her) viser identiteterne (5.8) og (5.9):
( n k) =
( n k) =
0 hvis k < 0 eller k > n
n!
k!(n−k)!
⎧
⎪⎨ 0
1
⎪⎩
hvis 0 ≤ k ≤ n
hvis k < 0 eller k > n
hvis 0 = k ≤ n eller 0 ≤ k = n
) hvis 0 < k < n
( n−1
k
) + (n−1
k−1
P˚a grund af ligning 5.9 kan kombinationer stilles op i Pascals trekant:
( 0 0)
( 1 0) ( 1 1)
( 2 0) ( 2 1) ( 2 2)
( 3 0) ( 3 1) ( 3 2) ( 3 3)
( 4 0) ( 4 1) ( 4 2) ( 4 3) ( 4 4)
. . .
=
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
. . .
(5.8)
(5.9)
Betragt de to definitioner (5.8) og (5.9) som givet, og skriv funktioner til beregning af
antallet af k-kombinationer af n elementer i henhold til b˚ade den ene og den anden definition.
Afprøv funktionerne og konstater derved, at der er tal n og k, for hvilke (5.9) kan beregne
( n k), mens (5.8) giver overløb. Hvordan kan det forklares?
Tegn kaldtræet for ( 4 2) beregnet med den funktion, som følger (5.9).
Opgave 5.3 Man kan bevise, to tals største fælles divisor altid kan udtrykkes som en
linearkombination med hele koefficienter af de to tal, og opgaven er at skrive en funktion til
beregning af disse koefficienter. Mere konkret: Funktionen gcd fra afsnit 3.5.2 skal udbygges,
s˚a den for to naturlige tal a og b, der ikke begge er 0, finder to hele tal s og t, s˚adan at
s · a + t · b = gcd (a,b) (5.10)
89

Her er nogle vink til opgaven:
Operatorerne til heltalsdivision er valgt s˚adan, at der altid gælder
b = b div a * a + b mod a
Den nye funktion kan defineres rekursivt og følge nogenlunde samme skabelon som for
den oprindelige gcd-funktion.
I basistilfældet a = 0, hvor gcd (0,b) = b, er det let at konstruere s og t.
I det rekursive tilfælde, hvor gcd (a,b) blev bestemt ud fra gcd (b mod a,a), kan man
p˚a tilsvarende m˚ade konstruere s og t i (5.10) ud fra s ′ og t ′ , for hvilke
s ′ · (b mod a) + t ′ · a = gcd (b mod a,a)
Opgave 5.4 Løs denne opgave, n˚ar typen af lister er til r˚adighed. Læg mærke til, hvordan
den mindste skive bevæger sig under løsning af puslespillet “Hanois t˚arn”: Hvert andet træk
foreg˚ar med den mindste skive. Hvilken systematik er der i disse træk? Bemærk ogs˚a, at et
træk er entydigt bestemt, hvis det ikke er den mindste skive, som skal flyttes. Benyt disse
iagttagelser til at programmere en løsning p˚a puslespillet.
90

Kapitel 6
Højereordensfunktioner
En funktion, der tager argumenter af type α og har funktionsværdier af type β, har type
α → β. En konsekvens af det allerede i afsnit 2.3 nævnte forhold, at funktioner regnes for
værdier p˚a linje med tal, tegn, tekster, tupler og alle andre størrelser, er, at argumenttypen
α eller funktionsværditypen β selv igen kan være en funktionstype.
Hvis det er tilfældet, siges funktionen at være af højere orden (eng.:higher order). Hvad
mulighederne for højereordensfunktioner indebærer, undersøger vi i dette kapitel, idet vi
først betragter funktioner med funktioner som værdi og derefter funktioner med funktioner
som argument.
6.1 Funktion som funktionsværdi
I et af eksemplerne i afsnit 3.3 betragtedes udtrykket
bogpris - bogpris * rabatpct div 100
der b˚ade afhænger af bogpris og af rabatpct. Opfattes en bogs reelle pris for en studerende
som funktion af bogpris, er der tale om en parametriseret funktion med rabatpct som
parameter. Denne opfattelse afspejles i definitionerne
fun studpris rabatpct
= let fun pris bogpris = bogpris - bogpris * rabatpct div 100
in pris end;
val studpris = fn : int -> int -> int
studpris 10;
val it = fn : int -> int
it 31000;
val it = 27900 : int
(studpris 10) 50000;
val it = 45000 : int
(studpris 12) 50000;
val it = 44000 : int
Her er studpris en funktion, defineret med rabatpct som formel parameter, men med
en funktionsværdi, lokalt benævnt pris, der selv er en funktion (defineret med bogpris som
formel parameter).
91

N˚a vi derfor kalder studpris med argument 10, kan resultatet af dette funktionskald
ikke direkte vises frem, for det er selv en funktion (af type int -> int). Men kaldes denne
funktion (her med argumentet 31000), f˚as et synligt resultat (her 27900).
Som de to sidste eksempellinjer viser, kan man ogs˚a levere de to argumenter (rabatpct
og bogpris) p˚a en gang.
6.1.1 Parentesregler ved funktionskald og funktionstype
Vi har set, hvordan studpris skal kaldes p˚a formen (studpris r) p, idet den har typen
studpris : int -> (int -> int). I afsnit 2.3.2 blev det imidlertid nævnt, at funktionsanvendelse
er venstreassocierende. N˚ar funktionen kaldes, er parentesen derfor overflødig,
og man kan bare skrive studpris r p. Det er derfor ogs˚a besluttet, at parentesen i typebeskrivelsen
skal kunne undværes: studpris : int -> int -> int. Med andre ord gælder 1 ,
at
Funktionstypepil associerer fra højre.
Vi s˚a i eksemplet ovenfor, hvordan SML-systemet benyttede denne konvention, idet funktionsdefinitionen
blev besvaret med ekkoet val studpris = fn : int -> int -> int.
6.1.2 Sekventialisering
Med nøjagtig samme betydning som i definitionen ovenfor tillader SML ogs˚a, at man skriver
fun studpris rabatpct bogpris
= bogpris - bogpris * rabatpct div 100
val studpris = fn : int -> int -> int
Her er et andet eksempel: Anvendt p˚a det reelle tal d vil funktionen foroeg som funktionsværdi
give den funktion, der forøger sit reelle argument med d.
fun foroeg d r = r + d : real;
val foroeg = fn : real -> real -> real
foroeg 0.5;
val it = fn : real -> real
foroeg 0.5 2.0;
val it = 2.5 : real
(En lille advarsel om syntaks: Selv om man ved funktionskald frit kan vælge, om parenteserne
skal skrives eller underforst˚as ((studpris 10) 31000 eller studpris 10 31000),
s˚a er den slags parenteser forbudt i en funktionserklæring. Definitionen af Standard ML
kræver, at funktionsnavnet følger umiddelbart efter det reserverede ord fun.)
1 Det kan umiddelbart virke ulogisk, at funktionstypepil associerer i den modsatte retning af de operatorer,
vi hidtil har mødt. Et andet sted, hvor retningen virker forkert, er ved funktionssammensætning: Den
sammensatte funktion g ◦ f er som bekendt den, der i punktet x har værdien (g ◦ f)(x) = g(f(x)), s˚a at g ◦ f
skal læses fra højre: først f, s˚a g. Miseren kan siges at stamme fra, at det fra først af var forkert at notere
funktionen f anvendt p˚a argumentet x som f(x); man skulle, som det gøres i visse matematiske kredse, have
skrevet (x)f. Sammensat funktion ville derved blive ((x)f)g, og en funktion, der for argumenter af type α
leverede funktioner fra β til γ, ville f˚a type (γ ← β) ← α, i begge tilfælde fint læsbare fra venstre.
92

En funktion, der p˚a denne m˚ade “tager sine argumenter et ad gangen”, vil vi kalde
sekventialiseret (eng.:curried) (efter den engelske logiker Haskell Brooks Curry 2 (1900–82)).
6.1.3 Funktion af tupel eller sekventialiseret funktion?
Det er tidligere blevet nævnt, at SML kun kan h˚andtere funktioner af én variabel, og
vi har hidtil dannet funktioner, der tilsyneladende havde flere variable, ved at lade dem
være funktioner, hvis argument var et tupel. Sekventialiserede funktioner er imidlertid ogs˚a
funktioner af flere variable: Der skal kun et øjebliks overvejelse til for at indse, at noget, der
forelagt et argument giver en funktion fra et andet argument til en værdi, jo netop svarer
til en funktion, der fra et argument og et andet argument leverer værdien.
Det er instruktivt at sammenligne foroeg med en funktion, der tager de to parametre
p˚a en gang:
fun adder (d,r) = r + d : real;
val adder = fn : real * real -> real
De to funktioner har naturligvis omtrent samme funktionalitet: for alle reelle værdier
d og r vil foroeg d r = adder (d,r). Forskellen er, at man er nødt til at kende begge
argumenter, før adder kan kaldes, mens foroeg allerede kan kaldes, s˚a snart første argument
foreligger (selv om den først kan give et tal, n˚ar andet argument ogs˚a kendes).
Læg ogs˚a mærke til parallelliteten i type. En funktion, der til argumenter af type α og
β lader svare værdier af type γ har i det ene tilfælde typen α * β -> γ, i det andet typen
α -> β -> γ. Bemærk tillige, at dette i første tilfælde grupperes (α * β) -> γ, i andet
α -> (β -> γ).
Har man brug for en funktion af to variable, er der med andre ord
to forskellige m˚ader at “simulere” dette p˚a i SML (som i realiteten
kun kender begrebet “funktion af én variabel”): Man kan danne en
funktion af et par, eller man kan danne en sekventialiseret funktion,
der kaldt med den ene komponent leverer en funktion af den anden
komponent.
Hvilken af de to metoder er s˚a bedst? Det afhænger af sammenhængen. P˚a en vis m˚ade
er den sekventialiserede form mest generel, for i den kan funktioner bruges p˚a hele tre m˚ader:
helt uden argumenter, med et argument eller med begge argumenter. Funktioner af par kan
kun bruges p˚a to m˚ader: uden eller med argumentpar. Den sekventialiserede form kan ogs˚a
virke mest elegant, fordi man ikke som ved tupler skal gruppere argumenterne med kommaer
og parenteser.
Skal en funktion g levere to resultater, kan det imidlertid kun ske ved, at g returnerer
parret af de to resultater. Skal det sidenhen efterbehandles i sammensætningen f(g . . .), m˚a
f nødvendigvis være en funktion af par.
2 selv om Moses Schönfinkel brugte metoden i en artikel fra 1924 og ideen allerede forefindes i Gottlob
Freges “Grundgesetze der Arithmetik” fra 1893.
93

6.1.4 Operator som funktion
Har man defineret
fun sum (a,b) = a + b;
val sum = fn : int * int -> int
kan 28 - 5 + 3 ogs˚a skrives sum (28 - 5,3), og mere almindeligt er der stor overensstemmelse
mellem operatorer, som skal skrives mellem deres to operander, og funktioner, hvis
argumenter er et par. I SML har man valgt, at disse to begreber dybest set skal være ens:
operatorer opfattes som funktioner, der har par som argumenttype, men som syntaktisk har
f˚aet “infiks-status” i den forstand, at de ikke som normale funktioner kaldes ved at blive
skrevet foran deres argumentpar, men ved at blive skrevet imellem parrets to komponenter.
Denne “infiks-status” ophæves af symbolet “op”; hvis “$” er en operator, kan man alts˚a
i steden for “a $ b” skrive “op $ (a,b)”, og specielt er op + synonym med den ovenfor
definerede funktion sum. Hvis man i en sammenhæng, hvor der skal anføres en funktion
(vi skal senere se eksempler p˚a den slags kontekster), ønsker at bruge en operator $ (med
infiks-status), kan man alts˚a skrive op $.
Uden sine operander er en operator ikke et lovligt udtryk:
+;
! Toplevel input:
! +;
! ^
! Ill-formed infix expression
men funktioner er lovlige værdier, s˚a med op kan man for eksempel se, hvilke typer en
operator forventer af sine operander:
op ^;
val it = fn : string * string -> string
it ("vand","ring");
val it = "vandring": string
6.2 Funktion som funktionsargument
For ML er der intet ekstraordinært i, at en af en funktions parametre selv kan være en
funktion. Som et simpelt eksempel herp˚a kunne man konstruere en funktion, der evaluerede
sin parameter i nulpunktet:
fun nulvaerdi f = f 0.0;
val ’a nulvaerdi = fn : (real -> ’a) -> ’a
load "Math";
val it = () : unit
nulvaerdi Math.sqrt;
val it = 0.0 : real
nulvaerdi Math.exp;
val it = 1.0 : real
94

Som typen (real -> α) -> α viser (parentesen kan ikke undværes), skal nulvaerdi
kaldes med et argument af type real -> α. Her er en af de situationer, hvor man kan have
glæde af, at foroeg er sekventialiseret:
nulvaerdi (foroeg ~0.6)
val it = ~0.6 : real
(Parentesen kan ikke undværes.)
Som et andet eksempel konstrueres en funktion, der danner b i=a f(i), det vil sige
f(a) + f(a + 1) + . . . + f(b − 1) + f(b)
fun sum (f,a,b)
= if a > b then 0.0 else f a + sum (f,a+1,b);
val sum = fn : (int -> real) * int * int -> real
sum (real,1,10);
val it = 55.0 : real
Vi regnede med, det ville være mest nyttigt, hvis f kunne have reelle funktionsværdier,
men udbuddet af standardfunktioner af type int -> real er ikke stort. En af dem er real,
der omsætter et heltal til reel type (se figur 2.1), og vi har s˚a fundet summen af tallene fra
1 til 10. Ved at definere et passende f kan vi beregne
fun reciprok n = 1.0 / real n;
val reciprok = fn : int -> real
sum (reciprok,1,100);
val it = 5.18737751764 : real
1 + 1 1 1
+ + . . . +
2 3 100
Undertiden er det naturligt at kombinere funktioner som argument med sekventialisering.
Som et afsluttende eksempel defineres den funktion until af tre argumenter, for hvilken
until p f x gennemg˚ar følgen x, f(x), f(f(x)), f 3 (x), . . . og som funktionsværdi har det
første element, der opfylder p. Her tænker vi os, p er et s˚akaldt prædikat, det vil sige en
funktion med bool som resultattype. Et element f i (x) siges at opfylde p, hvis p(f i (x))
bliver true.
fun until p f
= let fun g x = if p x then x else g (f x)
in g end;
val ’a until = fn : (’a -> bool) -> (’a -> ’a) -> ’a -> ’a
Med until er formuleret en meget generel skabelon, der passer p˚a mange approksimationsproblemer.
Man kan for eksempel vise, at hvis x er en tilnærmelse til √ a
x+ x a, vil 2 være
en bedre tilnærmelse. Vi kan derfor bruge until til en beregning af √ 5 med stor nøjagtighed:
95

fun godnok x = abs (x * x - 5.0) < 1E~4
fun naeste x = (x + 5.0 / x) / 2.0;
val godnok = fn : real -> bool
val naeste = fn : real -> real
until godnok naeste 1.0;
val it = 2.23606889564 : real
it * it;
val it = 5.00000410606 : real
Man kan more sig med at bruge until til definition af en udgave af fakultetsfunktionen:
fun fak n
= let fun godnok (i, ) = i = n
fun naeste (i,p) = (i+1,(i+1)*p)
in #2 (until godnok naeste (0,1)) end;
val fak = fn : int -> int
fak 7;
val it = 5040 : int
6.3 Anonym funktion
Den funktion, som fører parametermønster over i krop, noteres i SML
fn parametermønster => krop
idet det formelle parametermønster er en pladsholder, hvis forekomster i krop erstattes af
det faktiske argument, n˚ar funktionen kaldes. Med denne form for udtryk, som ogs˚a kaldes
et lambdaudtryk, fordi en udbredt matematisk notation for det er λ parametermønster.krop,
kan man alts˚a arbejde med funktioner uden at være tvunget til at give dem et navn.
Her er for eksempel kvadreringsfunktionen:
fn n => n * n;
val it = fn : int -> int
it 5;
val it = 25 : int
Skal en hjælpefunktion blot bruges som argument til en anden funktion, kan man ofte
spare at give den et navn. Her er et par af de tidligere eksempler med anonyme hjælpefunktioner:
sum (fn n => 1.0 / real n,1,100);
val it = 5.18737751764 : real
until (fn x => abs (x * x - 5.0) < 1E~4)
(fn x => (x + 5.0 / x) / 2.0)
1.0;
val it = 2.23606889564 : real
96

6.3.1 Funktionserklæring med val
At lave en funktion og give den et navn
val fnavn = fn x => krop
er næsten det samme som at levere funktionserklæringen
fun fnavn x = krop
Forskellen ligger i virkefeltsreglerne: Som nævnt i afsnit 3.3 er fnavn til r˚adighed i krop i
andet tilfælde, men ikke i første. Formen med val kan derfor ikke bruges til erklæring af en
rekursiv funktion 3 .
Det er forskellen mellem de to virkefeltsregler i afsnit 3.3, der er afgørende for, om
man skal bruge val eller fun, og ikke spørgsm˚alet om, hvorvidt det er en funktion, der skal
erklæres. Skriver man fun fnavn, s˚a skal der ogs˚a følge et eller flere parametermønstre efter.
Gør der ikke det, skal man bruge val:
val efterfoelger = foroeg 1.0;
val efterfoelger = fn : real -> real
efterfoelger 29.0;
val it = 30.0 : real
Og selv om der bruges fun f x = . . ., kan det godt være, f har andre parametre end x (se
for eksempel definitionen af until).
6.4 Sammenfatning
I SML er funktioner specielle værdier, og overalt, hvor der skal bruges en type, kan det
specielt være en funktionstype.
Alle funktioner har ét argument. Hvis argumentet har type τ og funktionsværdien type
τ ′ , har funktionen type τ → τ ′ . Effekten af flere parametre kan opn˚as ved at lade argumentet
være et tupel, s˚a funktionens type bliver τ1 * . . . * τn -> τ, eller ved at lade funktionen
være sekventialiseret, med type τ1 -> . . . -> τn -> τ.
En funktion skal kaldes i overensstemmelse med sin erklæring; er argumentet et tupel, skal
man bruge parenteser og kommaer; er funktionen sekventialiseret, tager den sine argumenter
et ad gangen, og de skal bare skrives efter hinanden.
Operatorer er funktioner, der har f˚aet syntaktisk infiks-status. Nøgleordet op (som binder
stærkere end nogen anden sprogkonstruktion) ophæver en operators infiks-status, s˚a den i
stedet bliver en funktion af par.
Hvis en funktion ikke er rekursiv, behøver man ikke at give den et navn, men kan i stedet
bruge notationen fn mønster => krop.
Erklærer man en funktion uden at anføre et parametermønster, skal nøgleordet være
val.
3 I den formelle definition af Standard ML indeholder det s˚akaldte “kernesprog” kun erklæringer med
val, idet “fun fnavn x = krop” opfattes som en “afledt form” ækvivalent med
“val rec fnavn = fn x => krop”, hvor rec signalerer den ønskede variant af virkefeltsreglerne.
97

Selv om en erklæring benytter val, kan det godt være,
den erklærer en funktion.
Det er unødvendigt at skrive parametermønstre, som ikke bruges.
6.5 Opgaver
Selv om en fun-erklæring benytter et vist antal formelle
parametermønstre, kan det godt være, den erklærede
funktion har flere parametre end dem.
Opgave 6.1 Brug sum til at beregne summen af kvadrattallene fra 1 2 til 10 2 .
Opgave 6.2 Generaliser den metode, som i afsnit 6.2 blev brugt til beregning af en tilnærmet
værdi af √ 5, s˚a der defineres en kvadratrodsfunktion.
Opgave 6.3 Definer en sekventialiseret funktion, der beregner differenskvotienten
f(x + h) − fx
h
Funktionen skal tage sine tre variable i rækkefølgen først h, s˚a f, og sidst x.
Opgave 6.4 Definer deriv som værdien af funktionen defineret i foreg˚aende opgave i
punktet, hvor h er en titusindedel. For “pæne” funktioner f vil deriv f være en god tilnærmelse
til differentialkvotienten f ′ .
Opgave 6.5 Newtons metode til bestemmelse af et nulpunkt for en funktion f g˚ar ud p˚a,
at hvis y er en tilnærmelse til roden, bliver y − f(y)
f ′ en bedre tilnærmelse. Den formel for
(y)
tilnærmelse til kvadratrødder, der blev brugt i afsnit 6.2, opst˚ar ved Newtons metode, idet
man for f(x) = x2 − a f˚ar f ′ (x) = 2x og x − f(x)
f ′ (x) = x − x2 a
−a x+ x = 2x 2 .
Definer en funktion newton ved, at newton f skal være until godnok naeste, hvor
f(x)
godnok tester, om |fx| er mindre end en titusindedel, og naeste x er x −
deriv f x .
Kunne man lade godnok og naeste være anonyme?
Opgave 6.6 Brug funktionen newton fra foreg˚aende opgave til definition af en kubikrodsfunktion.
[Vink: Beregn 3√ a som et nulpunkt for x 3 − a.]
98

Kapitel 7
Tegn, tekster, udskrivning
Hidtil har vi fremstillet det, som om resultaterne fra systemet direkte havde form af tal,
sandhedsværdier, sæt, lister, og s˚a videre, men derved ses der bort fra, at kommunikationen
i virkeligheden foreg˚ar ved hjælp af skærm og tastatur. I transmissionen er indskudt passende
omsætninger mellem ydre og indre repræsentationer, og det er naturligt at opfatte det, der
dannes fra tastaturet, og som fremkommer p˚a skærmen, som tekster opbygget af enkelttegn.
7.1 Typen string af tekster
Hvis man selv vil kunne styre, hvordan resultater præsenteres, er det nødvendigt at kunne
arbejde med tekster i programmerne, og hertil har ML grundtypen string.
Tekstkonstanter blev omtalt i afsnit 3.10.1. I Moscow ML skrives en tekstkonstant som
en følge af nul eller flere tegn mellem et par anførelsestegn ("). De tegn, der kan indg˚a i en
tekstkonstant, er tegnene fra ISO’s 8-bit-alfabet (se tabel 1.2). Bortset fra anførelsestegn og
spejlvendt skr˚astreg kan de grafiske tegn (med andre ord tegnene med koder 32, 33, 35–91,
93–126, 160–255) anføres direkte; dertil kommer nogle særlige betegnelser, hvor spejlvendt
skr˚astreg (eng.:backslash) er brugt som undvigelsestegn, se tabel 7.1.
Form˚alet med konstruktionen \ff . . . f\ nævnt nederst i tabellen er at gøre det muligt
at dele lange tekster over flere linjer: man sætter bare en spejlvendt skr˚astreg sidst p˚a en
linje og forrest p˚a en ny linje — s˚a vil det have samme virkning, som hvis man var fortsat
p˚a samme linje.
Funktionen print skal kaldes med en tekst som argument; selve funktionsværdien er
uinteressant (det tomme sæt), men forinden bliver argumentet som bivirkning overført til
uddata, idet alle opstillingstegn respekteres. P˚a den m˚ade kan man selv bestemme, hvad
der skal komme frem p˚a skærmen — blot kan man ikke slippe for, at der allersidst tilføjes
“> val it = () : unit”:
print;
val it = fn : string -> unit
print "Her\n og\"\nder";
Her
og"
der> val it = () : unit
99

\a tegnet BEL (som f˚ar terminalen til at afgive lyd)
\b tilbagerykningstegn, BS
\t tabuleringstegn, HT
\n linjeskift, LF eller NL
\v vertikal tabulering, VT
\f sideskift, FF
\r vognretur, CR
\^c c skal være et af tegnene med kode mellem 64 og 95, og symbolet
her st˚ar da for det tegn, hvis kode er 64 mindre (se tabel 1.1)
\ddd De tre decimale cifre ddd skal angive et tal mellem 0 og 255, og
symbolet angiver da tegnet med den p˚agældende kode
\uxxxx Her skal xxxx være fire hexadecimale cifre, som angiver et tal mellem
0 og 255, og hele symbolet angiver da tegnet med den p˚agældende
kode
\" Anførelsestegnet selv
\\ Spejlvendt skr˚astreg
\ff . . . f\ Idet ff . . . f mellem de to skr˚astreger st˚ar for et eller flere opstillingstegn
(for eksempel blanktegn, tabuleringstegn, linjeskift, sideskift),
repræsenterer hele konstruktionen en tom følge af tegn.
Tabel 7.1: ML’s særlige symboler for tegn i tekst- og tegnkonstanter.
7.2 Typen char af tegn
I den oprindelige definition [7] af Standard ML m˚atte enkelttegn h˚andteres ved hjælp af
deres koder, men Moscow ML følger revisionen [9] ved ogs˚a at have tegn som grundtype,
under betegnelsen char (eng.:character).
Tegnkonstanter anføres simpelt hen som den tilsvarende tekstkonstant af længde 1, men
med et nummertegn (#) umiddelbart foran. Notationen for et blanktegn er for eksempel #.
En tekst er naturligvis omtrent det samme som en liste af tegn, blot m˚a man forvente, at
systemet kan h˚andtere tekster mere effektivt end generelle lister. Tabel 7.2 viser standardfunktioner
og -operatorer p˚a tegn og tekster, og her finder man netop funktionerne explode
og implode, som etablerer den nævnte korrespondance.
Der er grund til at fremhæve, at selv om Standard ML 1 opfatter de normale symboler
for ordning (=) som virkende p˚a heltal, n˚ar andet ikke er angivet
op bool
s˚a kan de alts˚a ogs˚a anvendes p˚a operander af type real og, som tabellen viser, af typerne
char eller string. (Men de to operander skal have samme type.)
1 Dette blev indført med revisionen i 1997
100

status navn type virkning
ord char -> int tegnets kode eller vægt
chr int -> char tegnet med den p˚agældende
op =
string * string -> bool
char * char -> bool
kode
tegn og tekster kan sammenlignes
med de sædvanlige ulighedstegn.
For tekster bruges
leksikografisk orden
str char -> string teksten best˚aende af det
p˚agældende tegn
op ^ string * string -> string sammenstillen af to tekster
explode string -> char list listen af de tegn, som indg˚ar i
teksten
implode char list -> string teksten med de p˚agældende
tegn i
size string -> int antallet af tegn
String.substring string * int * int
-> string
String.substring (s,i,n)
udtager n p˚a hinanden
følgende tegn fra s regnet fra
det i-te (idet nummerering
begynder med 0)
print string -> unit bivirkning: overføring af argumentet
til uddata
7.3 Typeerklæring
Tabel 7.2: Operatorer og funktioner p˚a tegn og tekster.
Under arbejde med tekster vil typen “char list” ofte optræde. P˚a samme m˚ade kan der
i andre sammenhænge være visse typer, man flere gange f˚ar brug for; i geometriske anvendelser
m˚aske punkter i rummet af type real * real * real. For at det ikke skal være
nødvendigt at gentage komplicerede typeudtryk, indeholder ML muligheden for, at man
med en typeerklæring kan indføre korte navne for typeudtryk. I de nævnte tilfælde kunne
man skrive
type linje = char list;
type linje = char list
type rumpunkt = real * real * real;
type rumpunkt = real * real * real
og i resten af programmet kan linje og rumpunkt bruges som typesynonymer med den
indførte betydning. Forkortelserne benyttes ikke i svar fra systemet. Her er en funktion, der
indsætter blanktegn mellem hvert af en linjes tegn:
fun spatier ([] : linje) : linje = []
| spatier [c] = [c]
| spatier (c :: cr) = c :: # :: spatier cr;
101

val spatier = fn : char list -> char list
implode (spatier (explode "Prøv selv!"));
val it = "P r ø v s e l v !": string
Tabel 7.3 viser typeerklæringers syntaks. Som det ses, kan man ogs˚a indføre typer med
typbind ::= tyvarseq identifier = ty typekonstruktør
tyvarseq ::= uden typeparametre
tyvar med én typeparameter
( tyvar , . . . , tyvar ) med en eller flere typeparametre
Tabel 7.3: Forenklet syntaks for binding af navn til type i ML.
parametre. Man kan for eksempel vælge, at en α matrix skal være en liste af lister af
elementer af type α:
type ’element matrix = ’element list list;
type ’element matrix = ’element list list
og derefter er der mulighed for at skrive int matrix, real matrix, rumpunkt matrix og
s˚a videre.
7.4 Eksempler
7.4.1 Majuskler
Lad os overveje, hvordan et program kan omforme en tekst, s˚a sm˚a bogstaver erstattes af
store. For at f˚a adgang til de enkelte tegn i teksten m˚a den ændres til en liste af tegn,
s˚a en delopgave m˚a g˚a ud p˚a at foretage den nævnte ændring p˚a et enkelt tegn. Bogstaverne
mellem a og z ligger samlet, og der er en systematisk forskydning i koden, som vil
transformere dem til store bogstaver A til Z, men æ, ø og ˚a m˚a behandles separat:
fun stort c = if #"a≪= c andalso c

val majuskler = fn : string -> string
majuskler "Side 3/linje 4";
val it = "SIDE 3/LINJE 4": string
7.4.2 Decimale talord
Tal kan repræsenteres som tekster (med fortegn, cifre, decimalpunkt og s˚a videre) eller
som værdier af type int eller real. Nu kan vi skrive funktioner, der omsætter mellem
repræsentationerne, men lad os for nemheds skyld nøjes med ikke negative hele tal.
N˚ar en følge af cifre skal tolkes som et tal, er det nyttigt at gøre sig klart, at det er en
konsekvens af den sædvanlige titalsnotation, at hvis et talord med m + n cifre deles i to
talord med henholdsvis m og n cifre:
m+n
dd . . . d
dd . . . d
m n
s˚a er der følgende simple sammenhæng mellem talværdierne:
værdien af
m+n
dd . . . ddd . . . d = værdien af dd . . . d
m
· 10 n + værdien af dd . . . d
n
Denne sammenhæng gælder endda for m = 0 eller n = 0, hvis man lader værdien af en tom
cifferfølge være 0.
Omsætning fra et tal til en følge af cifre kan nu programmeres, og derved kan man ogs˚a
komme fra tal til talord. Vi udnytter, at cifrene i tegnsættet ligger samlet i rækkefølge, s˚a
man systematisk med udtrykket chr (ord #"0"+ d) kan komme fra værdien d til cifferet
med den værdi:
fun divmod (a,b) = (a div b,a mod b);
val divmod = fn : int * int -> int * int
fun tilciffer n = chr (ord #"0"+ n);
val tilciffer = fn : int -> char
fun tilcifre n
= if n = 0 then []
else let val (q,r) = divmod (n,10)
in tilcifre q @ [tilciffer r] end;
val tilcifre = fn : int -> char list
fun tiltekst n = if n < 0 then -"^ implode (tilcifre (~ n))
else if n = 0 then "0"
else implode (tilcifre n);
val tiltekst = fn : int -> string
tiltekst 0;
val it = "0": string
tiltekst 007;
val it = "7": string
103

I tiltekst fanges 0 som et særtilfælde, s˚a det ikke bliver skrevet ud som en tom tekst,
: string, og negative talord vises med almindelig bindestreg (-) som minus-tegn. Som
tidligere nævnt rummer modulet Int en tilsvarende funktion Int.toString (der dog bruger
~ som minus-tegn).
Vil man bruge denne metode i modsat retning, skal man kunne dele en liste op i en
forreste del og et sidste element. Det kan for eksempel skrives s˚aledes, idet vi supplerer
List.last med en funktion, der tager resten af listen p˚anær sidste element:
fun init xr = rev (tl (rev xr));
val init = fn : ’a list -> ’a list
fun fraciffer c = ord c - ord #"0";
val fraciffer = fn : char -> int
fun fracifre dr
= if null dr then 0
else fracifre (init dr) * 10 + fraciffer (List.last dr);
val fracifre = fn : char list -> int
fun fratekst s = fracifre (explode s);
val fratekst = fn : string -> int
fratekst "007";
val it = 7 : int
Hvis man vil opspalte teksten i et forreste ciffer og halen, er det hensigtsmæssigt at
beregne de tilhørende vægte sideløbende med tallene. For hvert nyt ciffer foran skal vægten
ganges med 10, og den nye værdi findes ud fra den gamle ved tilføjelse af cifferet, men vægtet
med den gamle vægt:
fun vaegtOgVaerdi [] = (1,0)
| vaegtOgVaerdi (d :: dr) = let val (v,n) = vaegtOgVaerdi dr
in (v * 10,fraciffer d * v + n) end;
val vaegtOgVaerdi = fn : char list -> int * int
fun fratekst s = #2 (vaegtOgVaerdi (explode s));
val fratekst = fn : string -> int
fratekst "007";
val it = 7 : int
Det bør i øvrigt bemærkes, at modulet Int indeholder en funktion Int.fromString til
omsætning fra tekst til heltal, s˚a man behøver ikke selv at programmere funktioner som
fratekst ovenfor. Int.fromString kan oven i købet ogs˚a h˚andtere fortegn.
7.4.3 Opstilling
Man f˚ar ofte brug for at stille en tekst op i et felt med en bestemt bredde, for eksempel venstrestillet
eller højrestillet i feltet eller i midten. Her er en funktion, der venstrestiller en tekst,
hvor vi indfører en hjælpefunktion, der danner en liste af blanktegn, og en hjælpestørrelse,
der holder styr p˚a, hvor meget af det afsatte felt der er ledigt:
fun ljustify (w,s)
104

= let fun blanke n = if n = 0 then [] else # :: blanke (n-1)
val restlaengde = w - size s
in s ^ implode (blanke restlaengde) end;
val ljustify = fn : int * string -> string
ljustify (5,"˚Ar");
val it = "˚Ar ": string
Lad os til sidst konstruere en funktion, der giver en grafisk fremstilling af et talsæt som
histogram eller søjlediagram med liggende søjler; noget i retning af
********************
***********
**************
******************
**********************************
****************
****
Hvis tallenes størrelsesorden ikke er kendt p˚a forh˚and, vil det være praktisk at normere
dem, for eksempel s˚adan at den længste søjle fylder hele tekstens bredde.
For at give programmet større anvendelighed indføres tekstens bredde som en konstant
— s˚a skal man kun ændre ét sted, hvis den skal laves om.
Tallene behøver ikke at være hele, men vi vil g˚a ud fra, intet af dem er negativt. Funktionen
soejler danner en liste af søjler ud fra en liste af heltal, og det endelige diagram f˚as
ved, at man skyder et linjeskift-tegn ind efter hver søjle:
val bredde = 50 (* maksimale søjlestørrelse er global konstant *);
val bredde = 50 : int
fun max (x : real,y : real) = if x < y then y else x;
val max = fn : real * real -> real
fun maximum [] = 0.0
| maximum (tal :: talliste) = max (tal,maximum talliste);
val maximum = fn : real list -> real
fun normer talliste
= let val stoerste = maximum talliste
fun norm [] = []
| norm (t :: tr) = round (t / stoerste * real bredde)
:: norm tr 2
in norm talliste end;
val normer = fn : real list -> int list
fun soejle n = if n = 0 then [] else #"*":: soejle (n - 1);
val soejle = fn : int -> char list
fun soejler [] = []
| soejler (n :: nr) = soejle n :: soejler nr;
val soejler = fn : int list -> char list list
2 Husk, at reglerne for prioritet og associering indebærer, at højresiden grupperes som
(round((t/stoerste)*(real bredde)))::(norm tr).
105

fun histogram talliste
= let val soejleliste = soejler (normer talliste)
fun vis [] = []
| vis (s :: sr) = s @ [#"\n"] @ vis sr
in implode (vis soejleliste) end;
val histogram = fn : real list -> string print (histogram [25.0,2.0,15.0,16.0,9.
**************************************************
****
******************************
********************************
*******************
*************
*******
*****
****
**
*
val it = () : unit
7.5 Listefunktionalen map
N˚ar man arbejder med lister, f˚ar man meget ofte brug for skabelonen
fun F [] = []
| F (x :: xr) = f x :: F xr;
(7.1)
Ud fra en funktion f, der virker p˚a elementer, dannes en ny funktion F , som skal anvende
f p˚a hvert element i en liste. Hvis f har type α -> β, f˚ar F type α list -> β list, og
vi har alts˚a
F [a1, a2, ..., an] = [fa1, fa2, ..., fan]
Man kan opfatte F som en funktion af f, og sammenhængen findes foruddefineret i
Moscow ML under navnet map; der gælder med andre ord F = map f. Resultatet af
kaldet map f er s˚aledes en funktion, der skal have en liste som argument.
Med andre ord er map en funktion af to variable: den funktion, hvis virkning skal “løftes
fra elementer til lister”, og den liste, for hvilken dette skal gøres. Da disse to argumenter
ofte ikke vil foreligge samtidigt, har man valgt at lade map være en sekventialiseret funktion,
der tager sit funktionsargument først.
Man ville sagtens selv kunne definere funktionen:
fun map f [] = []
| map f (x :: xr) = f x :: map f xr
eller lidt mere effektivt (med udnyttelse af, at argumentet f ikke ændres)
fun map f = let fun g [] = []
| g (x :: xr) = f x :: g xr
in g end
106

men det er som nævnt overflødigt: map er tilgængelig som standardfunktion p˚a yderste
niveau.
Funktionen store i afsnit 7.4.1 og funktionen soejler i afsnit 7.4.3 fulgte skabelonen
(7.1). Vi kunne med andre ord i afsnit 7.4.1 have sparet os definitionen af store og
brugt map stort i stedet for; hovedfunktionen kunne have været defineret:
fun majuskler s = implode (map stort (explode s));
val majuskler = fn : string -> string
P˚a samme m˚ade kunne man i afsnit 7.4.3 have skrevet map soejle i stedet for soejler.
Læg mærke til, at hvis man alligevel vil indføre navnet soejler, men definere funktionen
ved hjælp af map, s˚a er det valgfrit, om man vil tage et listeargument med eller ej:
fun soejler nr = map soejle nr;
val soejler = fn : int list -> char list list
val soejler = map soejle;
val soejler = fn : int list -> char list list
— de to muligheder er helt ækvivalente (matematisk set er f = g hvis og kun hvis f(x) =
g(x) for alle x), men tager man ikke noget argument med, skal der bruges det reserverede
ord val i stedet for fun!
Definitionen af norm fra afsnit 7.4.3 følger ogs˚a omtrent skabelonen (7.1) — den eneste
afvigelse er, at der st˚ar et udtryk “round (t / stoerste * real bredde)”, hvor der efter
skabelonen burde være et kald af en funktion af t.
Man kunne med andre ord opn˚a overensstemmelse med skabelonen ved at definere en
funktion, der afbildede t over i round (t / stoerste * real bredde). Denne funktion
skulle imidlertid kun bruges til dette ene form˚al, og at skulle finde p˚a et navn til den og
bruge selvstændige definitionslinjer p˚a den kan synes et stort apparat at sætte i sving (for
blot at f˚a map’s skabelon til at passe).
For at lette den slags situationer indeholder ML som omtalt i afsnit 6.3 muligheden for,
at man kan arbejde med en funktion uden at give den navn.
I den tidligere kontekst kunne norm have været defineret gennem:
val norm = map (fn t => round (t / stoerste * real bredde))
Sammenfattende kunne hele definitionen
fun normer talliste
= let val stoerste = maximum talliste
fun norm [] = []
| norm (t :: tr) = round (t / stoerste * real bredde)
:: norm tr
in norm talliste end
s˚aledes erstattes af
fun normer talliste
= let val stoerste = maximum talliste
in map (fn t => round (t / stoerste * real bredde))
talliste
end
107

7.6 Sammenfatning
Typerne af tegn og tekster hedder henholdsvis char og string. Tekstkonstanter skrives
med tegnene mellem anførelsestegn; tegnkonstanter som tekster af længde 1, hvor der yderligere
er sat et nummertegn foran. Forskellige særlige koder (med spejlvendt skr˚astreg som
undvigelsestegn) gør det muligt at anføre alle 8-bit ISO-tegn.
Man kan ikke indlægge et linjeskift-tegn i en tekstkonstant ved direkte at skifte linje,
mens konstanten skrives ned; skal et linjeskift-tegn indg˚a i en tekstkonstant, m˚a det skrives
\n. Normalt skal alle dele af en tekstkonstant skrives p˚a samme linje; ved at man lader en
linje slutte med spejlvendt skr˚astreg og næste linje begynde med spejlvendt skr˚astreg, kan
lange tekstkonstanter dog deles over flere programlinjer.
Typeudtryk kan navngives med en typeerklæring.
Hvis f er en funktion, der fører elementer af type τ over i værdier af type τ ′ , vil map f
“løfte” funktionen op til at føre en liste af type τ list over i en lige s˚a lang liste af type
τ ′ list (ved at anvende f p˚a hvert listeelement for sig).
7.7 Opgaver
Opgave 7.1 Skriv en funktion, som for to ikke negative hele tal w og n danner et decimalt
talord for n med foranstillede nuller, s˚a der i alt bruges w positioner.
Opgave 7.2 Skriv en funktion, der udskriver et heltal som et talord, hvor cifrene er grupperet
tre og tre p˚a sædvanlig m˚ade (for eksempel 16.427.244). Udbyg funktionen til en
sekventialiseret funktion af to variable, der som første argument tager det tegn, der skal
bruges som skilletegn (for eksempel punktum, komma eller blanktegn), og som andet argument
heltallet.
Opgave 7.3 Skriv en funktion, der højrestiller en tekst i et felt og en, der midtstiller en
tekst i et felt af given længde.
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
1 6 15 20 15 6 1
1 7 21 35 35 21 7 1
1 8 28 56 70 56 28 8 1
1 9 36 84 126 126 84 36 9 1
1 10 45 120 210 252 210 120 45 10 1
Opgave 7.4 En af opgaverne i kapitel 5 omtalte Pascals trekant. Skriv en funktion, der
for en værdi n giver en centreret opstilling af de første n + 1 linjer af Pascals trekant. For
n = 10 for eksempel “vulkankeglen” vist ovenfor.
108

Opgave 7.5 Mange ting kan g˚a galt i funktionen histogram fra afsnit 7.4.3 (man kan for
eksempel komme til at dividere med 0). Skriv en robust version.
Opgave 7.6 Skriv en funktion, der præsenterer en talliste som søjlediagram med vertikale
søjler.
Opgave 7.7 Funktionen skaler, for hvilken skaler ([x1,. . .,xn],y) = [ x1 xn ,. . ., ], kan
y y
i SML defineres
fun skaler ([], ) = []
| skaler (x :: xr,y) = x / y :: skaler (xr,y)
Definer en hjælpefunktion s p˚a en s˚adan m˚ade, at skaler derefter ville kunne f˚as via
fun skaler (xr,y) = map (s y) xr
Definer til sidst funktionen normer fra afsnit 7.4.3 ved hjælp af skaler. [Vink: Slut af med
map round.]
109

110

Kapitel 8
Naïv sortering
For at opn˚a lidt erfaring i at h˚andtere lister vil vi i dette kapitel arbejde med et klassisk problem
inden for databehandling: sortering. At sortere en liste vil sige at omordne (permutere)
den, s˚a elementerne kommer i voksende rækkefølge. (Hvis gentagelser skal være tilladt, m˚a
man nøjes med at kræve ikke-aftagende rækkefølge.)
Det kriterium, der sorteres efter, kan i princippet være en hvilken som helst ordningsrelation,
og resultatet er entydigt fastlagt, hvis ordningen er total (i den forstand, at der for
to vilk˚arlige elementer x og y enten gælder x < y, x = y eller x > y). Ofte vil elementerne
være sammensatte værdier, og ordningen vil være fastlagt af en eller flere heltallige koder,
der indg˚ar i disse værdier (s˚asom personnummer, kontonummer, dato, osv.), men andre eksempler
er sortering af flydende talværdier (real), alfabetisk sortering af tegn (char) eller
leksikografisk sortering af tekster (string).
I eksempelprogrammerne vil vi g˚a ud fra, man skal sortere en liste af heltal, s˚a de bliver
placeret efter ikke-aftagende størrelse.
8.1 Naboombytning
En simpel ide til ordning af en liste er at lede efter to naboelementer x og y, hvor x st˚ar lige
foran y, men x > y, og bytte dem om, s˚a de kommer til at st˚a rigtigt.
Funktionen bytvh undersøger alle s˚adanne par af naboer i en liste og ombytter dem, hvis
de st˚ar forkert, idet den løber listen en gang igennem:
fun bytvh (x :: y :: xr)
= if x > y then y :: bytvh (x :: xr)
else x :: bytvh (y :: xr)
| bytvh xr = xr
Mønsteret x :: y :: xr passer p˚a alle lister med mindst to elementer, s˚a funktionsdefinitionens
sidste linje fanger lister af længde nul eller et (hvis elementer jo altid st˚ar rigtigt).
Da funktionen sammenligner de to forreste elementer og eventuelt ombytter dem, før den
rekursivt bearbejder den nye haleliste, kan man sige, at gennemløbet foretages fra venstre
mod højre.
Man kan ogs˚a skrive en ombytningsfunktion, som løber listen igennem fra højre mod
venstre:
111

fun bythv (x :: (xr as :: ))
= let val y :: yr = bythv xr
in if x > y then y :: x :: yr
else x :: y :: yr
end
| bythv xr = xr
Her har vi med synonymet :: sørget for, at parameteren xr ikke er tom, s˚a at
x :: (xr as :: ) igen er en liste med mindst to elementer.
For at sortere en liste er et enkelt naboombyttende gennemløb ikke tilstrækkeligt, men
gentager man den slags gennemløb, vil listen før eller siden blive sorteret. Der er flere m˚ader
at afgøre p˚a, hvor mange gennemløb der skal til:
1. For en liste af længde n vil n − 1 gennemløb altid være tilstrækkeligt. (I værste fald
flytter et gennemløb kun et forkert placeret element en enkelt plads, men intet element
skal flyttes længere end fra den ene ende af listen til den anden.)
2. I bytvh xr vil det største element i xr med sikkerhed være blevet placeret helt til
højre (og i bythv xr vil det mindste element i xr være placeret helt til venstre). Man
kunne derfor nøjes med at lade de fortsatte gennemløb virke p˚a den resterende liste
uden det bageste (forreste) element.
3. Hvis der i et gennemløb med bytvh (eller bythv) ingen ombytninger har været foretaget,
st˚ar alle elementer rigtigt, og man behøver ikke at løbe flere gange igennem.
Hver af de tre egenskaber kunne bruges som grundlag for programmering af en sorteringsfunktion,
men det er instruktivt at se, hvordan vi kan basere os p˚a egenskab 3. Der er
i s˚a fald brug for at udbygge bytvh (eller bythv) til funktioner, der ikke kun returnerer en
liste, men ogs˚a en indikation af, hvorvidt der skete ombytninger under gennemløbet.
Det kan gøres p˚a følgende m˚ade:
fun bytvh2 (x :: y :: xr)
= if x > y then (y :: #1 (bytvh2 (x :: xr)),true)
else let val (yr,b) = bytvh2 (y :: xr)
in (x :: yr,b) end
| bytvh2 xr = (xr,false)
fun bythv2 (x :: (xr as :: ))
= let val (y :: yr,b) = bythv2 xr
in if x > y then (y :: x :: yr,true)
else (x :: y :: yr,b)
end
| bythv2 xr = (xr,false)
Rent programmeringsteknisk er det værd at bemærke konstruktionerne i definitionen af
bytvh2 (x :: y :: xr): Kald af funktionen returnerer et par; er der kun brug for første
komponent af parret, kan vi udvælge den med #1; skal vi derimod bruge parret med en
modificeret førstekomponent, pakkes det først ud til mønsteret (yr,b), hvorefter man kan
returnere (x :: yr,b). (At konstruere denne sidstnævnte værdi
(x :: #1 (bytvh2 (y :: xr)),#2 (bytvh2 (y :: xr))) ville indebære to kald af samme
funktion med samme parametre og være urimelig ineffektivt.)
112

8.2 Boblesortering
Sorteringsmetoder, der baserer sig p˚a naboombytninger, kaldes boblesortering (eng.:bubble
sort). Med bytvh2 til r˚adighed er det let at programmere s˚adan en funktion:
fun boblesort xr = let val (yr,b) = bytvh2 xr
in if b then boblesort yr else yr end
(Da not b indebærer, at xr og yr er ens, kunne man lige s˚a godt have skrevet
“else xr end” her til sidst.)
I dette program kunne man have brugt bythv2 i steden for bytvh2, og i s˚a fald kunne
man endda nøjes med at lade det rekursive kald virke p˚a den nye hale. (At programmere
den beskrevne variant er stillet som en opgave.)
Man kan vise, at boblesortering ikke er nogen god metode — det bedste ved den er
faktisk navnet. Bedre sorteringsmetoder skal ombytte elementer, der ikke nødvendigvis er
naboer, men kan st˚a længere fra hinanden. Vi slutter kapitlet af med omtale af to s˚adanne
metoder, som dog heller ikke er optimale.
8.3 Indsættelsessortering
Ideen bag denne metode er at tage en listes elementer i betragtning et ad gangen og efter tur
indsætte dem p˚a rette plads i dellisten af allerede sorterede elementer. Der bliver derfor brug
for en hjælpefunktion, som kan indsætte et element i en liste af allerede ordnede elementer:
(* I kald af formen indsaet (x,xr) skal xr allerede være sorteret *)
fun indsaet (x,[]) = [x]
| indsaet (x,xr as y :: yr)
= if x > y then y :: indsaet (x,yr) else x :: xr
Indsættelsessortering bygger p˚a denne hjælpefunktion:
fun indssort [] = []
| indssort (x :: xr) = indsaet (x,indssort xr)
Undervejs i indsættelsessortering er den oprindelige liste delt op i en sorteret og en
usorteret del, og elementer flyttes et ad gangen fra den usorterede til den sorterede del. Ved
bare at tage det forreste af de usorterede elementer lægges størstedelen af arbejdet (det,
indsaet foretager) i korrekt indplacering i den sorterede del.
8.4 Udtagelsessortering
Den i en vis forstand “modsatte” ide er at gøre indplaceringen i den sorterede del enkel p˚a
bekostning af, at valget af “det rigtige” af de usorterede elementer kompliceres.
Dette er netop ideen bag udtagelsessortering, som hele tiden stiller det mindste af de
tilbageværende elementer forrest. For at programmere det bliver der brug for en funktion,
der kan adskille en ikke-tom liste i sit mindste element og de øvrige elementer:
113

fun splitmin [x] = (x,[])
| splitmin (x :: xr)
= let val (y,yr) = splitmin xr
in if x > y then (y,x :: yr)
else (x,xr)
end
Sprogsystemet vil advare os om, at definitionen af splitmin ikke dækker alle parametermønstre
— hvilket er fuldstændig rigtigt, da man ikke kan angive det mindste element i
en tom liste. Vi skal sørge for, at splitmin kun kaldes med ikke-tomme argumentlister:
fun udtsort [] = []
| udtsort xr = let val (y,yr) = splitmin xr in y :: udtsort yr end
8.5 Sammenfatning
At sortere en liste vil sige at permutere dens elementer, s˚a de opfylder en passende ordningsrelation.
Korte lister kan med fordel sorteres med naive metoder, der blot ombytter
elementer. I kapitel 12 vil vi møde metoder, der er effektive for lange lister.
Bedre end boblesortering, som ombytter naboelementer, er indsættelsessortering og udtagelsessortering.
8.6 Opgaver
Opgave 8.1 Programmer en sortering, der virker efter følgende princip: Funktionen bythv
kaldes igen og igen, men hver gang p˚a en liste, der kun er den nye hale af den forrige liste,
idet det udnyttes, at bythv har bragt det mindste element p˚a sin rette plads.
Skriv ogs˚a den variant af funktionen, som slutter af “i utide”, hvis der i et gennemløb
ingen ombytninger er sket.
Opgave 8.2 Programmer en sortering, der skiftevis løber listen igennem med bytvh og
med bythv, idet den efter hvert gennemløb nøjes med at fortsætte med en liste, der er et
element kortere, og alts˚a udnytter, at enten det nye forreste eller det nye bageste element nu
st˚ar rigtigt. Denne variant af boblesortering er blevet kaldt “rystesortering” (eng.:cocktail
shaker sort).
Opgave 8.3 Programmer den variant af udtagelsessortering, hvor det hele tiden er det
største element, der sættes bagest.
114

Kapitel 9
Et større eksempel: kalender
Den tid, det tager jorden at rotere en gang omkring sig selv og igen vende samme punkt
mod solen, g˚ar ikke et helt antal gange op i den tid, jorden er om at gennemløbe sin bane
om solen; forholdet mellem de to tal er 365,24219.
Ønsker man derfor, at ˚arstiderne skal falde p˚a de samme datoer hvert ˚ar, m˚a man ind
mellem ˚ar p˚a 365 døgn skyde enkelte ˚ar med 366 døgn. Sammenhængen mellem et ˚ars datoer
og ugedage kan derved falde ud p˚a 14 forskellige m˚ader, og da disse forskellige kalendere
veksler i et uoverskueligt mønster, er der megen rimelighed i at konstruere et program, der
kan generere kalenderen for et givet ˚arstal.
Under operativsystemet Unix findes faktisk allerede et s˚adant program; det hedder cal
og har (direkte p˚a operativsystem-niveau, alts˚a uden for mosml) et af de to kaldformer
cal m˚aned ˚ar eller cal ˚ar. (Husk alle cifrene i ˚arstallet!)
Vi vil sætte os for at konstruere en tilsvarende funktion i ML, men med m˚aneders og
ugedages navne p˚a dansk og med mandag som ugens første dag (i overensstemmelse med
den gældende standard). Med for eksempel 1998 som inddata ønsker vi p˚a skærmen at se
noget i retning af
januar 1998 februar 1998 marts 1998
ma ti on to fr lø sø ma ti on to fr lø sø ma ti on to fr lø sø
1 2 3 4 1 1
5 6 7 8 9 10 11 2 3 4 5 6 7 8 2 3 4 5 6 7 8
12 13 14 15 16 17 18 9 10 11 12 13 14 15 9 10 11 12 13 14 15
19 20 21 22 23 24 25 16 17 18 19 20 21 22 16 17 18 19 20 21 22
26 27 28 29 30 31 23 24 25 26 27 28 23 24 25 26 27 28 29
30 31
april 1998 maj 1998 juni 1998
ma ti on to fr lø sø ma ti on to fr lø sø ma ti on to fr lø sø
1 2 3 4 5 1 2 3 1 2 3 4 5 6 7
6 7 8 9 10 11 12 4 5 6 7 8 9 10 8 9 10 11 12 13 14
13 14 15 16 17 18 19 11 12 13 14 15 16 17 15 16 17 18 19 20 21
og s˚a videre.
Overordnet vil vi konstruere en funktion kalender, der til 1998 lader svare skærmbilledet
som en lang tekst " januar 1998 februar 1998 . . ."; den ønskede opgave
115

løses s˚a af et kald af formen print (kalender 1998);
Det bliver nødvendigt at dele konstruktionen op i flere faser. Den tekst, vi skal ende
med, er bygget op af 12 rektangulære blokke, der hver igen er bygget op af rektangulære
delblokke. Vist skematisk er strukturen
og s˚a videre
Det vil derfor være nyttigt med nogle funktioner, der kan danne den slags rektangulære
blokke af tegn og bygge dem sammen ved siden af og under hinanden.
For at danne den billedblok, som viser en bestemt m˚aned, er der brug for fire grundoplysninger:
• m˚anedens navn,
• ˚arstallet (til at sætte lige bagefter m˚anedsnavnet),
• hvilken ugedag den første i m˚aneden ligger og
• antallet af dage i m˚aneden.
Lad os kalde s˚adan et sæt af oplysninger for m˚anedsdata.
Vi har nu analyseret os frem til tre delopgaver:
• Ud fra ˚arstallet dannes sættet af m˚anedsdata for hver af de tolv m˚aneder.
• Der skal være en funktion, som konstruerer billedblokken for en m˚aned ud fra m˚anedsdata.
• Der skal være funktioner til at konstruere og sammensætte rektangulære billedblokke
Af disse ingredienser kan funktionen kalender stykkes sammen. De efterfølgende afsnit
vil løse delopgaverne og til sidst konstruere kalender.
116

9.1 Rektangulære billeder
Lad os indføre typen billede som en liste af linjer og lade en linje være en tekst.
type linje = string;
type linje = string
type billede = linje list;
type billede = string list
De funktioner, vi nu skal bygge op, vil blive indrettet efter, at intet af tegnene i en linje vil
være #"\n" (eller et tilsvarende tegn), og at alle linjer i et billede bliver lige lange. Desuden
skal et billede mindst indeholde én linje. (Det er blandt andet s˚adanne begrænsninger, der
gør det berettiget s˚adan at indføre nye navne for best˚aende typer – jævnfør opgave 9.2.)
Et billede har en højde og en bredde
fun hoejde (bi : billede) = length bi;
val hoejde = fn : string list -> int
fun bredde (bi : billede) = size (hd bi);
val bredde = fn : string list -> int
Vi vil kun arbejde med rektangulære billeder; alle linjer i et billede skal derfor være lige
lange, og billedets bredde kan findes som længden af en hvilken som helst af disse linjer —
funktionen bredde bruger første linje. Da vi forlangte, et billede ikke m˚atte være en tom
liste af linjer, er dets bredde altid veldefineret.
To billeder kan stilles oven over hinanden (hvis de er lige brede) eller ved siden af hinanden
(hvis de er lige høje). Det første er let (man skal bare lade den ene liste af linjer efterfølge af
den anden), men det andet kræver, at de to førstelinjer bliver sat i forlængelse af hinanden,
at de to andenlinjer bliver sat i forlængelse af hinanden, og s˚a videre.
fun over (bi1,bi2) = bi1 @ bi2 : billede;
val over = fn : string list * string list -> string list
fun vsiden ([],[]) = [] : billede
| vsiden (li1 :: bi1,li2 :: bi2) = li1 ^ li2 :: vsiden (bi1,bi2);
! Toplevel input:
! ....vsiden ([],[]) = [] : billede
! | vsiden (li1 :: bi1,li2 :: bi2) = li1 ^ li2 :: vsiden (bi1,bi2).
! Warning: pattern matching is not exhaustive
val vsiden = fn : string list * string list -> string list
Advarslen minder os om, at vi ikke har taget stilling til, hvad der skal ske, hvis man forsøger
at stille to ulige høje billeder ved siden af hinanden. Opgave 9.1 g˚ar ud p˚a at gøre over og
vsiden robuste.
Selv om et billede ikke m˚atte være tomt, har vi alligevel efter princippet om at tilstræbe
enkelhed valgt at bruge et par af tomme lister som basistilfælde i definitionen af vsiden.
(Basistilfældet skal s˚aledes blot bruges “internt”; funktionen vil aldrig udefra blive kaldt p˚a
den m˚ade.)
Der bliver ogs˚a brug for at stille flere end to billeder over eller ved siden af hinanden.
Det kan naturligt opfattes som operationer p˚a lister:
117

fun stabl [bi] = bi
| stabl (bi :: bir) = over (bi,stabl bir);
! Toplevel input:
! ....stabl [bi] = bi
! | stabl (bi :: bir) = over (bi,stabl bir).
! Warning: pattern matching is not exhaustive
val stabl = fn : string list list -> string list
fun sidestil [bi] = bi
| sidestil (bi :: bir) = vsiden (bi,sidestil bir);
! Toplevel input:
! ....sidestil [bi] = bi
! | sidestil (bi :: bir) = vsiden (bi,sidestil bir).
! Warning: pattern matching is not exhaustive
val sidestil = fn : string list list -> string list
Der vil senere blive brug for en generalisering af sidestil, som for en liste af lister af billeder
kan sidestille hver af de indg˚aende lister. Selv om behovet ikke har vist sig endnu, er det
naturligt at behandle problemet her. Funktionen skal alts˚a for en liste [bir1, bir2, ...] af
billedlister danne listen [sidestil bir1, sidestil bir2, ...] af billeder. At programmere
funktionen er lettere end at forklare, hvad den skal gøre:
fun sidestilAlle [] = []
| sidestilAlle (bir :: birr) = sidestil bir :: sidestilAlle birr;
val sidestilAlle = fn : string list list list -> string list list
Til sidst bliver der naturligvis brug for at omsætte et billede til en tekst, man kan se p˚a
skærmen, og ogs˚a under indkøring af de forskellige hjælpefunktioner er det nyttigt at have
s˚adan en funktion til r˚adighed. Lad os kalde den billedetiltekst; den skal simpelt hen
lægge et linjeskift ind efter hver af billedets linjer:
fun billedetiltekst [] =
| billedetiltekst (li :: bi) = li ^ "\n"^ billedetiltekst bi;
val billedetiltekst = fn : string list -> string
Billeder opbygges en linje ad gangen. Lad teksttilbillede være navnet p˚a den operation,
som konstruerer et grundbillede ud fra en enkelt tekstlinje:
fun teksttilbillede s = [s] : billede;
val teksttilbillede = fn : string -> string list
For at kunne stille delbilleder op med lidt afstand imellem er det nyttigt at kunne danne
et blankt billede og at kunne stille et givet billede op øverst til venstre — i det “nordvestlige
hjørne” s˚a at sige — i et felt af given størrelse. Disse opgaver isoleres som selvstændige
funktioner, idet vi f˚ar brug for en hjælpefunktion, der bygger en liste, hvor et forelagt
element er gentaget et ønsket antal gange.
118

fun gentag (n,x) = if n = 0 then [] else x :: gentag (n - 1,x)
val gentag = fn : int * ’a -> ’a list
fun mellemrum n = implode (gentag (n,#));
val mellemrum = fn : int -> string
fun blankbillede (h,b)
= stabl (gentag (h,teksttilbillede (mellemrum b)));
val blankbillede = fn : int * int -> string list
fun nvstil (h,b,bi)
= let val hbi = hoejde bi
val bbi = bredde bi
in over (vsiden (bi,blankbillede (hbi,b - bbi)),
blankbillede (h - hbi,b))
end;
val nvstil = fn : int * int * string list -> string list
9.2 Opdeling af en liste i dellister
Den sidste funktion til billedh˚andtering skal ombryde en liste af billeder: i første omgang
grupperet som en liste af rækker med et bestemt antal billeder i hver række, men derefter
skal rækkerne stables oven p˚a hinanden til et enkelt stort billede.
Lad os først betragte en simplere opgave: at opsplitte en liste i to dele. I biblioteksmodulet
“List” ligger funktionerne
take, drop: α list * int -> α list
der henholdsvis udvælger og fjerner et opgivet antal elementer af en liste:
List.take ([a1,. . .,ak−1,ak,ak+1,. . .,an],k) = [a1,. . .,ak−1,ak]
List.drop ([a1,. . .,ak−1,ak,ak+1,. . .,an],k) = [ak+1,. . .,an]
Hver af disse funktioner kræver naturligvis et gennemløb af argumentlisten. Lad os prøve
at konstruere en funktion, som danner parret af de to dele af en liste i kun et enkelt gennemløb.
Den ønskede funktion, som vi kan kalde splitAt, skal “splitte en liste efter et
opgivet elementantal”, s˚adan at
splitAt ([a1,. . .,ak−1,ak,ak+1,. . .,an],k) = ([a1,. . .,ak−1,ak],[ak+1,. . .,an])
Vi har alts˚a splitAt (ℓ,k) = (List.take (ℓ,k),List.drop (ℓ,k)), men for at spare
et gennemløb (og for at øve os i funktionskonstruktion) vil vi gerne konstruere splitAt
direkte, uden at bruge take eller drop.
Normalt skal naturligvis 0 ≤ k ≤ length(ℓ), n˚ar man kalder splitAt (ℓ,k), men for
andre værdier af k virker det naturligt at sørge for at opretholde, at listen kan gendannes
af sine to dele:
Hvis splitAt (ℓ,k) = (xr,yr), da vil ℓ = xr @ yr
Vi beslutter derfor, at for k < 0 skal splitAt (ℓ,k) = ([],ℓ), og for k > length (ℓ) skal
splitAt (ℓ,k) = (ℓ,[]).
119

For at funktionen skal kunne løse sin opgave i et enkelt gennemløb, skal værdien af
splitAt (x::xr,. . .) kunne dannes ud fra splitAt (xr,. . .), og efter et øjebliks overvejelse
indser man, at det kan ske ved at splitte en plads tidligere og derefter tilføje x forrest i venstre
komponent af parret. (En analytisk brug af val, se afsnit 4.4.1.) Som program:
fun splitAt ([], ) = ([],[])
| splitAt (wr as x :: xr,n)
= if n > 0 then let val (yr,zr) = splitAt (xr,n - 1)
in (x :: yr,zr) end
else ([],wr);
Med splitAt til r˚adighed lader grupper sig let konstruere:
fun grupper (xr,n) = if length xr > n
then let val (yr,zr) = splitAt (xr,n)
in yr :: grupper (zr,n) end
else [xr];
val grupper = fn : ’a list * int -> ’a list list
fun ombryd (bir,n) = stabl (sidestilAlle (grupper (bir,n)));
val ombryd = fn : string list list * int -> string list
9.3 En enkelt m˚aneds billede
Oven over listen af (forkortede) ugedagsnavne skal m˚anedens navn og ˚arstallet st˚a, og nedenunder
datoskemaet. Til omsætning af ˚arstal og de enkelte datoer til tekst bruges tiltekst
fra afsnit 7.4.2.
Tilbage st˚ar konstruktionen af selve datoskemaet. Der bliver mindst brug for 4 og højst
for 6 rækker, s˚a vi vil altid afsætte plads til 6, det vil sige bruge 42 felter. Hvert felt fylder
tre positioner og skal enten være blankt eller indeholde et tal mellem 1 og m˚anedens længde,
men man skal vide, hvilken ugedag m˚aneden begynder.
Lad os kode de syv dage mandag, tirsdag, . . . , søndag ved tallene 1, 2, . . . , 7. Hvis koden
for m˚anedens første dag er fd, g˚ar der fd − 1 blanke felter foran den første i m˚aneden. Man
kan derfor opfatte tabellen som en ombrydning af de 42 tal fra 2 − fd til 43 − fd, idet tal,
der ikke er relevante for den p˚agældende m˚aned, er maskeret som blanke felter (se figuren).
Selve listen af tal fra 2 − fd til 43 − fd dannes med en hjælpefunktion interval for hvilken
interval (m,n) = [m,m + 1,...,n − 1,n] hvis m ≤ n
1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31
beregnes ud fra
-5 -4 -3 -2 -1 0 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 31 32 33 34 35 36
fun interval (m,n) = if m > n then [] else m :: interval (m + 1,n)
val interval = fn : int * int -> int list
120

val ugedage = "ma ti on to fr lø sø";
val ugedage = "ma ti on to fr lø sø": string
fun tildatobi (mdlgd,n)
= teksttilbillede (if n < 1 orelse n > mdlgd then " "
else (if n < 10 then " "else )
^ tiltekst n);
val tildatobi = fn : int * int -> string list
fun tildatobiAlle (mdlgd,[]) = []
| tildatobiAlle (mdlgd,n :: nr)
= tildatobi (mdlgd,n) :: tildatobiAlle (mdlgd,nr);
val tildatbiAlle = fn : int * int list -> string list list
fun datotabel (fd,mdlgd)
= ombryd (tildatobiAlle (mdlgd,interval (2 - fd,43 - fd)),7);
val datotabel = fn : int * int -> string list
fun mdbillede (maaned,aar,fd,mdlgd)
= nvstil (10,22,
stabl [nvstil (2,21,
teksttilbillede ( ^ maaned ^ ^ tiltekst aar)),
teksttilbillede ugedage,
datotabel (fd,mdlgd)]);
val mdbillede = fn : string * int * int * int -> string list
Som tidligere nævnt skal mdbillede bruges p˚a en liste af tolv m˚anedsdata. Derfor definerer
vi
fun mdbilledeAlle [] = []
| mdbilledeAlle (q :: qr) = mdbillede q :: mdbilledeAlle qr;
val mdbilledeAlle = fn : (string * int * int * int) list -> string list list
9.4 Ugedag
Vi valgte at kode mandag som 1, tirsdag som 2, og s˚a videre. I nogle af beregningerne bliver
der brug for at finde koden for en ugedag, der ligger et vist antal dage d senere end ugedagen
med en given kode k. Med nedenst˚aende definition kan den findes som ugedag (d + k). Vi
benytter ogs˚a lejligheden til at generalisere til en liste af datoer:
fun ugedag n = (n - 1) mod 7 + 1;
val ugedag = fn : int -> int
fun ugedagAlle [] = []
| ugedagAlle (n :: nr) = ugedag n :: ugedagAlle nr;
val ugedagAlle = fn : int list -> int list
9.5 M˚anedsdata
Den indledende analyse afklarede, at de enkelte m˚aneders billedblokke kunne dannes ud fra
et kvadrupel med fire grundoplysninger: m˚anedens navn, ˚arstallet, ugedagen for den første
i m˚aneden og antallet af dage i m˚aneden.
121

Konstruktionerne i dette afsnit munder ud i en funktion
mddata : int -> (string * int * int * int) list, s˚adan at hvis n er et ˚arstal, vil
mddata n beregne de ønskede oplysninger i form af en liste med tolv kvadrupler (et for hver
af de tolv m˚aneder).
9.5.1 Skud˚ar
P˚a Catos og Ciceros tid var der ingen regel for, hvorledes skud˚ar og almindelige ˚ar skulle
følge hinanden; præsterne var kalenderforvaltere. I ˚ar 47 før vor tidsregning var kalender˚aret
kommet 80 dage forud for solen. Julius Cæsar besluttede, at ˚ar 46 f.v.t. skulle indeholde de
nødvendige ekstra dage, og at man fra ˚ar 45 f.v.t. skulle benytte reglen om, at hvert fjerde ˚ar
var skud˚ar. Efter ham kaldes denne kalender for den “julianske”. Forskellen mellem 365,25
og de i indledningen nævnte 365,24219 gjorde, at solen langsomt kom foran kalenderen. I
det sekstende ˚arhundrede indtraf for˚arsjævndøgn 10 dage for tidligt, og pave Gregor XIII
besluttede (med assistance fra astronomen Lilius), at man skulle udelade 10 dage af 1582
og derefter udelade 3 skuddage i hver periode p˚a 400 ˚ar, idet ˚arstal delelige med 100 kun
skulle være skud˚ar, hvis de ogs˚a kunne deles med 400. I Danmark indførtes den “gregorianske”
kalender i ˚aret 1700, hvor man gik direkte fra den 18. februar til den 1. marts og
s˚aledes udelod 11 dage (idet det jo ellers skulle have været et skud˚ar). Med den gregorianske
korrektion bliver ˚aret gennemsnitligt p˚a 365,2425 døgn.
For at beregne første januars ugedag et givet ˚ar er det bekvemt at g˚a ud fra ˚ar 1 (selv
om man ikke brugte den gregorianske kalender p˚a det tidspunkt).
I forhold til et s˚adant fiktivt ˚ar 1 vil hvert almindeligt ˚ar skubbe den første januar 1 dag
(fordi 365 mod 7 = 1) og hvert skud˚ar skubbe den to dage. Det viser sig, at man skal regne
den første januar ˚ar 1 som en mandag. Forud for et vist ˚ar aar vil antallet af ˚ar siden ˚ar 1
være aar - 1, og af disse aar - 1 ˚ar vil (regnet efter vores gregorianske kalender)
(aar - 1) div 4 - (aar - 1) div 100 + (aar - 1) div 400
have været skud˚ar.
Herudfra defineres funktionen jan1 til beregning af ugedagen for ˚arets første dag:
fun skudaar aar = if aar mod 100 = 0 then aar mod 400 = 0
else aar mod 4 = 0;
val skudaar = fn : int -> bool
fun jan1 aar
= let val mandag = 1
val antalaar = aar - 1
val skud = antalaar div 4 - antalaar div 100
+ antalaar div 400
in ugedag (mandag + antalaar + skud) end;
val jan1 = fn : int -> int
9.5.2 De enkelte m˚aneder
M˚anedernes navne kan vi bare skrive ned, og m˚anedernes længder kan beregnes, n˚ar man
ved, hvorvidt der er tale om et skud˚ar:
122

val mdnavne = ["januar","februar","marts","april","maj","juni","juli",
"august","september","oktober","november","december"];
val mdnavne =
["januar", "februar", "marts", "april", "maj", "juni", "juli", "august",
"september", "oktober", "november", "december"]
: string list
fun mdlgder aar = let val feb = if skudaar aar then 29 else 28
in [31,feb,31,30,31,30,31,31,30,31,30,31] end;
val mdlgder = fn : int -> int list
˚Arstallet er forelagt, og tilbage af de fire m˚anedsdataelementer st˚ar herefter kun at
beregne ugedagen for den første i hver m˚aned. Hvis den første januar falder p˚a ugedagen k,
vil den første i de øvrige m˚aneder falde p˚a ugedag (d + k), hvor d (p˚a ˚ar, der ikke er skud˚ar)
findes ved at sl˚a m˚aneden op i listen [0, 31, 31 + 28, 31 + 28 + 31, 31 + 28 + 31 + 30, . . .]. Den
m˚ade, hvorp˚a denne liste kan beregnes ud fra listen [31, 28, 31, 30, . . .] af m˚anedslængder,
følger et generelt princip, og i stedet for at løse problemet ad hoc vælger vi at programmere
dette generelle princip:
Initialsummer
Lad os betragte den opgave at overføre en liste [a1, a2, a3, . . . , an] med n tal i til en liste med
n + 1 delsummer: [0, a1, a1 + a2, a1 + a2 + a3, . . . , a1 + a2 + a3 + . . . + an].
I konstruktion af en funktion, der tager en liste som argument, har vi hidtil ofte kunnet
bruge den skabelon, hvor man dels fastlægger funktionens værdi med den tomme liste som
argument, dels dens værdi for en liste med et hovede og en hale ud fra funktionsværdien af
halen.
I vores første forsøg initialsummer1 p˚a at løse opgaven følges denne skabelon. Har man
allerede beregnet
initialsummer1 [a2, a3, . . ., an] = [0, a2, a2 + a3, . . ., a2 + a3 + . . . + an], s˚a findes
initialsummer [a1, a2, a3, . . ., an] ˚abenbart ved, at a1 adderes til alle elementer i
listen, hvorefter et nyt 0 sættes allerforrest.
Vi f˚ar alts˚a brug for en hjælpefunktion, der adderer en værdi til hvert element i en liste,
og kan derefter programmere initialsummer1:
fun flytAlle (m,[]) = []
| flytAlle (m,n :: nr) = m + n :: flytAlle (m,nr);
val flytAlle = fn : int * int list -> int list
fun initialsummer1 [] = [0]
| initialsummer1 (n :: nr) = 0 :: flytAlle (n,initialsummer1 nr);
val initialsummer1 = fn : int list -> int list
Selv om det konstruerede program er kompakt og elegant, afslører nærmere overvejelse
en urimelig defekt: det er faktisk temmelig ineffektivt! Det er klart, at flytAlle (m,nr)
m˚a foretage en addition for hvert element i listen nr. Kalder man derfor initialsummer1
med en liste med n elementer som argument, vil flytAlle-kaldet p˚a højre side umiddelbart
kræve n additioner, men hertil kommer de additioner, som for˚arsages af det indre rekursive
kald af initialsummer1. Alt i alt fører det til n + (n − 1) + . . . + 3 + 2 + 1 additioner.
123

P˚a sin vis er dette ikke s˚a mærkeligt, for det er (p˚anær de n additioner til 0) netop
antallet af plus-tegn i resultatet [0, a1, a1 + a2, a1 + a2 + a3, . . . , a1 + a2 + a3 + . . . + an];
problemet er bare, at det m˚a kunne gøres smartere: hver sum i listen burde kunne dannes
ud fra den foreg˚aende ved blot en enkelt addition mere, s˚a man burde kunne klare sig med
n additioner i alt.
Funktionsværdien af lister af en vis længde skal dannes ud fra funktionsværdien af en
kortere liste, men prøv at sammenligne det ønskede resultat med funktionsværdien af [a1 +
a2, a3, . . . , an], som m˚a være [0, a1 + a2, a1 + a2 + a3, . . . , a1 + a2 + a3 + . . . + an]. Nu f˚as
det ønskede resultat blot ved, at man heri “stikker a1 ind mellem forreste og næstforreste
plads”.
Vores næste forsøg initialsummer2 bygger p˚a denne ide og bruger kun n − 1 additioner
p˚a at beregne sit resultat for et argument af længde n:
fun initialsummer2 [] = [0]
| initialsummer2 [n] = [0,n]
| initialsummer2 (n1 :: n2 :: nr)
= let val 0 :: mr = initialsummer2 (n1+n2 :: nr)
in 0 :: n1 :: mr end;
val initialsummer2 = fn : int list -> int list
Man kunne ogs˚a sige, at ineffektiviteten i initialsummer1 bundede i, at additionen (via
flytAlle) af et element til hver plads i listen var adskilt fra dannelsen af initialsummerne.
Den effektive funktion initialsummer’ nedenfor kombinerer de to operationer. Sammenhængen
er alts˚a
initialsummer’ (m,nr) = flytAlle (m,initialsummer nr)
men der er en simpel effektiv definition af initialsummer’, og initialsummer fremkommer
som det specialtilfælde, hvor det er 0, man adderer:
fun initialsummer’ (m,[]) = [m]
| initialsummer’ (m,n :: nr) = m :: initialsummer’ (m+n,nr);
val initialsummer’ = fn : int * int list -> int list
fun initialsummer nr = initialsummer’ (0,nr);
val initialsummer = fn : int list -> int list
9.5.3 Opsamling af m˚anedsdata
Ugedagene for hver den første i m˚aneden beregnes som nævnt af ugedag (k + d), hvor k
er ugedagen for 1. januar, og d er hentet fra listen af initialsummer af m˚anedernes længder.
Det klares netop af ugedagAlle (initialsummer’(k,lgdr )), hvor lgdr er længderne af
˚arets første elleve m˚aneder (s˚a der bliver tolv initialsummer).
Vi f˚ar med andre ord præcis brug for funktionen initialsummer’ fra foreg˚aende underafsnit,
mens initialsummer, initialsummer1 og initialsummer2 ikke skal bruges her i
kalenderprogrammet:
124

fun md1er aar = let val lgdr = #1 (splitAt (mdlgder aar,11))
in ugedagAlle (initialsummer’ (jan1 aar,lgdr))
end;
val md1er = fn : int -> int list
Til sidst kan listen af de 12 m˚anedsdata dannes ved “sammenlyning” af fire lister, der
alle har længde 12. Virkem˚aden for funktionen zip4 kan skitseres s˚aledes:
zip4 ([a1, a2, . . ., an],[b1, b2, . . ., bn],[c1, c2, . . ., cn],[d1, d2, . . ., dn])
Det er stillet som en opgave at konstruere zip4.
= [(a1,b1,c1,d1), (a2,b2,c2,d2), . . ., (an,bn,cn,dn)]
fun mddata aar = zip4 (mdnavne,gentag (12,aar),md1er aar,mdlgder aar);
val mddata = fn : int -> (string * int * int * int) list
9.6 Kalenderfunktionen
I de foreg˚aende afsnit er arbejdet gjort — nu skal vi bare samle sammen: Ud fra ˚arstallet
dannes listen af de 12 m˚anedsdata, p˚a hver af dem anvendes mdbillede, og listen af 12
billeder brydes om med 3 i hver række:
fun kalender aar
= billedetiltekst (ombryd (mdbilledeAlle (mddata aar),3));
val kalender = fn : int -> string
print (kalender 1998);
januar 1998 . . .
. . .
9.7 Hele programmet
(* En linje best˚ar af grafiske tegn, herunder blanktegn *)
type linje = string (* ej linjeskift, vognretur ell. lign. *)
(* Et billede er en ikke tom liste af lige lange linjer *)
type billede = linje list
fun hoejde (bi : billede) = length bi
fun bredde (bi : billede) = size (hd bi)
(* over (bi1,bi2)
= billedet bi1 placeret oven over billedet bi2,
idet bi1 og bi2 skal være lige brede *)
fun over (bi1,bi2) = bi1 @ bi2 : billede
(* vsiden (bi1,bi2)
= billedet bi1 placeret til venstre for billedet bi2,
125

idet bi1 og bi2 skal være lige høje *)
fun vsiden ([],[]) = [] : billede
| vsiden (li1 :: bi1,li2 :: bi2) = li1 ^ li2 :: vsiden (bi1,bi2)
(* stabl [bi1, bi2, bi3, ...]
= over (bi1, over (bi2, over (bi3, ...)))
En liste af lige brede billeder placeres oven over hinanden *)
fun stabl [bi] = bi
| stabl (bi :: bir) = over (bi,stabl bir)
(* sidestil [bi1, bi2, bi3, ...]
= vsiden (bi1, vsiden (bi2, vsiden (bi3, ...)))
En liste af lige høje billeder placeres ved siden af hinanden *)
fun sidestil [bi] = bi
| sidestil (bi :: bir) = vsiden (bi,sidestil bir)
(* sidestilAlle [bir1, bir2, bir3, ...]
= [sidestil bir1, sidestil bir2, sidestil bir3, ...] *)
fun sidestilAlle [] = []
| sidestilAlle (bir :: birr) = sidestil bir :: sidestilAlle birr
(* Et billede omformes til en tekst. De underforst˚aede
linjeskift indsættes, og resultatet kan vises af print *)
fun billedetiltekst [] = ""
| billedetiltekst (li :: bi) = li ^ "\n" ^ billedetiltekst bi
(* En tekst uden linjeskift, vognretur eller lignende
omformes til et en-linjes-billede *)
fun teksttilbillede (s : string) = [s] : billede
(* gentag (n,x) = [x, x, x, ...] med n elementer i listen *)
fun gentag (n,x) = if n = 0 then [] else x :: gentag (n - 1,x)
(* mellemrum n = en tekst best˚aende af n blanktegn *)
fun mellemrum n = implode (gentag (n,#" "))
(* blankbillede (h,b)
= et blankt billede med højde h og bredde b *)
fun blankbillede (h,b)
= stabl (gentag (h,teksttilbillede (mellemrum b)))
(* nvstil (h,b,bi)
= billedet bi udvidet til højde h og bredde b,
idet bi placeres i øverste venstre hjørne *)
fun nvstil (h,b,bi)
= let val hbi = hoejde bi
val bbi = bredde bi
126

in over (vsiden (bi,blankbillede (hbi,b - bbi)),
blankbillede (h - hbi,b))
end
(* splitAt (xr,n) = (yr,zr)
hvor yr er de n forreste elementer af xr, og zr er resten *)
fun splitAt ([],_) = ([],[])
| splitAt (wr as x :: xr,n)
= if n > 0 then let val (yr,zr) = splitAt (xr,n - 1)
in (x :: yr,zr) end
else ([],wr)
(* grupper (xr,n) = [xr1, xr2, xr3, ...]
hvor xr = xr1 @ xr2 @ xr3 @ ..., og delene har længde n *)
fun grupper (xr,n) = if length xr > n
then let val (yr,zr) = splitAt (xr,n)
in yr :: grupper (zr,n) end
else [xr]
(* ombryd (bir,n)
Af en liste bir af billeder dannes et nyt billede, idet
de indkommende billeder sidestilles n ad gangen *)
fun ombryd (bir,n) = stabl (sidestilAlle (grupper (bir,n)))
val ugedage = " ma ti on to fr lø sø"
(* interval (m,n) = [m, m+1, m+2, ..., n-1, n] *)
fun interval (m,n) = if m > n then nil else m :: interval (m + 1,n)
(* tilcifre n
= listen af decimale enkelttegn i det positive heltal n *)
fun tilcifre n = if n = 0 then []
else tilcifre (n div 10) @ [chr (ord #"0" + n mod 10)]
(* tiltekst n
= det naturlige tal n som talord *)
fun tiltekst n = if n = 0 then "0" else implode (tilcifre n)
(* tildatobi (mdlgd,n)
= den tretegnstekst, datoen n skal blive til
i m˚aneder af længde mdlgd *)
fun tildatobi (mdlgd,n)
= teksttilbillede (if n < 1 orelse n > mdlgd then " "
else (if n < 10 then " " else " ") ^ tiltekst n)
(* tildatobiAlle (mdlgd,[n1, n2, ...])
= [tildatobi (mdlgd,n1), tildatobi (mdlgd,n2), ...] *)
fun tildatobiAlle (mdlgd,[]) = []
127

| tildatobiAlle (mdlgd,n :: nr)
= tildatobi (mdlgd,n) :: tildatobiAlle (mdlgd,nr)
(* datotabel (fd,mdlgd)
= selve datodelen for en m˚aned af længde mdlgd, hvis
den første i m˚aneden falder p˚a dagen med kode fd *)
fun datotabel (fd,mdlgd)
= ombryd (tildatobiAlle (mdlgd,interval (2 - fd,43 - fd)),7)
(* mdbillede maanedsdata
= billedet (med højde 10 og bredde 22) af de
som argument givne maanedsdata *)
fun mdbillede (maaned,aar,fd,mdlgd)
= nvstil (10,22,
stabl [nvstil (2,21,
teksttilbillede (" " ^ maaned ^ " " ^ tiltekst aar)),
teksttilbillede ugedage,
datotabel (fd,mdlgd)])
(* mdbilledeAlle
vil for en liste af maanedsdata danne den tilsvarende
liste af billeder *)
fun mdbilledeAlle [] = []
| mdbilledeAlle (q :: qs) = mdbillede q :: mdbilledeAlle qs
(* Ugens dage kodes mandag = 1, tirsdag = 2, ..., søndag = 7 *)
fun ugedag n = (n - 1) mod 7 + 1
fun ugedagAlle [] = []
| ugedagAlle (n :: nr) = ugedag n :: ugedagAlle nr
(* skudaar ˚ar
hvis og kun hvis ˚ar er skud˚ar efter den
gregorianske kalender *)
fun skudaar aar = aar mod 4 = 0 andalso aar mod 100 0
orelse aar mod 400 = 0
(* jan1
giver ugedagskoden for 1. januar
i det som argument anførte ˚ar *)
fun jan1 aar
= let val mandag = 1 (* 1. januar ˚ar 1 skal være en mandag *)
val antalaar = aar - 1
val skud = antalaar div 4 - antalaar div 100
+ antalaar div 400
in ugedag (mandag + antalaar + skud) end
val mdnavne = ["januar","februar","marts","april","maj","juni","juli",
"august","september","oktober","november","december"]
128

fun mdlgder aar = let val feb = if skudaar aar then 29 else 28
in [31,feb,31,30,31,30,31,31,30,31,30,31] end
(* initialsummer’ (m,[n1, n2, n3, ...])
= [m, m+n1, m+n1+n2, m+n1+n2+n3, ...] *)
fun initialsummer’ (m,[]) = [m]
| initialsummer’ (m,n :: nr) = m :: initialsummer’ (m+n,nr)
(* md1er
beregner listen af ugedagskoder for den første i hver
af de 12 m˚aneder af det som argument angivne ˚ar *)
fun md1er aar = let val lgdr = #1 (splitAt (mdlgder aar,11))
in ugedagAlle (initialsummer’ (jan1 aar,lgdr))
end
(* zip4 ([a1, a2, a3, ...],
[b1, b2, b3, ...],
[c1, c2, c3, ...],
[d1, d2, d3, ...])
= [(a1,b1,c1,d1), (a2,b2,c2,d2), (a3,b3,c3,d3), ...] *)
fun zip4 ... (* Opgave 9.3 *)
(* mddata
beregner listen af m˚anedsdata for de 12 m˚aneder
af det som argument angivne ˚ar *)
fun mddata aar = zip4 (mdnavne,gentag (12,aar),md1er aar,mdlgder aar)
(* kalender : int -> string *)
fun kalender aar
= billedetiltekst (ombryd (mdbilledeAlle (mddata aar),3));
9.8 Udnyttelse af listefunktionalen map
Lad os udnytte, at flere af de konstruerede funktioner mere eller mindre følger skabelonen
(7.1), til at præsentere programmet mere kompakt.
De funktioner, som burde kunne undværes, er
sidestilAlle
tildatobiAlle
mdbilledeAlle
ugedagAlle
For tre af disse funktioner er der en direkte sammenhæng
val sidestilAlle = map sidestil
val mdbilledeAlle = map mdbillede
val ugedagAlle = map ugedag
129

men tildatobi er b˚ade en funktion af m˚anedens længde og af den dato, som skal vises.
Rent syntaktisk ville der ikke være noget i vejen for at konstruere map tildatobi, men da
tildatobi har type int * int -> string list, vil
map tildatobi : (int * int) list -> string list list blive en funktion, der som
argument skal have en liste af par (hvor hvert par best˚ar af en m˚anedslængde og en dato)
— og ikke, som vi har brug for det, et par best˚aende af en m˚anedslængde og en liste af
datoer.
Det ønskede kan opn˚as ved at definere en sekventialiseret funktion
tildatobi’ mdlgd n = tildatobi (mdlgd,n)
fun tildatobi’ mdlgd n
= teksttilbillede (if n < 1 orelse n > mdlgd then
else (if n < 10 then else ) ^ tiltekst n);
val tildatobi’ = fn : int -> int -> string list
fun tildatobiAlle’ mdlgd = map (tildatobi’ mdlgd)
val tildatobiAlle’ = fn : int -> int list -> string list list
Bemærk, at tildatobiAlle’ nu ogs˚a er en sekventialiseret funktion, s˚a det oprindelige
kald
tildatobiAlle (mdlgd,interval (2 - fd,43 - fd))
nu skal erstattes af
tildatobiAlle’ mdlgd (interval (2 - fd,43 - fd))
I næste afsnit samles de beskrevne omformninger, og vi viser hele programmet i komprimeret
form uden kommentarer.
9.9 Hele programmet p˚a kompakt form
type linje = string
type billede = linje list
fun hoejde (bi : billede) = length bi
fun bredde (bi : billede) = size (hd bi)
fun over (bi1,bi2) = bi1 @ bi2 : billede
fun vsiden ([],[]) = [] : billede
| vsiden (li1 :: bi1,li2 :: bi2) = li1 ^ li2 :: vsiden (bi1,bi2)
fun stabl [bi] = bi
| stabl (bi :: bir) = over (bi,stabl bir)
fun sidestil [bi] = bi
| sidestil (bi :: bir) = vsiden (bi,sidestil bir)
fun billedetiltekst [] = ""
| billedetiltekst (li :: bi) = li ^ "\n" ^ billedetiltekst bi
fun teksttilbillede (s : string) = [s] : billede
fun gentag (n,x) = if n = 0 then [] else x :: gentag (n - 1,x)
fun mellemrum n = implode (gentag (n,#" "))
130

fun blankbillede (h,b)
= stabl (gentag (h,teksttilbillede (mellemrum b)))
fun nvstil (h,b,bi)
= let val hbi = hoejde bi
val bbi = bredde bi
in over (vsiden (bi,blankbillede (hbi,b - bbi)),
blankbillede (h - hbi,b))
end
fun splitAt ([],_) = ([],[])
| splitAt (wr as x :: xr,n)
= if n > 0 then let val (yr,zr) = splitAt (xr,n - 1)
in (x :: yr,zr) end
else ([],wr)
fun grupper (xr,n) = if length xr > n
then let val (yr,zr) = splitAt (xr,n)
in yr :: grupper (zr,n) end
else [xr]
fun ombryd (bir,n) = stabl (map sidestil (grupper (bir,n)))
val ugedage = " ma ti on to fr lø sø"
fun interval (m,n) = if m > n then nil else m :: interval (m + 1,n)
fun tilcifre n = if n = 0 then []
else tilcifre (n div 10) @ [chr (ord #"0" + n mod 10)]
fun tiltekst n = if n = 0 then "0" else implode (tilcifre n)
fun tildatobi’ mdlgd n
= teksttilbillede (if n < 1 orelse n > mdlgd then " "
else (if n < 10 then " " else " ") ^ tiltekst n)
fun datotabel (fd,mdlgd)
= ombryd (map (tildatobi’ mdlgd) (interval (2 - fd,43 - fd)),7)
fun mdbillede (maaned,aar,fd,mdlgd)
= nvstil (10,22,
stabl [nvstil (2,21,
teksttilbillede (" " ^ maaned ^ " " ^ tiltekst aar)),
teksttilbillede ugedage,
datotabel (fd,mdlgd)])
fun ugedag n = (n - 1) mod 7 + 1
fun skudaar aar = aar mod 4 = 0 andalso aar mod 100 0
orelse aar mod 400 = 0
fun jan1 aar
= let val mandag = 1
val antalaar = aar - 1
val skud = antalaar div 4 - antalaar div 100
+ antalaar div 400
in ugedag (mandag + antalaar + skud) end
val mdnavne = ["januar","februar","marts","april","maj","juni","juli",
"august","september","oktober","november","december"]
131

fun mdlgder aar = let val feb = if skudaar aar then 29 else 28
in [31,feb,31,30,31,30,31,31,30,31,30,31] end
fun initialsummer’ (m,[]) = [m]
| initialsummer’ (m,n :: nr) = m :: initialsummer’ (m+n,nr)
fun md1er aar = let val lgdr = #1 (splitAt (mdlgder aar,11))
in map ugedag (initialsummer’ (jan1 aar,lgdr))
end
fun zip4 ... (* Opgave 9.3 *)
fun mddata aar = zip4 (mdnavne,gentag (12,aar),md1er aar,mdlgder aar)
fun kalender aar
= billedetiltekst (ombryd (map mdbillede (mddata aar),3));
9.10 Opgaver
Opgave 9.1 Gør over og vsiden robuste, s˚adan at over kaster en undtagelse, hvis billederne
ikke er lige brede, og vsiden kaster en undtagelse, hvis de ikke er lige høje.
Opgave 9.2 Ud over, at de skulle tjene som forkortelser, var ideen med at indføre typenavnene
linje og billede ogs˚a, at de skulle markere nogle særlige begrænsninger: En værdi
af type string kunne kun bruges som linje, hvis alle dens tegn havde grafisk fremtræden
(opfyldte Char.isPrint). En værdi af type linje list kunne kun bruges som billede,
hvis den ikke var tom, og alle dens linjer var lige lange.
Sørg for, at alle de hjælpefunktioner i kalenderprogrammet, som bygger værdier af type
linje og af type billede, overholder disse begrænsninger (idet det samtidig kan antages,
at eventuelle parametre af type linje eller billede overholder begrænsningerne). [Vink:
Brug biblioteksfunktionen List.all.]
Opgave 9.3 Konstruer zip4.
Opgave 9.4 Skriv en funktion, hvis virkning er den samme som ombryd, blot transponeret:
Med en liste af billeder og et tal n som parameter skal den stable billederne fra listen n ad
gangen oven p˚a hinanden og derefter sidestille disse stable.
Opgave 9.5 Skriv en udgave af kalenderfunktionen, hvor den enkelte m˚aneds datoer opstilles
søjlevis:
januar 1998 februar 1998 marts 1998
ma 5 12 19 26 ma 2 9 16 23 ma 2 9 16 23 30
ti 6 13 20 27 ti 3 10 17 24 ti 3 10 17 24 31
on 7 14 21 28 on 4 11 18 25 on 4 11 18 25
to 1 8 15 22 29 to 5 12 19 26 to 5 12 19 26
fr 2 9 16 23 30 fr 6 13 20 27 fr 6 13 20 27
lø 3 10 17 24 31 lø 7 14 21 28 lø 7 14 21 28
sø 4 11 18 25 sø 1 8 15 22 sø 1 8 15 22 29
132

Opgave 9.6 I henhold til Encyclopedia Britannica er skud˚arsreglen i den gregorianske
kalender for nyligt revideret, s˚a ˚ar, hvis nummer er deleligt med 4000, ikke skal være skud˚ar.
Dette forbedrer gennemsnits˚arets 365,2425 døgn til 365,24225 døgn, hvilket tilnærmer den
eksakte værdi 365,24219 tilstrækkelig godt til ethvert praktisk form˚al. Modificer programmet,
s˚a det tager hensyn til denne revision.
Opgave 9.7 Hver uge har 7 dage, der strækker sig fra mandag til søndag, og uger nummereres
efter deres midterste dag, det vil sige torsdag. ˚Arets n-te uge er med andre ord den
uge, som strækker sig fra tre dage før til tre dage efter ˚arets n-te torsdag (uanset, om disse
dage alle tilhører samme ˚arstal).
Skriv et program, som for en opgiven dato beregner dens ugedag og ugenummer.
133

134

Kapitel 10
Kombinatorisk søgning
Nogle problemers løsning kan beskrives som resultat af en serie trufne valg. Man kan da
tænke p˚a problemet som en form for “spil”: I hver “stilling” (tilstand, konfiguration) er
der nogle mulige “træk”, som hver fører til en ny stilling, og fra en forelagt udgangsstilling
gælder det om at bestemme en sekvens af træk, der fører til en ønsket slutstilling.
Problemer af denne type kan illustreres som i figur 10.1 af en graf, hvor stillingerne er
knuder og trækkene er pile. (Hvis samme stilling kan n˚as ad flere forskellige sekvenser af
træk, vil grafen ikke som p˚a figuren være et træ.)
Her er nogle af de opgavetyper, som kan formuleres inden for denne ramme:
• Kan en slutstilling n˚as ad en sekvens af træk?
• Angiv en sekvens af træk, der fører til en slutstilling.
• Find den bedste (efter et eller andet nærmere specificeret kriterium) slutstilling, som
kan n˚as.
• Angiv antallet af opn˚aelige slutstillinger.
• Opregn samtlige løsninger p˚a problemet.
✑
✑ ✁❆◗
◗◗
✑✰ ✁☛ ❆❯
❅
✠ ❄ ❄ ❄ ❄
❅❘
❄ ❄ ❄ ❄
❄ ❄
Figur 10.1: Illustration af kombinatorisk søgning.
10.1 Det gr˚adige princip
Et af de problemer, som falder under den beskrevne ramme, er “pengevekslingsproblemet”,
hvor et beløb skal betales med mønterne inden for et bestemt møntsystem.
135

Lad os skrive en funktion, der med et beløb som argument beregner de danske mønter,
det skal betales med, n˚ar der skal bruges s˚a f˚a mønter som muligt. For en pris p˚a for eksempel
14,75 kr. skal svaret være en tikrone, to tokroner, en 50-øre og en 25-øre.
Det m˚a være hensigtsmæssigt at prøve de største møntværdier først, og efterh˚anden som
det bliver besluttet, hvilke mønter der skal bruges, reduceres det beløb, som mangler at blive
betalt. Lad os derfor skrive en funktion, der holder styr p˚a to ting: en liste mntr af mulige
møntværdier (i øre) i faldende orden og det beløb blb, som skal dannes. Hvis beløbet er 0,
skal ingen mønter bruges. Hvis møntsystemets største mønt er større end beløbet, kan den
ikke bruges, men ellers skal den bruges, og beløbet kan reduceres tilsvarende:
fun betalG ( ,0) = []
| betalG (mntr1 as mnt :: mntr,blb)
= if mnt > blb then betalG (mntr,blb)
else mnt :: betalG (mntr1,blb - mnt);
! Toplevel input:
! ....betalG ( ,0) = []
! | betalG (mntr1 as mnt :: mntr,blb)
! = if mnt > blb then betalG (mntr,blb)
! else mnt :: betalG (mntr1,blb - mnt).
! Warning: pattern matching is not exhaustive
val betalG = fn : int list * int -> int list
val DKmntr = [2000, 1000, 500, 200, 100, 50, 25];
val DKmntr = [2000, 1000, 500, 200, 100, 50, 25] : int list
betalG (DKmntr,1475);
val it = [1000, 200, 200, 50, 25] : int list
I det rekursive tilfælde vælger betingelsen mnt > blb mellem to delproblemer, som begge
er simplere end det oprindelige problem: enten er der færre møntstørrelser at vælge imellem,
eller ogs˚a er der et mindre restbeløb at betale.
N˚ar en møntstørrelse kan bruges, bliver den det ogs˚a; den m˚ade at løse et problem p˚a:
at vælge et træk, blot det er muligt, kaldes “det gr˚adige princip”.
Det gr˚adige princip fungerer ikke altid! Lad os forestille os, man kun har femmere og
tokroner til r˚adighed og skal betale 11 kr.
betalG ([500,200],1100);
! Uncaught exception:
! Match
Programmet giver op, selv om man kunne betale elleve kroner med en femmer og tre tokroner.
Læg mærke til, at systemet allerede under oversættelsen med “pattern matching is
not exhaustive” advarede os om muligheden for, at beregninger kunne kaste undtagelsen
“Match”.
136

10.2 Alle løsninger
Det gik galt, fordi betalingsfunktionen ikke prøvede andre møntstørrelser end “den første
den bedste”. Ønsker man at f˚a den løsning med, hvor 1100 dannes som 500+200+200+200,
er en af mulighederne at programmere en funktion, der danner samtlige mulige m˚ader at
betale et beløb p˚a. Det indebærer blandt andet, at selv om en bestemt møntstørrelse kan
bruges, s˚a skal funktionen b˚ade prøve at bruge den og ikke at gøre det.
Hvor svaret før var en betaling i form af en liste af møntværdier, skal funktionsværdien
nu være en liste af den slags lister. Hvis et problem ingen løsning har, f˚as en tom liste;
har det netop én løsning, bliver funktionsværdien en liste med denne ene løsningsliste som
element, men i almindelighed returneres alts˚a en liste af løsningslister.
N˚ar det var beregnet, at en bestemt møntstørrelse mnt skulle bruges, kunne man tidligere
blot med mnt :: delresultat sætte den foran det simplere delresultat. Nu, hvor et delresultat
er en liste af lister, bliver der brug for en hjælpefunktion foranAlle, som sætter mnt foran
hver enkelt liste i denne liste af lister.
fun foranAlle [] = []
| foranAlle x (xr :: xrr) = (x :: xr) :: foranAlle x xrr;
val ’a foranAlle = fn : ’a -> ’a list list -> ’a list list
fun betalA ( ,0) = [[]]
| betalA ([], ) = []
| betalA (mntr1 as mnt :: mntr,blb)
= if mnt > blb then betalA (mntr,blb)
else foranAlle mnt (betalA (mntr1,blb - mnt))
@ betalA (mntr,blb);
val betalA = fn : int list * int -> int list list
betalA ([500,200],1100);
val it = [[500, 200, 200, 200]] : int list list
betalA (DKmntr,100);
val it = [[100], [50, 50], [50, 25, 25], [25, 25, 25, 25]] : int list list
Vi kan ogs˚a prøve det oprindelige eksempel
betalA (DKmntr,1475);
val it =
[[1000, 200, 200, 50, 25], [1000, 200, 200, 25, 25, 25],
[1000, 200, 100, 100, 50, 25], [1000, 200, 100, 100, 25, 25, 25],
[1000, 200, 100, 50, 50, 50, 25], [1000, 200, 100, 50, 50, 25, 25, 25],
[1000, 200, 100, 50, 25, 25, 25, 25, 25],
...
[500, 200, 100, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 25, 25,
25], ...] : int list list
length it;
val it = 1082 : int
Efter et øjebliks tøven fyldes skærmen med tallister, og kun de første 200 løsninger 1 vises
1 Hvor mange elementer af en liste der skal vises, kan man selv styre med standardvariablen printLength,
se [13, afsnit 3.4].
137

af Moscow ML, men resultatet opbevares inde i systemet, og vi kan f˚a at vide, at der er
1082 løsninger i alt.
Omskrivninger Rent programmeringsteknisk er det utilfredsstillende, at deludtrykket
betalA (mntr,blb) forekommer to gange:
fun betalA1 ( ,0) = [[]]
| betalA1 ([], ) = []
| betalA1 (mntr1 as mnt :: mntr,blb)
= (if blb < mnt then []
else foranAlle mnt (betalA1 (mntr1,blb - mnt)))
@ betalA1 (mntr,blb);
Her sikrer betingelsen blb < mnt, at subtraktionen blb - mnt ikke giver et negativt resultat,
s˚a betalA1 kunne blive bedt om at betale et negativt beløb. Vi kunne imidlertid ogs˚a
vælge at tillade et negativt beløbsargument, som s˚a bare skulle resultere i tom løsningsliste:
fun betalA2( ,0) = [[]]
| betalA2 ([], ) = []
| betalA2 (mntr1 as mnt :: mntr,blb)
= if blb < 0 then []
else foranAlle mnt (betalA2 (mntr1,blb - mnt))
@ betalA2 (mntr,blb)
Opsamles de foransatte mønter i en ekstra parameter, overflødiggøres foranAlle: (Da
senest valgte mønter sættes forrest i denne liste, spejlvendes løsningerne nu i forhold til den
m˚ade, tidligere funktioner præsenterede dem p˚a.)
fun betalA’ (bmntr, ,0) = [bmntr]
| betalA’ ( ,[], ) = []
| betalA’ (bmntr,mntr1 as mnt :: mntr,blb)
= if blb < 0 then []
else betalA’ (mnt :: bmntr,mntr1,blb - mnt)
@ betalA’ (bmntr,mntr,blb)
fun betalA3 (mntr,blb) = betalA’ ([],mntr,blb);
val betalA’ = fn : int list * int list * int -> int list list
val betalA3 = fn : int list * int -> int list list
betalA3 (DKmntr,125);
val it = [[25, 100], [25, 50, 50], [25, 25, 25, 50], [25, 25, 25, 25, 25]] :
int list list
10.3 Kaste og gribe undtagelser
I tillæg til de undtagelser, som p˚a forh˚and er defineret i systemet, kan man konstruere sine
egne. Før en undtagelse kan bruges, skal den erklæres med en definition af formen
exception undtagelsesnavn
138

og i de tilfælde, hvor den skal kastes, skriver man s˚a
raise undtagelsesnavn
Undtagelser kan ogs˚a have parametre, se [5, Sect. 7.6] og [12, Sect. 4.6].
Ved selv at gribe (fange, h˚andtere) en undtagelse kan man forhindre den reaktion p˚a
undtagelser, vi har set indtil nu, hvor de afbryder den igangværende beregning med en
fejlmelding “Uncaught exception: . . . ”. I sprogkonstruktionen
exp handle match
hvor match har formen pat 1 => exp 1 | . . . | pat n => exp n, vil eventuelle undtagelser kastet
af exp bliver sammenholdt med mønstrene i match. Hvis exp i er det første mønster, som
passer, erstattes hele konstruktionen af det tilsvarende udtryk exp i til højre for dobbeltpilen.
Hvis intet mønster passer, propageres undtagelsen videre ud.
Som eksempel kan vi lade gr˚adige løsninger udskrive som tekst:
load "Int";
val it = () : unit
fun vistalliste [] =
| vistalliste [n] = Int.toString n
| vistalliste (n :: nr)
= Int.toString n ^ ", "^ vistalliste nr;
val vistalliste = fn : int list -> string
fun visbetaling (mntr,blb)
= "I møntsystemet\n"
^ vistalliste mntr ^ "\n"
^ "kan "^ Int.toString (blb div 100) ^ "kr. og "
^ Int.toString (blb mod 100) ^ "øre "
^ ("gr˚adigt betales som\n"^ vistalliste (betalG (mntr,blb))
handle Match => "ikke betales gr˚adigt") ^ "\n";
val visbetaling = fn : int list * int -> string
print (visbetaling (DKmntr,1425));
I møntsystemet
2000, 1000, 500, 200, 100, 50, 25
kan 14 kr. og 25 øre gr˚adigt betales som
1000, 200, 200, 25
val it = () : unit
print (visbetaling ([500,200],1100));
I møntsystemet
500, 200
kan 11 kr. og 0 øre ikke betales gr˚adigt
val it = () : unit
10.4 Blindgydesøgning
Hvor det gr˚adige princip ikke kunne bruges, s˚a vi, at man i stedet kunne generere (listen
af) alle løsninger. Er man kun interesseret i en enkelt løsning, synes det imidlertid at være
139

spild af ressourcer. Ganske vist vil man f˚a udvalgt den forreste løsning ved at skrive
hd (betalA3 (møntsystem,beløb))
men i et sprog som Standard ML er herved ikke sparet noget: P˚a grund af den strikse
argumentoverføring beregnes hele listen, før dens hoved udtages.
Det, der er brug for, er muligheden for at “prøve sig frem”: man skal kunne træffe et valg,
men hvis det viser sig ikke at føre til en brugbar løsning, skal det senere kunne gøres om.
Denne strategi, som passende kunne kaldes blindgydesøgning (eng.:backtrack programming),
er let at programmere, n˚ar man kan kaste og gribe undtagelser:
exception Ubetaleligt;
exn Ubetaleligt = Ubetaleligt : exn
fun betalB ( ,0) = []
| betalB ([], ) = raise Ubetaleligt
| betalB (mntr1 as mnt :: mntr,blb)
= if blb < 0 then raise Ubetaleligt
else mnt :: betalB (mntr1,blb - mnt)
handle
Ubetaleligt => betalB (mntr,blb);
val betalB = fn : int list * int -> int list
betalB (DKmntr,1425);
val it = [1000, 200, 200, 25] : int list
betalB ([5,2],11);
val it = [5, 2, 2, 2] : int list
betalB ([5,2],3);
! Uncaught exception:
! Ubetaleligt
Vi prøver først at medtage møntsystemets største mønt
mnt :: betalB (mntr1,blb - mnt), men hvis det ikke fører til en løsning, prøves den
anden mulighed: ikke at medtage denne mønt betalB (mntr,blb). Kun hvis slet ingen
kombination af valg kan bruges, forplanter undtagelsen sig til det yderste funktionskald
(som hvis 3 skal betales med 5 og 2).
10.5 Otte-dronning-problemet
Blindgydesøgning illustreres med endnu et klassisk eksempel, det s˚akaldte “otte-dronningproblem”
(se eventuelt ogs˚a [5, Sect. 7.7]). En “dronning” i skak sl˚ar andre brikker p˚a samme
række, samme søjle (i skak kaldet “linje”) og p˚a de samme diagonaler. Opgaven er at placere
otte dronninger p˚a et skakbræt, s˚a ingen af dem kan sl˚a nogen af de andre.
Man kan forsøge at finde en enkelt løsning, at finde alle løsninger eller at finde ud af,
hvilke essentielt forskellige løsninger der er, n˚ar symmetriske løsninger kun skal medregnes
en gang.
I 1850 blev problemet undersøgt af matematikeren Karl Friedrich Gauß, som dog ikke
løste det fuldt ud.
140

8
7
6
5
4
3
2
1
❊❆✁❆✁❆✁✆
❊
❊
✆
✆
❊❆✁❆✁❆✁✆
❊
❊
✆
✆
❊❆✁❆✁❆✁✆
❊
❊
✆
✆
❊❆✁❆✁❆✁✆
❊
❊
✆
✆
❊❆✁❆✁❆✁✆
❊
❊
✆
✆
❊❆✁❆✁❆✁✆
❊
❊
✆
✆
❊❆✁❆✁❆✁✆
❊
❊
✆
✆
❊❆✁❆✁❆✁✆
a b c d e f g h
Figur 10.2: En løsning p˚a problemet med de otte dronninger.
Med computer til r˚adighed kan problemet angribes efter principperne for kombinatorisk
søgning. Lad os i første omgang blot prøve at finde en enkelt løsning (opgave 10.6 g˚ar ud p˚a
at finde alle løsninger).
Det er værd at bemærke, at den samme opgave kunne stilles for et bræt med n × n felter
for andre værdier af n end 8, og efter princippet om at søge den størst mulige enkelhed ved
passende generalisering vælger vi at konstruere programmet, s˚a der kun skal ændres ganske
lidt, for at det vil kunne fungere med andre brætstørrelser (jævnfør opgave 10.7).
Otte-dronning-problemet repræsenterer en fundamental klasse af kombinatoriske problemer
og blev meget tidligt taget op i den datalogiske litteratur. Man finder for eksempel
problemet behandlet i Edsger W. Dijkstra: Notes on Structured Programming, Technical
University Eindhoven (1970) og i Niklaus Wirth: Program Development by Stepwise Refinement,
Communications of the ACM 14 (April 1971) 221–227, mens en helt anden indgangsvinkel
kan ses i Peter Naur: An Experiment on Program Development, BIT 12 (1972)
347–365.
Der kan højst være en dronning p˚a hver linje, s˚a hvis der i alt skal placeres otte, m˚a der
netop st˚a en p˚a hver linje. Vi forsøger at placere dem fra en ende af, for eksempel først en
dronning p˚a linje 8 (=h), s˚a p˚a linje 7 (=g), og s˚a videre ned til linje 1 (=a). Til r˚adighed
under løsning af den delopgave at placere en dronning i linje x vil vi derfor have en delløsning
best˚aende af dronninger i linjerne x + 1, . . . , 7, 8.
141
❊
❊
✆
✆

En dronnings placering kunne vises som (x, y), hvor x er linjenummeret og y rækkenummeret;
en delløsning af den nævnte slags kunne da repræsenteres
[(x + 1,yx+1),. . .,(7,y7),(8,y8)]. Denne repræsentation er valgt i [5, Sect. 7.7], men det
er klart, at linjenumrene kan underforst˚as, og det vil vi udnytte her, s˚a en s˚adan delløsning
blot vil blive repræsenteret gennem listen [yx+1,. . .,y7,y8].
N˚ar en dronning skal placeres p˚a en linje, prøves rækkerne af i rækkefølgen 8, 7, . . . , 2, 1.
Den centrale funktion i løsningen er dronning ((x,y),yr), som forsøger at udvide delløsningen
yr med en dronning i (x, y). Den ønskede løsning dannes ved, at man udefra kalder
p˚a formen dronning ((8,8),[]). Funktionens opbygning skal tage hensyn til følgende:
• Hvis x = 0, er der allerede en dronning i linjerne 1 . . . 8, s˚adan at “del”løsningen faktisk
er en fuld løsning og kan returneres som facit.
• Hvis y = 0, har alle mulige rækker været forsøgt forgæves for dronningen i den aktuelle
linje. Vi er havnet i en blindgyde og m˚a omgøre et af de tidligere valg.
• Ellers skal det undersøges, om nogen af delløsningens dronninger sl˚ar feltet (x, y).
Hvis det ikke er tilfældet, kan delløsningen udvides med en dronning p˚a dette felt, og
dronning kan kaldes rekursivt med den udvidede delløsning i forsøg p˚a ogs˚a at placere
en dronning i linje x − 1, i første omgang i række 8.
• I tilfælde af, at det rekursive kald mislykkes, m˚a vi i stedet prøve feltet (x, y − 1).
• Ogs˚a hvis en dronning p˚a (x, y) kan sl˚as af de andre, m˚a vi i stedet prøve (x, y − 1).
De beskrevne punkter kan direkte identificeres i programmet:
fun dronning ((0, ),yr) = yr
| dronning (( ,0), ) = raise Dronning
| dronning ((x,y),yr)
= if sikker ((x,y),x + 1,yr)
then dronning ((x - 1,8),y :: yr)
handle Dronning => dronning ((x,y - 1),yr)
else dronning ((x,y - 1),yr)
Vi har her præsenteret den centrale struktur uden først at definere de indg˚aende størrelser.
Undtagelsen Dronning skal erklæres. Dronninger p˚a (x, y) og (x1, y1) kan sl˚a hinanden,
hvis de st˚ar p˚a samme linje (x = x1), samme række (y = y1) eller samme diagonal (x + y =
x1 + y1 eller x − y = x1 − y1). Ved hjælp af funktionen slaar defineres sikker, hvor det
ud over delløsningen yr og det aktuelle felt (x, y) er bekvemt at tage en ekstra parameter
med til at holde styr p˚a delløsningens længde. (Værdien af den ekstra parameter er faktisk
linjenummeret for delløsningens forreste dronning.)
Det er ogs˚a bekvemt at konstruere en funktion visBraet, som kan fremstille en løsning
grafisk. (Mange medier viser tegn med 10 tegn pr. tomme2 vandret, men 6 linjer pr. tomme
lodret; for at f˚a felterne nogenlunde kvadratiske har vi derfor valgt, at hvert felt skal fylde
to tegn vandret.) For nemheds skyld er funktionen skrevet, s˚a brættet roteres 90◦ , n˚ar det
skrives ud:
a
b c
d efg
h
12345678
2 En amerikansk tomme (eng.:inch) er standardiseret til 25.4 mm.
142

Nu skulle det samlede program være til at forst˚a:
fun prikker 0 =
| prikker n = ". "^ prikker (n - 1)
fun visBraet [] =
| visBraet (y :: yr)
= prikker (y - 1) ^ "* "^ prikker (8 - y) ^ "\n"
^ visBraet yr
fun slaar ((x,y),(x1,y1))
= (* x = x1 orelse *) y = y1
orelse x + y = x1 + y1 orelse x - y = x1 - y1
fun sikker ((x,y), ,[]) = true
| sikker ((x,y),x1,y1 :: yr)
= not (slaar ((x,y),(x1,y1)))
andalso sikker ((x,y),x1 + 1,yr)
exception Dronning
fun dronning ((0, ),yr) = yr
| dronning (( ,0), ) = raise Dronning
| dronning ((x,y),yr)
= if sikker ((x,y),x + 1,yr)
then dronning ((x - 1,8),y :: yr)
handle Dronning => dronning ((x,y - 1),yr)
else dronning ((x,y - 1),yr);
val prikker = fn : int -> string
val visBraet = fn : int list -> string
val slaar = fn : (int * int) * (int * int) -> bool
val sikker = fn : (int * int) * int * int list -> bool
exn Dronning = Dronning : exn
val dronning = fn : (int * int) * int list -> int list
print (visBraet (dronning ((8,8),[])));
. . . . * . . .
. . . . . . * .
. * . . . . . .
. . . . . * . .
. . * . . . . .
* . . . . . . .
. . . * . . . .
. . . . . . . *
val it = () : unit
10.6 Sammenfatning
Mange opgaveløsninger best˚ar af en sekvens af valg. Hvis valgene kan ordnes, s˚a trufne valg
aldrig skal omgøres, kan man blot benytte det gr˚adige princip. Gængse møntsystemer er
s˚adan indrettet, at med alle møntstørrelser til r˚adighed kan betalinger bruge det gr˚adige
143

princip.
I almindelighed kan det være nødvendigt at “prøve sig frem”. Blindgydesøgning er den
søgestrategi, hvor det systematisk er det senest trufne valg, der gøres om.
Undtagelser erklæres med exception, kastes med raise og gribes med handle. Ved
at bruge undtagelser er det let at programmere blindgydesøgning efter den første mulige
løsning.
Alle løsninger p˚a et problem kan man f˚a frem ved at arbejde med en liste af løsninger.
Længden af denne liste er s˚a antallet af løsninger. (Hvis problemet er uløseligt, bliver listen
tom.)
10.7 Opgaver
Opgave 10.1 BetalG benytter den urealistiske forudsætning, at der er et vilk˚arligt antal af
hver møntværdi til r˚adighed. Modificer funktionen, s˚a den betaler fra en endelig pengepung.
Opgave 10.2 Definer foranAlle ved hjælp af map og en anonym funktion.
Opgave 10.3 Skriv en funktion, som ud fra et ˚arstal og dagens nummer i ˚aret beregner
datoen (i form af m˚anedens nummer og dagens nummer inden for den p˚agældende m˚aned).
Opgave 10.4 (Ideen til denne opgave skyldes Peter Sestoft.) Romertalord skrives med
bogstaverne ”M”(1000), ”D”(500), ”C”(100), ”L”(50), ”X”(10), ”V”(5) og ”I”(1). Normalt
skrives bogstaver med mindre vægt til højre for bogstaver med større vægt; hvis et bogstav
skrives til venstre for et med større vægt, skal dets egen vægt subtraheres. Antag, de eneste
tilladte kombinationer af den slags er ”IV”, ”IX”, ”XL”, ”XC”, ”CD”og ”CM”. Skriv et
program, der omsætter tal til romertalord. Programmet kan benytte det gr˚adige princip.
Opgave 10.5 I denne opgave kaldes en liste for delliste af en anden, hvis alle dens elementer
er indeholdt i den anden og st˚ar i samme rækkefølge. Skriv en funktion, der ud fra en liste
som argument danner listen af alle dens dellister. Den rækkefølge, dellisterne kommer i, er
underordnet. Med argumentet [1,2,3] kunne funktionsværdien for eksempel være
[[],[3],[2],[2,3],[1],[1,3],[1,2],[1,2,3]]. Vink: Man kan bruge omtrent samme
programskabelon som i betalA.
Opgave 10.6 Find alle løsninger til otte-dronning-problemet (der er 92). Skriv ogs˚a en
funktion, der kun medtager én repræsentant fra hver klasse af symmetriske løsninger (der
er 12 forskellige løsninger, hvis symmetri tages i betragtning).
Opgave 10.7 Generaliser otte-dronning-problemet til den opgave at placere n dronninger
p˚a et n × n-bræt. For n = 2 og n = 3 er der ingen løsninger, men for n = 4 er der 2 (1
modulo symmetri). Hvor mange løsninger er der for n = 5, n = 6 og n = 7?
144

Kapitel 11
Køretidseffektivitet
11.1 Eksempel: potensopløftning
Vi vil konstruere en funktion til beregning af x n . Her kan x være et hvilket som helst reelt
tal, mens vi vil forudsætte, at n er et naturligt tal, s˚a man kan bygge p˚a formlen
x n = x · x · · · x
n
(11.1)
(Matematikere kan udvide definitionen af potensopløftning til eksponenter, der er negative,
brudne og s˚agar vilk˚arlige reelle og komplekse tal, men det kræver, at man g˚ar ud over
definitionen (11.1), som vi vil bygge p˚a her1 .)
Af (11.1) indses
x n = x · x n−1
(11.2)
der er et godt grundlag for beregning, idet x n her er dannet ved hjælp af det simplere udtryk
x n−1 . Vi mangler en basis for rekursionen. Her kunne man vælge x 2 = x · x eller x 1 = x,
men efter princippet om at reducere antallet af specialtilfælde vælger vi
x 0 = 1 (11.3)
som giver (11.2) det størst mulige gyldighedsomr˚ade (alle positive hele n) og medfører de to
andre identiteter (x 1 = x og x 2 = x · x).
Funktionsdefinitionen kan bygge p˚a (11.3) og (11.2):
fun oploefttil (x : real, n : int)
= if n = 0 then 1.0 else x * oploefttil (x, n - 1);
val oploefttil = fn : real * int -> real
Læg mærke til typebegrænsningerne af x og n og til, hvordan basis for multiplikationerne
skal være den flydende talkonstant 1.0 (som ogs˚a kunne have været skrevet real 1).
(Typebegrænsningerne kunne strengt taget undværes, idet de impliceres af brugen af 1.0
og af operationerne n = 0 og n - 1.)
Funktionen skal afprøves, s˚a i den fil, hvori definitionen er skrevet, tilføjer vi
1 I oversættelsesenheden Math ligger biblioteksfunktionen Math.pow : real * real -> real.
145

oploefttil (real 3, 0) = real 1;
oploefttil (real 4, 1) = real 4;
oploefttil (real 3, 2) = real 9;
oploefttil (real 2, 3) = real 8;
(som alle besvares af systemet med val it = true : bool ).
11.1.1 En forbedring
Det er oplagt, at et kald af formen oploefttil (x, n) løser sin opgave ved at udføre n
multiplikationer, men s˚a mange er det ikke nødvendigt at bruge! Man kan jo kvadrere et
tal med én multiplikation, s˚a for at beregne for eksempel x 4 = (x 2 ) 2 kan man nøjes med to
multiplikationer, og for store eksponenter bliver gevinsten betragtelig. Man kan sige, at vi
har fundet endnu en egenskab
som kan udnyttes i funktionsdefinitionen:
x n = (x 2 ) n
2 for lige naturlige tal n (11.4)
fun oploefttilhurt (x : real, n : int)
= if n = 0 then 1.0
else if n mod 2 = 0
then oploefttilhurt (x * x, n div 2)
else x * oploefttilhurt (x, n - 1);
oploefttilhurt (real 3, 0) = real 1;
oploefttilhurt (real 4, 1) = real 4;
oploefttilhurt (real 3, 2) = real 9;
oploefttilhurt (real 2, 3) = real 8;
11.2 M˚aling af ressourceforbrug
Ved at prøve forskellige eksempler af ved terminalen kan man godt fornemme, at oploefttil
ikke er s˚a effektiv som oploefttilhurt, men det er nyttigt at kunne understøtte denne
fornemmelse med konkrete tal.
Mosml.time
I oversættelsesenheden Mosml ligger en biblioteksfunktion
Mosml.time : (α -> β) -> (α -> β)
som kan bruges til m˚aling af ressourceforbrug. Det fremg˚ar af typen, at der er tale om en
højereordensfunktion: for en funktion f beregner konstruktionen Mosml.time f det samme
som f, men i tilgift f˚ar man, i en ekstra linje oven over funktionsværdien, en opsummering
af beregningens tidsforbrug.
Helt konkret betyder det, at man (efter at direktivet load "Mosml"; har gjort funktionen
Mosml.time tilgængelig) kan f˚a m˚alt ressourceforbruget for et kald f x ved i stedet at
skrive (Mosml.time f) x (hvor parentesen i øvrigt kan undværes, fordi funktionsanvendelse
associerer fra venstre).
Den ekstra linje med oplysninger har formen
146

User: brugttid System: systtid GC: spildop Real: sandtid
idet sandtid er den faktisk forløbne tid, brugttid er det tidsrum, centralenheden 2 har været
benyttet, systtid er tiden brugt p˚a systemkald og spildop er tiden brugt under s˚akaldte
spildopsamlinger (hvilket til en vis grad m˚aler lagerforbruget). Enheden for tidsangivelserne
er sekunder.
Man kan for eksempel finde:
load "Mosml";
val it = () : unit
Mosml.time oploefttil (2.0, 1000);
User: 0.010 System: 0.000 GC: 0.000 Real: 0.018
val it = 1.07150860719E301 : real
Mosml.time oploefttilhurt (2.0, 1000);
User: 0.000 System: 0.000 GC: 0.000 Real: 0.001
val it = 1.07150860719E301 : real
11.3 Beregning af udførelsestid
M˚alinger kan naturligvis kun give oplysning om forløbet for konkrete inddatasæt, hvilket ikke
er tilstrækkeligt, hvis man vil udtale sig om en funktions ressourceforbrug i almindelighed.
S˚adanne udtalelser m˚a bygge p˚a analyser af selve programteksten. For oploefttil (x, n)
ses det, at de dele af programmet, som udføres, hvis n = 0, er
if n = 0 then 1.0 else . . .
De hermed forbundne beregninger m˚a formodes at tage en vis konstant tid a.
Lad os indføre notationen Tf(x) som betegnelse for den tid, det tager at kalde en bestemt
ML-funktion f med argumentet x. S˚a har vi lige set, at
Toploefttil(x, 0) = a (11.5)
For n > 0 er der fire skridt i beregningen oploefttil (x, n):
1. Indledningsvis beregnes if n = 0 then ... else
2. Derefter evalueres n1 = n - 1 (fordi ML har striks parameteroverføring)
3. S˚a udføres det rekursive kald x1 = oploefttil (x, n1)
4. Og til sidst multipliceres x * x1
Her kan vi g˚a ud fra, at skridtene 1, 2 og 4 tilsammen tager en vis konstant tid b, mens
tiden for skridt 3 jo er Toploefttil(x, n − 1), alts˚a:
Toploefttil(x, n) = b + Toploefttil(x, n − 1) for n > 0 (11.6)
Af de to ligninger (11.5) og (11.6) finder man
Toploefttil(x, n) = a + b · n (11.7)
2 En computers centralenhed (eng.:central processing unit eller CPU) er den aktive enhed, som foretager
den egentlige ordrefortolkning.
147

Analyse af oploefttilhurt
Den forbedrede funktion er lidt vanskeligere at behandle. Man indser, at der m˚a være konstanter
a, b0 og b1, s˚a
Toploefttilhurt(x, 0)
Toploefttilhurt(x, n)
=
=
a
b0 + Toploefttilhurt(x
(11.8)
2 , n
)
2
for lige n > 0 (11.9)
Toploefttilhurt(x, n) = b1 + Toploefttilhurt(x, n − 1) for ulige n (11.10)
Da tallet umiddelbart forud for et ulige tal jo er lige, medfører de to sidste ligninger
(11.9) og (11.10)
Toploefttilhurt(x, n) ≤ b + Toploefttilhurt(x 2 , n div 2) for n > 0 (11.11)
for en passende konstant b, og af (11.8) og (11.11) finder man
Toploefttilhurt(x, n) ≤ a + b · k (11.12)
hvor k er antallet af gange, n skal divideres med 2, før man f˚ar 0.
For funktionen oploefttil kunne udførelsestiden direkte udtrykkes som en funktion
af n, der var den ene komponent af inddataparret, men i almindelighed behøver inddata
ikke at være tal: de kan ogs˚a være tegn eller tekster eller strukturer af forskellig slags. Da
er man interesseret i at knytte et eller andet størrelsesm˚al til inddata og s˚a at f˚a udtrykt
udførelsestiden som funktion af inddatas størrelse. Vælger man at bruge n til vurdering af
størrelsen af (x, n), har vi i ligningen (11.7) direkte et udtryk for udførelsestiden.
Inddata af samme størrelse kan have forskellige udførelsestider; det, man som regel er
interesseret i, er da at finde udførelsestiden i det værste tilfælde. Det er heller ikke altid let
(om overhovedet muligt) at finde et eksplicit udtryk for denne udførelsestid, og man vil da
være tilfreds med bare at finde en begrænsning opadtil, alts˚a en eller anden funktion g, s˚a
Tf(x) ≤ g(n) for alle inddata x af størrelse n.
For oploefttilhurt fandt vi (11.12), der ogs˚a (for n = 0) kan skrives
Toploefttilhurt(x, n) ≤ a ′ + b ′ · log 2 n
idet ⌊log 2 n⌋ (det største hele tal mindre end eller lig med totalslogaritmen af n) er antallet
af gange, et tal n skal heltalsdivideres med 2, før man f˚ar 1.
11.4 Funktioners vækst
Nøjagtige formler for, hvor lang tid et program kører, kan være vanskelige at finde — og
selv om man finder dem, kan de være s˚a komplicerede, at det er vanskeligt at gennemskue,
hvad de egentlig betyder.
Som regel har man heller ikke brug for den eksakte formel; i praksis er situationen ofte
den, at det afgørende er, hvordan køretiden vokser med voksende inddatastørrelse. Flytter
man et program fra en lille maskine til en større og dyrere, der har mere lager og kan udføre
flere ordrer i sekundet, vil det naturligvis køre hurtigere. Men forsyner man den lille maskine
med et bedre program, er det alligvel muligt, at den for visse (passende store) inddata vil
klare sig bedre end den store maskine med det d˚arligere program, som illustreret i figur 11.1.
148

tid
11.4.1 Store O-notation
Vi havde jo fundet
✻
✑ (1)
(2)
✟
✭✭
(3)
✑✑✑✑✑✑✑✑✑✑✑✑✑✑✑✑✑✑✑✑✑✑✑
✑✟✟✟✟✟✟✟✟✟✟✟✟✟✟✟✟✟✟✟✟✟✟✟ ✟
Figur 11.1: Køretider for potensopløftning
(1) oploefttil (x, n) p˚a et langsomt system
(2) oploefttil (x, n) p˚a et hurtigt system
✲
(3) oploefttilhurt (x, n) p˚a et langsomt system
Toploefttil(x, n) = a + b · n
Toploefttilhurt(x, n) ≤ a ′ + b ′ · log 2 n
n
(11.13)
og det interessante er derfor ikke størrelsen af konstanterne a, b, a ′ og b ′ (som afhænger af
den konkrete maskine og det konkrete programmeringssprogssystem), men forskellen mellem
funktionerne n ↦→ n og n ↦→ log 2 n.
For at beskrive denne forskel er det almindeligt at bruge den s˚akaldte “store O-notation”
(oprindeligt benyttet af P. Bachmann i bogen Analytische Zahlentheorie fra 1892). O’et er
en forkortelse for “orden”, og meningen er, at hvis f er en funktion af de naturlige tal,
betegner O(f(n)) (læses: store O af f af n) en ikke nærmere specificeret værdi af samme
størrelsesorden som f(n). Mere præcist kan man sige, at
Hver forekomst af O(f(n)) betegner en størrelse xn, for hvilken der findes
konstanter M og n0 ≥ 0, s˚adan at |xn| ≤ M · |f(n)| for alle n ≥ n0.
De nøjagtige værdier af M og n0 angives ikke af notationen, og bruges symbolet O(f(n))
flere gange, kan der høre forskellige værdier af M og n0 til de forskellige forekomster.
Her er nogle eksempler p˚a brug af notationen:
37 + 102n =O(n) fordi 37 + 102n ≤ 139n for n ≥ 1
a + b · n =O(n)
7 − 12n + 6n 2 =O(n 2 ) fordi 7 − 12n + 6n 2 ≤ 13n 2 for n ≥ 1
a + b · n + c · n 2 =O(n 2 )
a + b log 2 n =O(log 10 n) fordi a + b log 2 n ≤ (a + 4b) log 10 n for n ≥ 10
149

Man plejer i øvrigt ikke at angive noget grundtal for logaritmer, der bruges i beskrivelse
af en størrelsesorden O(. . . log . . .), eftersom logaritmer med forskellige grundtal jo er
proportionale (husk: log a r = log b r
log b a ).
Det er i øvrigt en konsekvens af notationen, at en konstant kan betegnes som O(1) (alts˚a
for eksempel: 31 = O(1)).
Med den indførte notation til r˚adighed kan resultatet fra (11.13) nu kompakt udtrykkes:
Toploefttil(x, n) = O(n)
Toploefttilhurt(x, n) = O(log n)
Man siger ogs˚a, at oploefttil asymptotisk har lineær udførelsestid, mens størrelsesordenen
af udførelsestiden for oploefttilhurt asymptotisk er logaritmisk.
11.4.2 Store Ω- og store Θ-notation
Nu, hvor vi har indført store O-notationen for asymptotisk begrænsning opadtil, er det p˚a
sin plads at omtale to beslægtede notationer.
Undertiden har man brug for at udtale sig om, at et problem eller en algoritme mindst
kører i s˚a og s˚a lang tid. Køretiden vil naturligvis afhænge af inddatas størrelse, men man
ønsker et funktionsudtryk, der asymptotisk begrænser den nedadtil.
Hver forekomst af Ω(f(n)) (læses: store omega af f af n)
betegner en størrelse zn, for hvilken der findes konstanter
m > 0 og n0 ≥ 0, s˚adan at m · |f(n)| ≤ |zn| for alle
n ≥ n0.
Som før er der tale om en upræcis notation, der abstraherer fra de konkrete værdier af m
og n0, og ved forskellige forekomster af Ω(f(n)) kan værdierne af m og n0 være forskellige.
Hvis en størrelse er asymptotisk begrænset af samme funktion b˚ade opadtil og nedadtil,
er den asymptotisk tæt begrænset af denne funktion, og man plejer at bruge det græske
bogstav store theta som betegnelse herfor: Man siger, at yn = Θ(f(n)), hvis der b˚ade gælder
yn = O(f(n)) og yn = Ω(f(n)).
11.5 Effektivitet
Hver forekomst af Θ(f(n)) betegner en størrelse yn, for
hvilken der findes konstanter M, m > 0 og n0 ≥ 0, s˚adan
at m · |f(n)| ≤ |yn| ≤ M · |f(n)| for alle n ≥ n0.
Med oploefttilhurt er effektiviteten forbedret p˚a bekostning af overskueligheden: antallet
af tilfælde blev øget fra to til tre, idet vi inddrog relationen (11.4). Lad os overveje den
tilsvarende identitet
x n = (x n
2 ) 2
for lige naturlige tal n (11.14)
hvor de to eksponenter er byttet om. Denne identitet er naturligvis lige s˚a god at bygge en
effektiv potensopløftning over — hvis man vel at mærke gør det rigtigt!
Her er det gjort forkert:
150

fun oploefttillngs (x : real, n : int)
= if n = 0 then 1.0
else if n mod 2 = 0
then oploefttillngs(x,n div 2)*oploefttillngs(x,n div 2)
else x * oploefttillngs (x, n - 1);
val oplloefttillngs = fn : real * int -> real
Mosml.time oploefttillngs (2.0, 1000);
User: 0.040 System: 0.000 GC: 0.000 Real: 0.044
val it = 1.07150860719E301 : real
Det var ˚abenbart en forværring snarere end en forbedring!
Advarsel Det kan stærkt anbefales, at man indtaster disse funktioner og m˚aler køretiden
for kald af oploefttil, oploefttilhurt og oploefttillngs med forskellige argumentværdier,
men p˚a flerbrugersystemer er det vigtigt ikke at overdrive: Man kan komme til at sætte
s˚a omfattende beregninger i gang, at systemets øvrige brugere generes af det.
Grunden til den d˚arlige udførelsestid for oploefttillngs er naturligvis, at selv om dybden
af kaldtræet en nøjagtig den samme som i kaldtræet for oploefttilhurt (antallet af gange,
n skal heltalshalveres for at blive 0 og alts˚a af størrelsesorden log n), s˚a har hver knude med
lige n to nye knuder under sig (se figur 11.2) (og ikke som i oploefttilhurt kun én), s˚a
optill (x, 7)
optill (x, 6)
✘✘❳
✘✘✘
❳❳❳
✘✘✘
❳❳❳
✘
❳❳❳
optill (x, 3) optill (x, 3)
optill (x, 2) optill (x, 2)
✘✘✘❳❳
✘✘
❳❳❳
✘✘✘❳❳
✘✘
❳❳❳
optill (x, 1) optill (x, 1) optill (x, 1) optill (x, 1)
optill (x, 0) optill (x, 0) optill (x, 0) optill (x, 0)
Figur 11.2: Kaldtræet for oploefttillngs (x, 7) (forkortet til optill (x, 7)).
det samlede antal knuder i kaldtræet bliver af størrelsesorden n.
Det er tydeligt for os, at de to indre kald oploefttillngs (x,n div 2) er ens, men det
er ML-afviklingssystemet ikke programmeret til at finde ud af: Skriver man to funktionskald,
s˚a udføres der to funktionskald!
Det rigtige er at huske værdien af det indre funktionskald i en hjælpevariabel:
fun oploefttilhurt2 (x : real, n : int)
= if n = 0 then 1.0
151

else if n mod 2 = 0
then let val xn2 = oploefttilhurt2 (x, n div 2)
in xn2 * xn2 end
else x * oploefttilhurt2 (x, n - 1);
val oplloefttilhurt2 = fn : real * int -> real
Mosml.time oploefttilhurt2 (2.0, 1000);
User: 0.000 System: 0.000 GC: 0.000 Real: 0.001
val it = 1.07150860719E301 : real
En anden m˚ade at opn˚a effektiviteten p˚a ville være at kvadrere ved hjælp af funktionen
kvadrat fra afsnit 2.3.1; i udtrykket kvadrat (oploefttilhurt3 (x, n div 2)) vil
funktionsargumentet (for kaldet af kvadrat) oploefttilhurt3 (x, n div 2) kun blive
beregnet én gang (fordi ML er strikst).
fun oploefttilhurt3 (x : real, n : int)
= if n = 0 then 1.0
else if n mod 2 = 0
then kvadrat (oploefttilhurt3 (x, n div 2))
else x * oploefttilhurt3 (x, n - 1);
val oplloefttilhurt3 = fn : real * int -> real
11.6 Listespejling
Tabel [5, D.17] viser, at der er en biblioteksfunktion rev til at spejlvende (eng.:reverse) en
liste, men det er lærerigt selv at prøve at konstruere s˚adan en – lad os kalde den spejl.
En liste er enten tom, og s˚a er den spejlvendte liste det ogs˚a, eller ogs˚a har den formen
x :: xr, i hvilket tilfælde den spejlvendte liste begynder med det spejlvendte af xr og slutter
med x. S˚adan set har vi nu to egenskaber, ud fra hvilke spejl kunne konstrueres
spejl [] = []
spejl (x :: xr) = spejl xr @ [x]
(11.15)
men for at vurdere køretiden for spejl herudfra m˚a man vide, hvor lang tid listesammenstilling
med operatoren @ tager. Den letteste m˚ade at forst˚a kompleksiteten af @ p˚a er at
forestille sig, man ogs˚a selv skulle konstruere den:
11.6.1 Analyse af listesammenstillen (operatoren @)
Den forreste af de to lister, der skal stilles sammen, er enten tom eller er konstrueret af et
hoved sat foran en hale. Vi finder egenskaberne
[] @ yr = yr
(x :: xr) @ yr = x :: (xr @ yr)
der kan lægges til grund for definitionen af den tilsvarende funktion, som vi vælger at kalde
“append”:
152

fun append ([], yr) = yr
| append (x :: xr, yr) = x :: append (xr, yr);
val append = fn : ’a list * ’a list -> ’a list
Programmet viser, at udførelsestiden for append kan findes p˚a omtrent samme m˚ade,
som vi brugte ovenfor til at finde udførelsestiden for oploefttil: Der m˚a være konstanter
a og b, s˚adan at
Tappend([], yr) = a
Tappend(x :: xr, yr) = b + Tappend(xr, yr)
Af disse ligninger finder man Tappend([x1,x2,. . .,xn], yr) = a + b · n. Køretiden er alts˚a
helt uafhængig af anden liste, men asymptotisk lineært begrænset af længden af den første
liste:
Udførelsestiden for sammenstillen af to lister xr og yr
er O(length xr)
11.6.2 Analyse af funktionen spejl
Med udgangspunkt i (11.15) konstruerer vi nu spejl:
fun spejl [] = [] | spejl (x :: xr) = append (spejl xr, [x]);
val spejl = fn : ’a list -> ’a list
Der m˚a være en konstant a, s˚a
Tspejl([]) = a (11.16)
Skridtene under spejlvending af en ikke tom liste x :: xr ses at være (de to første skridt
skyldes, at argumenterne til append jo beregnes før kaldet):
1. En spejlvending af xr
2. Konstruktion af singletonlisten [x]
3. Kaldet af append
Tiden for skridt 1 er Tspejl(xr); tiden for skridt 2 kan antages at være en konstant b, og
tiden for skridt 3 er ifølge analysen ovenfor begrænset af en konstant c gange længden af
den spejlvendte liste.
Nu har den spejlvendte liste og listen selv jo samme længde, s˚a samlet kan det skrives
Tspejl(x :: xr) ≤ Tspejl(xr) + b + c · length xr (11.17)
Af (11.16) og (11.17) finder man for en liste af længde n
n(n − 1)
Tspejl([x1, x2, . . ., xn]) ≤ a+bn+c(1+2+3+. . .+n−1) = a+bn+c
2
= O(n 2 )
Udførelsestiden for spejlvendingsfunktionen i dette afsnit er asymptotisk begrænset
af kvadratet p˚a listens længde.
153

Summen af en differensrække
I udregningen ovenfor fik vi brug for at beregne summen af tallene 1, 2, 3, . . . , n − 1, hvor
hvert tal netop er 1 større end det foreg˚aende. En talrække, hvor forskellen mellem hvert tal
og det foreg˚aende tal har en konstant værdi d, kaldes en differensrække med differens d, og
for summen af en s˚adan række findes en færdig formel, vi vil udlede i dette afsnit.
Kald det første af tallene a og antallet af dem for n; talrækken best˚ar da af
a1 = a, a2 = a + d, a3 = a + 2d, . . . , an−1 = a + (n − 2)d, an = a + (n − 1)d
Indføres betegnelsen S for tallenes sum (den værdi, vi er ude p˚a at finde en formel for),
finder man ved omordning af leddene i S + S:
eller
2S =
a +a + d +a + 2d
+a + (n − 1)d +a + (n − 2)d +a + (n − 3)d
= 2a + (n − 1)d +2a + (n − 1)d +2a + (n − 1)d
= n · (2a + (n − 1)d) = n · (a1 + an)
S = n
2 · (a1 + an)
. . .
. . .
. . .
Summen af tallene i en differensrække er halvdelen af antallet
gange det første plus det sidste tal.
+a + (n − 1)d
+a
+2a + (n − 1)d
(11.18)
Summen af de n tal fra 1 til n er derfor n(1+n),
og det var den formel, som blev benyttet
2
ovenfor.
Anvisning Prøv at definere de viste funktioner, og prøv at m˚ale deres køretider med
Mosml.time. For at eksperimentere med spejlvending af lister af forskellig længde kunne
man definere spejl (gentag (n, 1)) eller spejl (interval (1, n)) som funktion af n,
hvor gentag og interval er funktionerne fra kapitel 9.
Eksperimenter bekræfter køretidens kvadratiske afhængighed af n. Sammen med ressourceforbruget
f˚ar man ogs˚a den spejlvendte liste (udtrykkets værdi) ud, hvilket i netop
denne forbindelse m˚aske er lidt forstyrrende 3 . Man kan da betjene sig af følgende trick (der
afgørende bygger p˚a den strikse parameteroverføring): kapsl udtrykket ind i en funktion,
som smider sit argument væk!
Man kunne for eksempel indføre
fun nul x = 0;
val nul = fn : ’a -> int
og s˚a tage tid p˚a nul (spejl (gentag (n, 1))) som funktion af n.
3 Hvis strukturer bliver tilstrækkeligt lange eller dybe, udskriver Moscow ML dem faktisk ikke fuldtud!
To systemvariable printLength, printDepth : int ref (se [13, afsnit 3.4]), der fra start af er sat til
henholdsvis 200 og 20, men hvis værdi man selv kan ændre (hvordan variable ændres, beskrives i [5, afsnit
18.2.4]), bestemmer, hvor meget man f˚ar at se.
154

11.7 Programtransformation
Fra dagligdagen er det kendt, hvordan man kan spejlvende en stak af emner ved at blade
den en gang igennem (se figur 11.3).
✬ ✩
4 ❄
5
6 3
7 2
8 1
Figur 11.3: Spejlvending af en stak af emner ved en enkelt gennembladning.
Derfor er spejlvending i kvadratisk tid ikke tilfredsstillende — det m˚a kunne gøres i
lineær tid. I dette afsnit vil vi konstruere s˚adan en funktion.
For potensopløftning s˚a vi, hvordan de hurtigere udgaver var mere komplicerede og vanskeligere
at konstruere end oploefttil, der direkte fulgte specifikationen, og det gælder
generelt: Hensynet til at f˚a et rimelig effektivt program betyder ofte, at man m˚a omforme
det specifikationsmæssige udgangspunkt, og trækker derved i modsat retning af hensynet til
enkelhed og overskuelighed.
Den ideelle m˚ade at konstruere et program p˚a ville være først at skaffe sig et korrekt
program ud fra den simplest mulige specifikation og derefter at gøre dette program effektivt
via transformationer, der vidstes at bevare korrektheden.
Del og hersk
Princippet bag konstruktionen af de hurtige potensopløftningsfunktioner kan siges at være
det, nogle har kaldt “del og hersk”, og som kan udtrykkes s˚aledes: Hvis et problem giver
anledning til delproblemer, er det en fordel at gøre det største delproblem mindst muligt.
I det aktuelle tilfælde: Det var bedre at dele x n i problemer af maksimalt halv størrelse
(x n
2 , samt en kvadrering) end at dele i et meget lille problem (multiplikation med x) og et,
som kun var ganske lidt mindre end det oprindelige problem (x n−1 ).
Hvis det ikke havde været s˚a tidskrævende at opsplitte en liste midti og at sammenhægte
lister, kunne man ogs˚a overveje “del og hersk” i forbindelse med listespejling — et program
ville kunne bygge p˚a egenskaben
Fortsættelser
spejl (xr @ yr) = spejl yr @ spejl xr
Vi vil forbedre spejlvendingsfunktionen ved at betragte en fortsættelse (eng.:continuation).
Ideen er, at hvis forbedrende omskrivninger forhindres af den kontekst, det rekursive kald
indg˚ar i, s˚a kan man undertiden komme igennem ved en generalisering, hvor konteksten
inddrages som ekstra funktionsparameter.
155

Det rekursive tilfælde er
spejl (x :: xr) = append (spejl xr, [x])
hvor det rekursive kald indg˚ar som første argument til append, eller sagt p˚a en anden m˚ade:
det rekursive kald fortsættes med efterhægtning af listen [x].
Lad os derfor i stedet for listespejling betragte en mere generel opgave: den at spejlvende
en liste og bagefter hægte en anden liste p˚a. Specifikation 4 :
spejlforan (xr, yr) = spejl xr @ yr
To krav m˚a naturligvis være opfyldt, hvis man skal have fornøjelse af at g˚a over til den
mere generelle opgave:
1. Den oprindelige funktion skal kunne beregnes som et specialtilfælde af den nye funktion.
2. I specifikationen for den nye funktion indg˚ar den oprindelige funktion, men hensigten
er, at den skal programmeres mere effektivt og uden reference til den gamle funktion.
Punkt 1. er opfyldt, fordi spejl xr fremkommer som det specialtilfælde af
spejlforan (xr, yr), hvor yr er tom.
For at tilgodese 2. foretages nogle omskrivninger, som bygger p˚a definitionerne af spejl
og append. For overskuelighedens skyld noteres append med operatoren @:
spejlforan ([], yr) = spejl [] @ yr = [] @ yr = yr
spejlforan (x :: xr, yr) = spejl (x :: xr) @ yr
= append (spejl xr, [x]) @ yr = (spejl xr @ [x]) @ yr
= spejl xr @ ([x] @ yr) = spejl xr @ (x :: yr)
= spejlforan (xr, x :: yr)
Her lykkedes det at udtrykke spejlforan uden brug af spejl, s˚a vi nu kan præsentere
en ny definition:
fun spejlforan ([], yr) = yr
| spejlforan (x :: xr, yr) = spejlforan (xr, x :: yr);
val spejlforan = fn : ’a list * ’a list -> ’a list
fun spejlhurt xr = spejlforan (xr, []);
val spejlhurt = fn : ’a list -> ’a list
I en vis forstand kan man sige, at spejlforan realiserer metoden skitseret i figur 11.3,
og da det rekursive kald benytter halen af argumentparrets førstekomponent, f˚as
Tspejlhurt(xr) = O(length xr)
Udførelsestiden for den hurtige spejlvendingsfunktion er asymptotisk lineært
begrænset af listens længde.
4 En effektiv implementering af spejlforan er faktisk tilgængelig i standardbiblioteket under navnet
List.revAppend.
156

11.8 Sammenfatning
Tidskompleksiteten for en algoritme er den funktion af n, som angiver det største antal
operationer, algoritmen vil foretage for inddata af længde n.
Ofte angives tidskompleksitetens størrelsesorden. En størrelse xn siges at være O(f(n)),
hvis der findes en konstant M, s˚a der fra et vist trin at regne (med andre ord for n ≥ n0)
gælder |xn| ≤ M · |f(n)|.
Man har tilsvarende forkortelser Ω(f(n)) og Θ(f(n)) for begrænsning nedadtil og tosidet
begrænsning.
Et funktionskalds faktiske tidsforbrug (i sekunder) kan m˚ales med biblioteksfunktionen
Mosml.time.
Køretiden for @ er proportional med længden af venstre operand.
Visse algoritmer (for eksempel potensopløftning) kan forbedres med metoden “del og
hersk”, som g˚ar ud p˚a, at de komplicerede tilfælde skal søges løst af to eller flere nogenlunde
lige store delproblemer.
Listespejling kunne omskrives til at køre i lineær tid ved at generalisere til en funktion,
som tog fortsættelsen af det indre rekursive kald med i betragtning.
11.9 Opgaver
Opgave 11.1 Antallet af opstillinger af n forskellige elementer valgt (uden tilbagelægning)
fra en mængde med x elementer (antallet af n-permutationer af x elementer) er den faldende
potensfunktion x (n) = x · (x − 1) · · · (x − n + 1) .
n
a. Konstruer og afprøv den faldende potensfunktion i ML.
b. Brug den faldende potensfunktion til at give endnu en definition af ( n k) fra opgave 5.2.
Opgave 11.2 Matematikere kan vise, at talrækken
1 + 1
1
1
,
1 + 1
2
2
,
1 + 1
3
3
, . . . ,
1 + 1
n
n
, . . .
er voksende og kommer vilk˚arlig tæt p˚a e, grundtallet for den naturlige logaritme. Skriv
passende hjælpefunktioner og et ML-udtryk, der bestemmer e med omkring tre decimalers
nøjagtighed i den forstand, at det finder en s˚adan værdi (1 + 1
10n )10n , at
1 + 1
10n
− 1 +
10n
1
n
n
< 0.0005
[Vink: Skriv først en funktion til beregning af (1 + 1
n )n .]
Prøv at udføre potensopløftningerne med de forskellige funktioner fra teksten, og m˚al
tidsforbruget. Følgen ((n + 1
n )n )n=1,2,3,... konvergerer meget langsomt, og den beskrevne metode
er ikke særlig god at beregne e efter. P˚a grund af afrundingsfejlene ved flydende regning
vil de forskellige potensopløftningsfunktioner give forskellige resultater, og kun med en af de
hurtige versioner er det muligt at finde flere end tre decimaler af e.
157

Opgave 11.3 Hvad er der galt med denne definition?
fun oploefttilhurt1 (x : real, n : int)
= if n mod 2 = 0 then oploefttilhurt1 (x * x, n div 2)
else if n = 0 then 1.0 else x * oploefttilhurt1 (x, n - 1);
Opgave 11.4 Antag, vi vælger at m˚ale størrelsen af inddata (x, n) ved længden af n,
forst˚aet som antallet af cifre, der skal bruges for at skrive tallet n ned. Hvad bliver da
størrelsesordenerne af udførelsestiderne for oploefttil og oploefttilhurt i værste tilfælde?
Opgave 11.5 I en af opgaverne i kapitel 8 skulle man programmere en version af udtagelsessortering,
der satte det største listeelement bagest. Et s˚adant program vil naturligt
komme til at indeholde en konstruktion af formen udtsort yr @ [y], som p˚a grund af
den lange venstreoperand for @ ikke er særligt effektiv. Indfør en generaliseret funktion, der
beregner udtsort yr @ xr, og programmer derved metoden uden brug af @.
Opgave 11.6 Konstruer funktionen minout : int list -> int, som ud fra en liste af
indbyrdes forskellige naturlige tal i lineær tid (som funktion af listens længde) beregner det
mindste naturlige tal, der ikke er med i listen. De naturlige tal er de ikke-negative hele
tal {0, 1, 2, . . .}. [Vink: Brug “del og hersk”, og udnyt oplysningen om, at den givne listes
elementer er forskellige.]
158

Kapitel 12
Effektiv sortering
12.1 Ineffektiv sortering
Vi vælger at m˚ale en sorteringsmetodes effektivitet p˚a det antal sammenligninger mellem
elementer, den kræver (i værste tilfælde) for at sortere en liste med n elementer 1 .
De sorteringsmetoder (boblesortering, indsættelsessortering og udtagelsessortering), som
blev omtalt i kapitel 8, foretog O(n) sammenligninger under hvert enkelt listegennemløb
og (i værste tilfælde) O(n 2 ) sammenligninger i alt (husk formlen (11.18) for summen af en
differensrække).
I dette kapitel præsenteres nogle bedre metoder.
12.2 En nedre grænse for sorteringstid
Den form for sorteringsmetoder, vi her betragter, skal for hver af de n! mulige inddata,
som kan dannes af n forskellige tal, opbygge uddata forskelligt. Det kan kun lade sig gøre,
hvis metoderne foretager tilstrækkeligt mange sammenligninger til, at der kan dannes n!
forskellige gennemløb af algoritmen. Da der er tale om binære sammenligninger, m˚a det
gennemløb, som stiller flest spørgsm˚al, mindst stille log 2(n!) af dem. (Med 1 spørgsm˚al kan
man f˚a 2 forskellige forløb, med 2 spørgsm˚al 4 forskellige forløb, . . . , med k spørgsm˚al 2 k
forskellige forløb.)
Her kan vi med fordel inddrage Stirlings formel (James Stirling 1764):
n n √
2πn < n! <
e
n n √ 1
2πn(1 +
e
10n )
Da logaritmen af venstresiden er O(n log n), indses det, at enhver sorteringsmetode, som
bygger p˚a sammenligning mellem elementerne, mindst m˚a have tidskompleksitet O(n log n).
Dette ræsonnement udtaler sig naturligvis ikke om, hvorvidt s˚a effektive sorteringsmetoder
faktisk findes — kun, at det umuligt kan gøres bedre.
1 Efter teorien for algoritmers kompleksitet burde man tage udgangspunkt i inddatas længde, m˚alt i bit.
Efter denne teori skulle man alts˚a ogs˚a tage i betragtning, hvor meget plads det krævede at nedskrive de
tal, som skulle sorteres.
159

12.3 Forbedring
Nøglen til bedre sorteringsmetoder er princippet “del og hersk” fra afsnit 11.7.
Som opsummeret i figur 12.1 kan man sige, at b˚ade indsættelsessortering og udtagelsessortering
først opdelte den givne liste, derefter kaldte metoden rekursivt og til sidst bearbejdede
resultatet med en samlings-operation. Begge disse metoder h˚andterede et element
ad gangen: I indsættelsessortering var opdelingsoperationen den simplest mulige, idet listen
blot blev delt i hoved og hale; til gengæld krævede samlingsoperationen en korrekt indsættelse.
For udtagelsessortering var det samlingen, som var simpel; til gengæld skulle opdeling
finde det mindste element.
Et element udskilles:
indssort
OPDEL
hd tl
indssort
❘ ✠
indsæt
SAML
udtsort
OPDEL
min rest
udtsort
❘ ✠
::
SAML
indsættelsessortering udtagelsessortering
Tvedeling:
fletsort
OPDEL
venstre højre
fletsort fletsort
❘ ✠
flet
SAML
12.4 Flettesortering
kviksort
OPDEL
sm˚a store
kviksort kviksort
❘ ✠
@
SAML
flettesortering kviksortering
Figur 12.1: Fire sorteringsmetoder
I stedet for som i det rekursive kald af indsættelsessortering blot at sortere resten af listen
p˚anær et enkelt element er ideen i flettesortering (eng.:mergesort) at opdele den forelagte
160

liste i to s˚a vidt muligt lige lange dele og sortere hver af dem. For at f˚a dannet en korrekt
ordnet liste som resultat er det nødvendigt at sammenflette (eng.:merge) de to sorterede
dele.
Her er en hjælpefunktion til sammenfletning af to ordnede lister af reelle værdier:
fun merge ([],yr) = yr
| merge (xr,[]) = xr
| merge (xxr as (x : real) :: xr,yyr as y :: yr)
= if x

12.5 Kviksortering
I flettesortering var opdelingsoperationen gjort simpel, men som vist i figur 12.1 kunne man
ogs˚a forestille sig samle-operationen simpel. Hvis samling blot skal g˚a ud p˚a at hægte to
lister sammen, m˚a opdeling skille listen i to dele, hvor ethvert element i den forreste del er
mindre end ethvert element i den bageste.
En værdi, man kan bruge til at skille med, kaldes en pivot (svingtap, omdrejningspunkt).
Her er en hjælpefunktion, som for pivot p og oprindelig liste xr danner dellisterne best˚aende
af henholdsvis elementerne ≤ p og elementerne > p fra den oprindelige liste xr:
fun partition ( ,[]) = ([],[])
| partition (pivot : real,x :: xr)
= let val (xv,xh) = partition (pivot,xr)
in if x

12.6 Effektiv sortering
P˚a grund af de nødvendige administrative beregninger kan en af de naive metoder (indsættelses-
eller udtagelsessortering) for korte tallister være hurtigere end de her nævnte metoder
(flette- og kviksortering). I praksis kan det mest effektive derfor være hybride metoder, der
kun bruger flette- eller kviksortering, indtil dellisterne er blevet passende korte, hvorefter
der skiftes over til en naiv sorteringsmetode.
Vi har her blot brugt sorteringsproblemet som udgangspunkt til illustration af algoritmekonstruktion
og -analyse, men den faglige litteratur om sortering er særdeles omfattende. Der
er andre effektive algoritmer end de her nævnte (for eksempel hobsortering (eng.:heapsort)),
og hvis de værdier, som skal sorteres, varierer inden for et begrænset omr˚ade, er der helt
andre metoder at tage i brug.
12.7 Tilfældige tal
Efter de forudg˚aende præsentationer f˚ar man lyst til at teste programmerne p˚a et passende
stort datamateriale, men hvordan skaffer man sig det?
Det ville være rart som udgangspunkt at kunne danne en liste p˚a for eksempel 10000
eller 100000 tilfældige tal. Beregning og tilfældighed er imidlertid modsatte størrelser; ingeniørerne
har netop bestræbt sig p˚a, at intet i computeren skal fungere tilfældigt! Undertiden
klarer man sig ved at bruge det ur, som er indbygget i de fleste computere. Klokkeslættet
i milli- eller mikrosekunder vil have en passende tilfældig værdi.
12.7.1 Pseudo-tilfældige tal
En anden m˚ade at illudere tilfældighed p˚a er det trick, der kaldes pseudo-tilfældige tal, og
som g˚ar ud p˚a at danne en talrække, der “ser tilfældig ud” uden reelt at være det. Da de
“tilfældige” tal kommer i en ganske bestemt p˚a forh˚and fastlagt rækkefølge, opn˚as samtidig
det paradoksale, at eksperimenter, der beror p˚a tilfældige tal, kan gentages, hvilket kan være
en stor fordel ved fejlfinding.
Lineær kongruens er en hyppigt benyttet metode, der fastlægges af tre værdier: multiplikatoren
a, konstanten c og modulus m. Ud fra et kim (eng.:seed) r0 dannes da talrækken
r0, r1, r2, . . . ved hjælp af formlen
rn+1 = (a · rn + c) mod m (12.2)
Ikke alle værdier af a, c, m og r0 giver naturligvis tilfældige tal (tænk p˚a konsekvensen
af a = 0 eller a = 1), og der bliver heller ikke uendeligt mange forskellige tal, for alle tallene
vil ligge mellem 0 og m − 1, men for passende valg af a, c og m ser tallene tilfældige ud.
En mulighed er a = 16807, c = 0 og m = 2147483647 = 2 31 − 1. Netop disse værdier
benyttes i biblioteksmodulet Random, og ved at bruge dette færdigprogrammerede modul
kan man alts˚a selv slippe for at administrere (12.2). (Da m overstiger det største heltal
2 30 − 1 = 1073741823 i MosML, ville programmeringen ikke være s˚a ligetil.)
Efter load "Random" vil en ny type være til r˚adighed, typen Random.generator af
“tilfældigtalsgeneratorer”. At frembringe tilfældige tal er herefter en to-trins-proces: først
163

skaffer man sig en tilfældigtalsgenerator, og derefter beder man den om de tilfældige tal.
Tabel 12.1 viser de værdier, som er til r˚adighed i Random.
navn type virkning
newgenseed : real -> generator en ny tilfældigtalsgenerator med det givne
kim
newgen : unit -> generator en ny tilfældigtalsgenerator med kim fra systemuret
random : generator -> real et tilfældigt tal i intervallet mellem 0.0
randomlist : int * generator
-> real list
range : int * int
-> generator -> int
rangelist : int * int
-> int * generator
-> int list
(medregnet) og 1.0 (ikke medregnet)
en liste af n (værdien af førsteparameteren)
tilfældige tal i intervallet mellem 0.0 (med-
regnet) og 1.0 (ikke medregnet)
range (fra,til) gen giver et tilfældigt heltal
i intervallet mellem fra (medregnet) og
til (ikke medregnet)
range (fra,til) (n, gen) giver en liste af
n tilfældige heltal i intervallet mellem fra
(medregnet) og til (ikke medregnet)
Tabel 12.1: De seks værdier i biblioteksmodulet Random. Husk at bruge lange navne
(Random.generator, Random.newgen, osv.)
Som man kan se, er der to funktioner til fremskaffelse af tilfældigtalsgeneratorer: en, hvor
man selv angiver et kim, og en, hvor systemet danner det. Derudover er der funktioner til
frembringelse af et enkelt og af en liste af reelle tal (i intervallet [0|1)) og til frembringelse
af et enkelt og af en liste af hele tal (i et ønsket interval).
Vi slutter af med at m˚ale kørtiden for flette- og kviksortering af et tilfældigt testmateriale:
load "Random";
val it = () : unit
val talliste = Random.randomlist (10000,Random.newgen ());
val talliste =
[0.505257184387, 0.546112051954, 0.957907188198, 0.961680127756,
. . .
load "Mosml";
val it = () : unit
Mosml.time mergesort talliste;
User: 1.648 System: 3.265 GC: 0.889 Real: 5.817
val it =
[7.53141939991E~5, 0.000278659630697, 0.000357734970915, 0.000388164539071,
. . .
Mosml.time quicksort talliste;
User: 1.485 System: 0.297 GC: 1.492 Real: 3.283
val it =
[7.53141939991E~5, 0.000278659630697, 0.000357734970915, 0.000388164539071,
. . .
164

12.8 Sammenfatning
De naive sorteringsmetoder har udførelsestid O(n 2 ). Ingen sorteringsmetode, der baserer sig
p˚a elementsammenligninger, kan have lavere tidskompleksitet end O(n log n). Udførelsestiden
for flettesortering er faktisk O(n log n). Kviksortering, som i almindelighed vil være den
hurtigste metode, har kun en udførelsestid p˚a O(n log n) i gennemsnit, men O(n 2 ) i værste
tilfælde.
En lineær kongruensmetode til dannelse af pseudo-tilfældige tal er til r˚adighed i modulet
Random.
12.9 Opgaver
Opgave 12.1 Da køretiden for listesammenstillen (afsnit 11.6.1) ikke er konstant, men
lineært begrænset af længden af venstre operand, er forekomsten af @ i deludtrykket
“quicksort xv @ x :: quicksort xh” uheldig. Generaliser quicksort til en funktion
quickersort, hvor quickersort (xr,yr) inddrager fortsættelsen “. . . @ yr” og beregner
quicksort xr @ yr. (Denne generalisering er helt analog til dannelsen af spejlforan ud
fra spejl i afsnit 11.7.) Dan derved en mere effektiv sorteringsfunktion. Ved omskrivning til
iterativ form ([5, Chapt. 17]) kan der opn˚as yderligere forbedringer, se eventuelt [12, Sect.
3.20].
Opgave 12.2 Bevis, at der for alle hele tal n gælder n div 2 + (n + 1) div 2 = n.
Som flettesortering er fremstillet ovenfor, vil b˚ade length og splitAt i hvert rekursivt
skridt gennemløbe argumentlisten. En m˚ade, hvorp˚a man kan integrere disse administrative
operationer i selve sorteringen (og helt spare splitAt) er at definere en hjælpefunktion
sort, s˚adan at sort (n,xr) = (yr,zr), hvor yr er en sorteret liste med de n forreste
elementer fra xr, og zr er de øvrige elementer fra xr. Basistilfældene er n = 0 og n = 1,
og for n ≥ 2 udnyttes identiteten bevist i begyndelsen af opgaven. Det ønskede resultat
f˚as som førstekomponenten af parret sort (length xr,xr) (hvis andenkomponent vil være
den tomme liste). Indtast programmet:
local fun sort (0,xr) = ([],xr)
| sort (1,x :: xr) = ([x],xr)
| sort (n,xr)
= let val (yr1,xr1) = sort (n div 2,xr)
val (yr2,xr2) = sort ((n + 1) div 2,xr1)
in (merge (yr1,yr2),xr2) end
in fun mergesort’ xr = #1 (sort (length xr,xr)) end
og m˚al efter, at der herved dannes en effektiv sorteringsfunktion.
Opgave 12.3 Programmer en funktion find, s˚adan at find (xr,i) returnerer det i-temindste
element i listen xr. Det kan gøres (C.A.R. Hoare 1962) væsentlig hurtigere end først
at sortere listen og derefter vælge det i-te element. [Vink: brug partition.]
165

166

Litteratur
[1] Dansk Standardiseringsr˚ad: EDB-ordbog (redigeret af Bjørn Eriksen, Hans
Jørgen Helms og Mogens D. Rømer), Dansk Standard DS 2049-1970, Gjellerup
1971, ISBN 87 13 01220 7
[2] Jørgen Hilden, Gustav Leunbach, Peter Naur: Forslag til tilføjelser til Edbordbog
Dansk Standard DS 2049-1970, Københavns Universitet 1971
[3] It-Terminologi-Udvalgets ordbog, http://www.dsn.dk/it-dansk/
[4] Chr. Gram, J. Hald, H.B. Hansen, P. Naur, A. Wessel, Datamatik, Regnecentralen
og Studentlitteratur 1968–70 (11 ud af 19 planlagte hæfter)
[5] Michael Reichhardt Hansen, Hans Rischel: Introduction to Programming using
SML, Addison-Wesley 1999, ISBN 0-201-39820-6
[6] Greg Michaelson, Elementary Standard ML, UCL Press 1995, ISBN 1-85728-
398-8
[7] Robin Milner, Mads Tofte, and Robert Harper, The Definition of Standard ML,
The MIT Press 1990, ISBN 0-262-13255-9 (paperback: ISBN 0-262-63132-6)
[8] Robin Milner, Mads Tofte, Commentary on Standard ML, The MIT Press 1991,
ISBN 0-262-13271-0 (paperback: ISBN 0-262-63137-7)
[9] Robin Milner, Mads Tofte, Robert Harper, and David MacQueen, The Definition
of Standard ML (Revised), The MIT Press 1997, ISBN 0-262-63181-4
[10] Peter Naur, Concise Survey of Computer Methods, Studentlitteratur og Petrocelli/Charter
1974
[11] Peter Naur, Computing: A Human Activity, ACM Press 1992, ISBN 0-201-58069-
1.
[12] Lawrence C. Paulson, ML for the Working Programmer, second edition, Cambridge
University Press 1996, ISBN 0 521 57050 6 (paperback: ISBN 0 521 56543
X)
[13] Sergei Romanenko, Claudio Russo and Peter Sestoft, Moscow ML Owner’s Manual,
se hjemmesiden http://www.dina.kvl.dk/~sestoft/mosml.html
167

[14] Sergei Romanenko, Claudio Russo and Peter Sestoft, Moscow ML Language
Overview, se hjemmesiden http://www.dina.kvl.dk/~sestoft/mosml.html
[15] Sergei Romanenko, Claudio Russo and Peter Sestoft, Moscow ML Library Documentation,
se hjemmesiden http://www.dina.kvl.dk/~sestoft/mosml.html
[16] The Unicode Consortium, The Unicode Standard, Version 2.0, Addison-Wesley
Developers Press 1996, ISBN 0-201-48345-9 (CD-ROM indlagt)
168

Bilag A
Styretegn
Styretegnenes tilsigtede virkning er forklaret i Dansk Standard DS/ISO 646 og ISO 8859-1.
Her gives en kort oversættelse til dansk. Rækkefølgen er som i tabellerne 1.1 og 1.2.
NUL Null Udfyldning af mediet eller af tid uden betydning for informationsindholdet.
SOH Start of heading Første tegn i en meddelelses overskrift.
STX Start of text Transmissionsstyretegn, der afslutter en overskrift og g˚ar forud for en
tekst.
ETX End of text Transmissionsstyretegn, der afslutter en tekst.
EOT End of transmission Transmissionsstyretegn til angivelse af afslutningen p˚a en
eller flere tekster.
ENQ Enquiry Transmissionsstyretegn til anmodning om svar fra en fremmed modtager.
ACK Acknowledge Bekræftende transmissionsstyretegn fra modtager til afsender.
BEL Bell P˚akaldelse af opmærksomhed.
BS Backspace Opstillingstegn, der flytter positionen en tegnposition baglæns i samme
linje.
HT Horizontal tabulation Opstillingstegn, der flytter positionen til næste forudbestemte
tegnposition i samme linje.
LF Line feed Opstillingstegn, der flytter positionen til samme tegnposition i næste linje.
VT Vertical tabulation Opstillingstegn, der flytter positionen til samme tegnposition i
næste forudbestemte linje.
169

FF Form feed Opstillingstegn, der flytter positionen til samme tegnposition i en forudbestemt
linje p˚a næste blanket eller side.
CR Carriage return Opstillingstegn, der flytter positionen til første tegnposition i samme
linje.
SO Shift-out Benyttes sammen med SI til at udvide repertoiret af grafiske tegn, idet det
fungerer som l˚asende skiftetegn, der ændrer betydning for koder mellem 33 og 126 indtil
næste forekomst af SI.
SI Shift-in Benyttes sammen med SO til at udvide repertoiret af grafiske tegn, idet det
fungerer som l˚asende skiftetegn for tilbagevenden til standardbetydningen af koder mellem
33 og 126.
DLE Data link escape Transmissionsstyretegn, der giver et begrænset antal efterfølgende
tegn (som skal være grafiske eller transmissionsstyretegn) ændret betydning. Med andre
ord et parametriseret tranmissionsstyretegn, der kan give supplerende transmissionsstyring.
DC1 Device control 1 Enhedsstyretegn fortrinsvis som signal til at tænde en enhed eller
sætte den i en grundtilstand.
DC2 Device control 2 Enhedsstyretegn fortrinsvis som signal til at tænde en enhed eller
sætte den i en specialtilstand.
DC3 Device control 3 Enhedsstyretegn fortrinsvis som signal til at slukke en enhed eller
sætte den i vente-tilstand.
DC4 Device control 4 Enhedsstyretegn fortrinsvis som signal til at slukke eller afbryde
en enhed.
NAK Negative acknowledge Afvisende transmissionsstyretegn fra modtager til afsender.
SYN Synchronous idle Transmissionsstyretegn til opn˚aelse (eller bevaring) af synkron
transmission.
ETB End of transmission block Transmissionsstyretegn til afslutning af en datablok
(til brug i de tilfælde, hvor data er opdelt i blokke).
CAN Cancel Alene eller eventuelt i forbindelse med efterfølgende tegn signal til, at forudg˚aende
data har været fejlagtige.
EM End of medium Afslutning p˚a et medium rent fysisk eller p˚a den benyttede eller
ønskede del af det.
170

SUB Substitute character Erstatning for et ugyldigt eller fejlagtigt tegn.
ESC Escape Benyttes til yderligere styrefunktioner, idet det ændrer betydningen af et
begrænset antal efterfølgende koder.
FS File separator (IS4 Information separator 4) Filskilletegn.
GS Group separator (IS3 Information separator 3) Gruppeskilletegn.
RS Record separator (IS2 Information separator 2) Postskilletegn.
US Unit separator (IS1 Information separator 1) Enhedsskilletegn.
SP Space Blanktegn; opstillingstegn, der flytter positionen en tegnpositionen frem i samme
linje. (Kan ogs˚a opfattes som et grafisk tegn, der ikke skriver noget.)
DEL Delete Slettetegn; beregnet til overhulning, men kan ogs˚a anvendes til udfyldning
af mediet eller af tid uden betydning for informationsindholdet.
NBSP No-break space Blanktegn, hvor der ikke m˚a være linjeskift.
SHY Soft hyphen Bindestreg til brug i orddeling ved linjeskift. (Egentlig et grafisk tegn
og ikke et styretegn.)
171

172

Bilag B
Engelsk-dansk ordliste
Apparater og metoder inden for informationsteknik er i overvejende grad kommet til os fra
Storbritannien og USA, og hele it-omr˚adet er derfor stærkt p˚avirket af engelsk terminologi.
N˚ar engelske ord optages i dansk (som for eksempel “sweater” eller “weekend”), skal de
imidlertid følge danske udtaleregler og bøjningsmønstre, hvis det ikke skal virke kunstigt og
lyde grimt. For ukritiske sprogbrugere best˚ar desuden risikoen for den kortslutning, at en
engelsk term “oversættes” til en dansk, der lyder liges˚adan, snarere en til en, der betyder
det samme.
Eksempler p˚a “kortslutningsoversættelser”: Engelsk eventually betyder noget i retning
af “til syvende og sidst” og ikke “eventuelt”; control skal som regel oversættes til “styre”
snarere end “kontrollere”; technology betyder snarere “teknik” end “teknologi”; set skal i
matematisk sammenhæng oversættes til “mængde” og ikke til “sæt” (som hedder tuple p˚a
engelsk), og s˚a fremdeles.
I 1960’erne og 1970’erne udfoldedes store bestræbelser p˚a udvikling af en dansk edbterminologi
(se for eksempel [1] og [2]), men det var svært at holde trit med den hastige
fremkomst af nye fænomener inden for it-omr˚adet, og ordbøgerne blev ikke udbredt til de
mange selvbestaltede miljøer, som opstod uden for undervisningssektoren. Overordnet m˚a
man derfor nu nok indse, at bestræbelserne har været en fiasko. Det er for eksempel ikke
lykkedes at f˚a den langt mere mundrette og præcise betegnelse “datamat” til at erstatte
computer 1 .
Dansk Sprognævn, som blandt andet regulerer den officielle retskrivning, ser det ikke
som sin opgave at foreskrive en bestemt sprogbrug, men observerer blot sprogets faktiske
udvikling. Et underudvalgs iagttagelser kan ses p˚a netadressen [3].
P˚a kurset “Funktionsprogrammering” benyttes den engelsksprogede lærebog [5] sammen
med undervisningsmateriale og forelæsninger p˚a dansk. Form˚alet med den foreliggende ordliste
er at fastlægge en fælles dansk terminologi blandt kursets lærere og instruktorer, ligesom
de studerende forventes at bruge denne terminologi i deres opgavebesvarelser.
Nedenfor følger to ordlister, som dels er ordnet efter ordenes forekomst i lærebogen, dels
alfabetisk efter den engelske term. Ordlisterne medtager stort set kun ord, der har en særlig
betydning i matematisk eller datateknisk sammenhæng; andre ord m˚a søges i en almindelig
1 En række danske it-kapaciteter betingede deres medvirken til udarbejdelse af “Den store danske Encyklopædi”
af, at hovedopslagsordet skulle være “datamaskine” eller “datamat”, men redaktøren foretrak
“computer”.
173

engelsk-dansk ordbog.
B.1 Ordliste for de enkelte afsnit i lærebogen
Ordlisten dækker kun kapitel 1–8, hvori størsteparten af de faglige termer forekommer.
Indgangene har formen p: engelsk term = oversættelse(r), hvor p er sidetallet i [5, første
udgave, første trykning]. Almindeligvis anføres kun første forekomst af hver term i en given
betydning.
Hvor der kan være tvivl om ordklassen, bruges forkortelserne vb. for verbum (udsagnsord),
sb. for substantiv (navneord) og adj. for adjektiv (tillægsord).
B.1.1 Chapter 1: Getting started
1: program (vb.) = programmere, 1: program (sb.) = program, 1: programming language
= programmeringssprog, 1: value = værdi, 1: expression = udtryk, 1: declaration =
erklæring, 1: recursive = rekursiv, 1: type = type, 1: bind (vb.) = binde, 1: environment
= omgivelser, 1: evaluation = evaluering, udregning, 1: implementation = implementering,
2: execute = udføre, 2: compilation = oversættelse, 2: tuple = sæt, tupel, 2: conversion =
omsætning, 2: input (sb.) = ind(gangs)data, 2: output (sb.) = ud(gangs)data.
Values, types, identifiers and declarations
2: identifier = identifikator, navn, 2: interface = grænseflade, 2: arithmetic (adj.) = aritmetisk,
regne-, 2: arithmetic expression = regneudtryk, aritmetisk udtryk, 2: key = tast,
2: the return key = linjeskiftstasten, 2: character = tegn, 2: string = tekst, 2: heading
string = indledende tekst, 2: prompt (sb.) = prompt, klarsymbol, rykker, 2: prompt (vb.)
= prompte, tilskynde, 3: integer (sb.) = heltal, 3: integer (adj.) = heltallig, heltals-, 3: set
(sb.) = mængde, 3: truth value = sandhedsværdi.
Simple function declarations
4: subset = delmængde, 4: argument = argument, 4: argument pattern = argumentmønster,
4: formal parameter = formel parameter, 4: apply to = anvende p˚a, kalde med.
Comments
4: comment (sb.) = kommentar.
Recursion
5: factorial function = fakultetsfunktion, 6: clause = klausul, erklæringstilfælde, 6: substitute
(vb.) = substituere, indsætte, 7: base case = basistilfælde, grundtilfælde, 7: match
(vb.) = matche, 7: skip (vb.) = skippe, overspringe, 8: memory(=storage) = lager, 9: italic
(font) = kursiv.
174

The power function
10: power function = potensopløftning.
About types and type checking
11: infer = aflede, inferere, 11: error message = fejlmelding, fejlmeddelelse.
Bindings and environments
12: an environment = omgivelser.
Exercises
13: Fibonacci number = Fibonaccital.
B.1.2 Chapter 2: Basic values and operators
15: number (sb.) = tal, antal, 15: character = tegn, 15: string = tekst, 15: truth value =
sandhedsværdi.
Integers and reals
16: computer = datamat, datamaskine, computer, 16: instruction = ordre, 16: machine
instruction = maskinordre, 16: prefix (vb.) = foranstille, 16: monadic = monadisk, unær,
16: dyadic = dyadisk, binær.
Expressions, precedence, association
17: infix (adj.) = infiks-, mellemstillet, 17: infix notation = infiksnotation, mellemstillet
notation, 17: precedence = prioritet, 17: (operator) precedence = operatorprioritet, 17:
(operator) association = forbindelse, associeringsretning, 18: associate to the left/the right
= associere fra venstre/højre.
Euclid’s algorithm
18: greatest common divisor = største fælles divisor, største fælles m˚al.
Evaluations with environments
21: subexpression = deludtryk.
Characters and strings
22: special character = specialtegn, 22: punctuation (sb.) = tegnsætning, 22: punctuation
(adj.) = skille-, tegnsætnings-, 22: control (vb.) = styre, 22: control (adj.) = styre-, 22:
encode = indkode, kode, 22: quote (sb.) = anførelsestegn, 22: space character = blanktegn,
175

22: space = mellemrum, 22: new line (character) = linjeskift(stegn), 22: backslash (character)
= spejlvendt skr˚astreg, omvendt skr˚astreg, 22: escape sequence = udskiftningssekvens,
udskiftningsfølge, 24: lexicographical = leksikografisk, 24: conversion = omsætning.
Truth values
25: predicate = prædikat, 25: negation = benægtelse, negering, 25: propositional logic =
udsagnslogik, udsagnskalkule, 25: lower case letter = lille bogstav.
Overloaded operators
27: overload = overlæsse, 27: default (vb.) = falde tilbage.
Type inference
27: type inference = typeafledning, typeinferens.
Exercises
28: binomial coefficient = binomialkoefficient, 30: prime number = primtal.
B.1.3 Chapter 3: Tuples and records
31: tuple = sæt, tupel, 31: record (sb.) = post.
Tuples
34: selector = selektor, projektion.
Tuple patterns
34: pattern matching = mønstertilpasning, 35: wild card (sb.) = joker, 35: wild card (adj.)
= joker-, 35: wild card pattern = jokermønster.
Infix functions on pairs
35: infix status = infiksstatus, mellemstillingsstatus, 35: directive = direktiv, 36: scope =
virkefelt, 36: Cartesian = kartesisk.
Records
39: record (sb.) = post, 39: label (sb.) = etiket(te), feltnavn, 39: field = felt.
Record patterns
41: wild card mark = jokermærke.
176

Type declarations
42: quadratic equation = andengradsligning, 43: exception = undtagelse, 43: raise an
exception = kaste en undtagelse, hejse en undtagelse, 44: equality type = lighedstype.
Exercises
47: time of day = klokkeslæt, 48: inverse wrt 2 addition = modsatte, additivt inverse,
48: inverse wrt 2 multiplication = reciprokke, multiplikativt inverse, 48: mirror (vb.) =
spejlvende, spejle.
B.1.4 Chapter 4: Problem solving I
Solution 1
52: irreducible fraction = uforkortelig brøk, 52: cancel = bortforkorte.
B.1.5 Chapter 5: Lists
60: sequence = sekvens, følge, 60: polymorphic = polymorf, 60: equality type = lighedstype.
Building lists
61: type constructor = typekonstruktør, 62: postfix (adj.) = postfiks-, efterstillet, 62: postfix
notation = postfiksnotation, efterstillet notation, 62: subtree = deltræ, undertræ.
Append and reverse; polymorphic types
69: append (vb.) = tilføje, 69: called ‘append’ = benævnt ‘tilføj’, 70: reverse (vb.) =
spejlvende, 70: called ‘reverse’ = benævnt ‘spejlvend’, 70: polymorphic = polymorf, 70:
monomorphic = monomorf, 70: polymorphism = polymorfi, 71: efficient = effektiv.
Membership; equality types
76: equality type variable = lighedstypevariabel, variabel af lighedstype.
Exercises
80: prime number = primtal, 80: palindrome = palindrom.
B.1.6 Chapter 6: Problem solving II
B.1.7 Chapter 7: Tagged values and partial functions
90: tag (vb.) = afmærke, 90: tag (sb.) = mærke, 90: square = kvadrat, 90: triangle =
trekant.
2 with respect to
177

Datatype declarations
91: value constructor = værdikonstruktør.
The case-expression
93: match (sb.) = tilpasning, match, 94: nest (vb.) = indlejre.
Enumeration types
94: enumerate = opregne, 94: enumeration type = opregningstype.
Partial functions: the option datatype
95: proper subset = ægte delmængde.
Exception handling
98: exception constructor = undtagelseskonstruktør, 99: catch an exception = gribe en undtagelse,
fange en undtagelse, 99: exception handler = undtagelsesvogter 3 , handle-udtryk,
99: match (sb.) = tilpasning, match.
The Eight Queens problem
100: backtracking = blindgydesøgning, 100: backtrack (vb.) = søge (samme vej) tilbage.
Exercises
102: mark = karakter, 102: pass (vb.) = best˚a, 102: day care centre = daginstitution,
102: day nursery = vuggestue, 102: nursery school = børnehave, 102: recreation centre =
fritidshjem, 103: union = foreningsmængde, 103: intersection = fællesmængde.
B.1.8 Chapter 8: Finite trees
104: Chinese boxes = kinesiske æsker, 104: ancestor = forfader, ane, 104: node = knude,
104: circuit = kredsløb.
Chinese boxes
110: layered pattern = mønstersynonym.
Trees of ancestors; traversal of a tree
118: traverse = gennemløbe, 118: pre-order traversal = præordensgennemløb, gennemløb i
præorden.
3 ikke alment accepteret fordanskningsforslag
178

Mutual recursion
120: mutual = gensidig.
Parameterized datatypes
123: instance = udgave, specialtilfælde, instans, 123: leaf = blad, 123: node = knude.
Exercises
132: propositional logic = udsagnslogik, udsagnskalkule, 133: calculator = regnemaskine,
133: instruction = ordre.
B.2 Engelsk-dansk ordliste
Listen omfatter fagtermerne fra de første otte kapitler i [5] for s˚a vidt ang˚ar ordet i den
angivne kontekst (de anførte sidenumre gælder første udgave, første trykning). Listen
kan p˚a ingen m˚ade erstatte en ordbog: Alternative betydninger angives ikke, og ordlisten
medtager overvejende ord af særlig datateknisk eller matematisk interesse.
ancestor 104 forfader, ane
append (vb.) 69 tilføje
called ‘append’ 69 benævnt ‘tilføj’
apply to 4 anvende p˚a, kalde med
argument 4 argument
argument pattern 4 argumentmønster
arithmetic (adj.) 2 aritmetisk, regnearithmetic
expression 2 regneudtryk, aritmetisk udtryk
associate to the left/the right 18 associere fra venstre/højre
(operator) association 17 forbindelse, associeringsretning
backslash (character) 22 spejlvendt skr˚astreg, omvendt skr˚astreg
backtrack (vb.) 100 søge (samme vej) tilbage
backtracking 100 blindgydesøgning
base case 7 basistilfælde, grundtilfælde
bind (vb.) 1 binde
binomial coefficient 28 binomialkoefficient
calculator 133 regnemaskine
cancel 52 bortforkorte
Cartesian 36 kartesisk
catch an exception 99 gribe en undtagelse, fange en undtagelse
character 2, 15 tegn
Chinese boxes 104 kinesiske æsker
circuit 104 kredsløb
clause 6 klausul, erklæringstilfælde
179

computer 16 datamat, datamaskine, computer
comment (sb.) 4 kommentar
compilation 2 oversættelse
control (vb.) 22 styre
control (adj.) 22 styreconversion
2, 24 omsætning
day care centre 102 daginstitution
day nursery 102 vuggestue
declaration 1 erklæring
default (vb.) 27 falde tilbage
directive 35 direktiv
dyadic 16 dyadisk, binær
efficient 71 effektiv
encode 22 indkode, kode
enumerate 94 opregne
enumeration type 94 opregningstype
environment 1 omgivelser
an environment 12 omgivelser
equality type 44, 60 lighedstype
equality type variable 76 lighedstypevariabel, variabel af lighedstype
error message 11 fejlmelding, fejlmeddelelse
escape sequence 22 udskiftningssekvens, udskiftningsfølge
evaluation 1 evaluering, udregning
exception 43 undtagelse
exception constructor 98 undtagelseskonstruktør
exception handler 99 undtagelsesvogter, handle-udtryk
execute 2 udføre
expression 1 udtryk
factorial function 5 fakultetsfunktion
Fibonacci number 13 Fibonaccital
field 39 felt
formal parameter 4 formel parameter
greatest common divisor 18 største fælles divisor, største fælles m˚al
heading string 2 indledende tekst
identifier 2 identifikator, navn
implementation 1 implementering
infer 11 aflede, inferere
infix (adj.) 17 infiks-, mellemstillet
infix notation 17 infiksnotation, mellemstillet notation
infix status 35 infiksstatus, mellemstillingsstatus
input (sb.) 2 ind(gangs)data
instance 123 udgave, specialtilfælde, instans
instruction 16, 133 ordre
integer (sb.) 3 heltal
integer (adj.) 3 heltallig, heltals-
180

interface 2 grænseflade
intersection 103 fællesmængde
inverse wrt addition 48 modsatte, additivt inverse
inverse wrt multiplication 48 reciprokke, multiplikativt inverse
irreducible fraction 52 uforkortelig brøk
italic (font) 9 kursiv
key 2 tast
label (sb.) 39 etiket(te), feltnavn
leaf 123 blad
lexicographical 24 leksikografisk
lower case letter 25 lille bogstav
machine instruction 16 maskinordre
mark 102 karakter
match (vb.) 7 matche
match (sb.) 93, 99 tilpasning, match
memory(=storage) 8 lager
mirror (vb.) 48 spejlvende, spejle
monadic 16 monadisk, unær
monomorphic 70 monomorf
mutual 120 gensidig
negation 25 benægtelse, negering
nest (vb.) 94 indlejre
new line (character) 22 linjeskift(stegn)
node 104, 123 knude
number (sb.) 15 tal, antal
nursery school 102 børnehave
output (sb.) 2 ud(gangs)data
overload 27 overlæsse
palindrome 80 palindrom
pass (vb.) 102 best˚a
pattern matching 34 mønstertilpasning
layered pattern 110 mønstersynonym
polymorphic 60, 70 polymorf
polymorphism 70 polymorfi
postfix (adj.) 62 postfiks-, efterstillet
postfix notation 62 postfiksnotation, efterstillet notation
power function 10 potensopløftning
precedence 17 prioritet
(operator) precedence 17 operatorprioritet
predicate 25 prædikat
prefix (vb.) 16 foranstille
pre-order traversal 118 præordensgennemløb, gennemløb i præorden
prime number 30, 80 primtal
program (vb.) 1 programmere
program (sb.) 1 program
programming language 1 programmeringssprog
181

prompt (sb.) 2 prompt, klarsymbol, rykker
prompt (vb.) 2 prompte, tilskynde
proper subset 95 ægte delmængde
propositional logic 25, 132 udsagnslogik, udsagnskalkule
punctuation (sb.) 22 tegnsætning
punctuation (adj.) 22 skille-, tegnsætningsquadratic
equation 42 andengradsligning
quote (sb.) 22 anførelsestegn
raise an exception 43 kaste en undtagelse, hejse en undtagelse
record (sb.) 31, 39 post
recreation centre 102 fritidshjem
recursive 1 rekursiv
the return key 2 linjeskiftstasten
reverse (vb.) 70 spejlvende
called ‘reverse’ 70 benævnt ‘spejlvend’
scope 36 virkefelt
selector 34 selektor, projektion
sequence 60 sekvens, følge
set (sb.) 3 mængde
skip (vb.) 7 skippe, overspringe
space 22 mellemrum
space character 22 blanktegn
special character 22 specialtegn
square 90 kvadrat
string 2, 15 tekst
subexpression 21 deludtryk
subset 4 delmængde
substitute (vb.) 6 substituere, indsætte
subtree 62 deltræ, undertræ
tag (vb.) 90 afmærke
tag (sb.) 90 mærke
time of day 47 klokkeslæt
traverse 118 gennemløbe
triangle 90 trekant
truth value 3, 15 sandhedsværdi
tuple 2, 31 sæt, tupel
type 1 type
type constructor 61 typekonstruktør
type inference 27 typeafledning, typeinferens
union 103 foreningsmængde
value 1 værdi
value constructor 91 værdikonstruktør
wild card (sb.) 35 joker
wild card (adj.) 35 jokerwild
card pattern 35 jokermønster
wild card mark 41 jokermærke
182

Bilag C
Indeks
absolut værdi 27 DS 2089 19
afprøvning 82 efterladende 51
afviklingsprogram 14 Euklid 48
alfabet 11,16 evaluering 15
analog repræsentation 11 fakultetsfunktionen 71,77,85
analoge data 11 flettesortering 160
analogregnemaskine 11 fortolke 14
applikativ programmering 13 funktionsorienteret programmering 13
applikativt programmeringssprog 15 funktionsorienteret programmeringssprog 15
ASCII 17 Gauß, Karl Friedrich 140
associering 29 grafem 16
Babbage, Charles (1792–1871) 13 grundsymbol 55
binære talsystem 11 Hanois t˚arn 85
bit 11 Hoare, Charles Antony Richard 162
blanktegn 17 højere programmeringssprog 14
blindgydesøgning 140 imperativ programmering 13
boblesortering 113 imperativt programmeringssprog 15
Boole,George (1815–1864) 28 implementere 14
bund 72 inddata 10
byte 19 indgangsdata 10
Church, Alonzo (1903–95) 13 indsættelsessortering 113
Curry, Haskell Brooks (1900–82) 93 ISO 646 17,169
data 9 ISO 8859 19,169
databehandling 10 ivrig 51
datamaskine 14 klar-symbol 25
datamat 14 kode 16
datamatik 14 kombination 89
dataproces 10 kommentar 81
deklarativ programmering 15 kontekst 14
differensrække 154 kviksortering 162
digital repræsentation 11 lambdaudtryk 96
digitale data 11 lineær kongruens 163
183

logikprogrammering 15 skiftenøgle 18
logisk værdi 28 skiftetegn 18
Lovelace, Augusta Ada (1815–1851) 13 skrifttegn 16
maskinsprog 14 sortering 111
McCarthy, John 13 Stirlings formel 159
ML 25 striks 51
monadisk minus 27 syntaksfejl 82
monadisk plus 26 sæt 33
von Neumann, John (1903–1957) 14 tal 11
numerisk værdi 27 talord 11
objektorienteret programmering 15 tegn 11
ord 11 tegnsæt 16
oversætte 14 tekstbehandlingsprogram 79
Pascal, Blaise (1623–1662) 12,89 tilstandsorienteret programmering 13
permutation 71,77 tilstandsorienteret programmeringssprog 15
polymorfi 64 top-niveau-erklæring 26
position 11 totalssystemet 11
prioritet 29 typebegrænsning 54
program 12 typevariabel 55
programbevis 82 uddata 10
programmere 12,13 udgangsdata 10
programmeringsstil 80 udtagelsessortering 113
pseudo-tilfældige tal 163 uegentlig værdi 72
redigeringsprogram 79 uendelig løkke 72
rekursiv 77 unit 62
reserveret ord 55 universel 12,25
rystesortering 114 variabelbaseret programmering 13
sandhedsværdi 27 vægt 16
Schönfinkel, Moses 93 værdiorienteret programmering 13
semantisk fejl 82 værdiorienteret programmeringssprog 15
simulering 10 værdipolymorfi 69
184