Fortsetter med ML: Repetisjon av lister Typer Unntak Moduler og abstrakte datatyper Introduksjon til høyere-ordens funksjoner

Transkript

1 Dagens tema Fortsetter med ML: Repetisjon av lister Typer Unntak Moduler og abstrakte datatyper Introduksjon til høyere-ordens funksjoner ML avsluttes etter planen neste uke. Ark 1 av 21 Forelesning

2 Lister Lister er predefinert i ML: [1,2,3] listen av 1, 2 og 3 IN 211 Programmeringsspråk [] den tomme listen (skrives også nil) [1,2]@[3,4]=[1,2,3,4] konkatenering 0::[1,2] = [0,1,2] innsetting først ["Ole", "Petter"] liste av strenger [[1,2],[2,3,4]] liste av lister Typisk mønster for funksjoner over lister: fun f (l: <type> list) = caselof[]=>... x::r =>... f(r)...; - fun finn(x:int,l:int list) = case l of [] => false y :: r => x = y orelse finn(x,r); val finn = fn : int * int list -> bool - finn(4, [2,4,6]); val it = true : bool - fun fjern(x:int,l:int list) = caselof[]=>[] y::r =>ifx=ythenfjern(x,r) else y :: fjern(x,r); val fjern = fn : int * int list -> int list - fjern(1,[1,3,4,1,3]); val it = [3,4,3] : int list Forelesning Ark 2 av 21

3 Smart type-analyse Følgende deklarasjoner forstås likt av ML: fun dobbel(x:int):int = x+x; fun dobbel(x:int) = x+x; fun dobbel(x):int = x+x; fun dobbel(x) = x+x; I alle tilfellene kvitterer ML med val dobbel = fn : int -> int ML kan dedusere typen av funksjonsverdien og/eller (utypede) parametre, så sant en éntydig løsning finnes. -funid(x)=x; valid=fn: a-> a Her står a for en vilkårlig type. Dvs. funksjonen er polymorf, den kan brukes for alle typer. Forelesning Ark 3 av 21

4 Type-deklarasjoner Deklarasjon av en type med navn T uten parametre: type/datatype T = <type-uttrykk>; type tall = int; type talliste = tall list; Deklarasjon av en type med navn T og med parametre: type/datatype <type-parametre> T = <type-uttrykk>; type mintype par = mintype * mintype; type intpar = int par; type boolpar = bool par; Merk: Navnet på en type-parameter må starte med en apostrof. Forelesning Ark 4 av 21

5 Produkt-typer med navn-gitte komponenter - type Person = {navn:string, alder:int}; type Person = {alder:int, navn:string} - val Ole = {navn="ole", alder= 25}; val Ole = {alder=25,navn="ole"} : {alder:int, navn:string} -#navnole; val it = "Ole" : string - #alder Ole; val it = 25 : int med navn-løse komponenter - type Person = string * int; type Person = string * int - val Ole = ("Ole", 25); val Ole = ("Ole", 25) : string * int -#1Ole; val it = "Ole" : string -#2Ole; val it = 25 : int; Tomt produkt unit minste produkt: type unit = {} Denne typen er predefinert, og har bare én mulig verdi, nemlig () Kan også skrive denne verdien som {} Forelesning Ark 5 av 21

6 Union-typer i ML: datatyper - datatype PData = navn of string alder of int; datatype PData = alder of int navn of string - val n = navn("ole"); val n = navn "Ole" : PData - val a = alder(25); val a = alder 25 : PData Både n og a er lovlige, men ulike, verdier av typen PData. Ved case-uttrykk kan man analysere PData-verdier: case x of navn(s) =>...s... alder(i) =>...i... der x er et uttrykk av type PData. - fun inc_alder(x:pdata) = case x of navn(s) => x alder(i) => alder(i+1); valinc_alder=fn:pdata->pdata - inc_alder(n); val it = navn "Ole" : PData - inc_alder(a); val it = alder 26 : PData Forelesning Ark 6 av 21

7 Konstanter som alternativer Et alternativ kan også være en konstant, for eksempel: datatype Dag = mandag tirsdag onsdag torsdag fredag lordag sondag; fun ukedag(d:dag):bool= casedoflordag=>false sondag => false _ =>true; Eksempel: - datatype Data = tall of int no; datatype Data = no tall of int - tall(5); val it = tall 5 : Data -no; val it = no : Data - fun dobbel(x:data):data = case x of tall(i) => tall(i+i) no =>no; valdobbel=fn:data->data - dobbel(tall(5)); val it = tall 10 : Data Forelesning Ark 7 av 21

8 Rekursive Typer datatype T == T... Eksempel: liste av tall datatype TallListe = tom ikketom of int * TallListe; ikketom(1,ikketom(2,ikketom(3,tom))) Uendelig datatype i ML - datatype Dum = dum of int*dum; - fun makedum(x:int) = dum(x,makedum(x)); val makedum = fn : int -> Dum makedum(1); => dum(1, makedum(1)) => dum(1, dum(1, makedum(1))) =>... Terminerer ikke! En rekursiv datatype må ha minst ett ikke-rekursivt alternativ! Forelesning Ark 8 av 21

9 Mer om lister Lister av vilkårlig type elem: datatype elem Liste = tom ikketom of elem * elem Liste; MLs egen liste-definisjon: datatype elem list = nil :: of elem * elem list; Merk at :: er en infiks operator, mens ikketom er prefiks. Funksjoner over lister repetert - fun finn(x,l) = case l of [] => false y :: r => x = y orelse finn(x,r); val finn = fn : a * a list -> bool - finn(4, [2,4,6]); val it = true : bool - finn("arne", ["Ole","Petter","Arne"]); val it = true : bool - fun fjern(x,l) = case l of [] => [] y :: r => if x = y then fjern(x,r) else y :: fjern(x,r); val fjern = fn : a * a list -> a list - fjern(1,[1,3,4,1,3]); val it = [3,4,3] : int list Forelesning Ark 9 av 21

10 Unntak exception deklarerer et unntak exception feil; raise for å gi unntak fun f(..)=... raise feil...; handle for å fange opp unntak (...f(..)...) handle feil => "Noe gikk galt!" - exception finnesikke; exception finnesikke - fun forste(l) = case l of nil => raise finnesikke x::r => x; val forste = fn : a list -> a - forste([1,2,3]); valit=1:int - forste([]); [...] uncaught exception finnesikke [...] - forste([]) handle finnesikke => 0; valit=0:int - forste([1,2,3]) handle finnesikke => 0; valit=1:int Forelesning Ark 10 av 21

11 Stakk datatype Stakk = empty push of int*stakk; Vi lar top og pop være udefinert for tom stakk (empty). datatype Stakk = empty push of int*stakk; fun nonempty(s:stakk) = case s of empty => false _=>true; fun pop (s:stakk) = case s of push(_,s) => s; fun top (s:stakk) = case s of push(x,_) => x; Appliserer vi top eller pop med empty får vi en feilmelding "pattern matching failed". Bedre å bruke unntak! Forelesning Ark 11 av 21

12 Stakk med unntak datatype Stakk = empty push of int*stakk; Merk: øverste stakk-element ligger først i listen. Vi kan nå lage en stakk, for eksempel slik: push(x1, push(x2,...push(xn, empty)...)) fun nonempty (s:stakk) = case s of empty => false _ =>true; (* deklarerer exception TomStakk *) exception TomStakk; fun pop (s:stakk) = case s of empty => raise TomStakk (* feil *) push(_,s) => s; fun top (s:stakk) = case s of empty => raise TomStakk (* feil *) push(x,_) => x; Forelesning Ark 12 av 21

13 Høyere-ordens funksjoner Høyere-ordens funksjoner er basert på at funksjoner er data på samme måte som tall og tekst er det. Det betyr at de kan sendes som parametre, mottas som returverdier og bindes til variable. Dette kaller vi funksjoner som fullverdige borgere. En høyere-ordens funksjon er altså en funksjon som opererer på andre funksjoner. Funksjoner som parametre I det følgende skal vi se på tre vanlige høyre-ordens funksjoner som alle tar en funksjon som parameter. Forelesning Ark 13 av 21

14 Funksjonen oppdater Verdien til oppdater( f, l) skal være listen vi får ved å anvende f på hvert element i listen l - fun oppdater(f, l) = caselof[]=>[] x :: r => f(x) :: oppdater(f, r); val oppdater = fn : ( a -> b) * a list -> b list - fun dobbel(x) = x + x; val dobbel = fn : int -> int - oppdater(dobbel, [1, 2, 3]); val it = [2,4,6] : int list Forelesning Ark 14 av 21

15 Funksjonen plukk Verdien til plukk( f, l) skal være listen av elementer x fra l der f (x) er true. - fun plukk(f, l) = caselof[]=>[] x :: r => if f(x) then x :: plukk(f, r) else plukk(f, r); valplukk=fn:( a->bool)* alist-> alist - fun negativ(x) = x < 0; val negativ = fn : int -> bool - plukk(negativ, [1, ~1, 2, ~4, ~5]); val it = [~1,~4,~5] : int list Forelesning Ark 15 av 21

16 Funksjonen gjenta gjenta(f,d,l) gjentar 2-arguments funksjonen f over alle elementene i listen l (fra høyre mot venstre). d angir defaultverdi for tom liste. - fun gjenta(f, d, l) = caselof[]=>d x :: l => f(x, gjenta(f, d, l )); valgjenta=fn:( a* b-> b)* b* alist-> b - gjenta(op+, 0, [1, 3, 5]); valit=9:int Forelesning Ark 16 av 21

17 Abstrakte datatyper i ML I ML kan man lage abstrakte datatyper ved først å definere grensesnitt og så implementasjon: Grensesnitt angis ved en signatur, som inneholder deklarasjon av det som skal være synlig utad. Funksjoner og typer implementeres ikke med, men type-informasjon angis. Implementasjon angis ved en struktur, som angir hvordan deklarasjonene i det tilsvarende grensesnittet skal implementeres. (Her må man angi data-strukturer for typer og implementasjon av alle funksjoner.) Både signaturer og strukturer navngis. Man kan ha flere strukturer som implementerer samme signatur. Forelesning Ark 17 av 21

18 Stakk som abstrakt data-type signature Stakk_def = sig type elem Stakk exception TomStakk val empty: elem Stakk val nonempty: elem Stakk -> bool val push: elem * elem Stakk -> elem Stakk val pop : elem Stakk -> elem Stakk val top : elem Stakk -> elem end; Forelesning Ark 18 av 21

19 Stakk-implementasjon ved struktur structure Stakk_impl: Stakk_def = struct datatype elem Stakk = empty push of elem*( elem Stakk); exception TomStakk; fun nonempty (s) = case s of empty => false _ =>true; fun pop (s) = case s of empty => raise TomStakk push(_,s) => s; fun top (s) = case s of empty => raise TomStakk push(x,_) => x; end; Stakk_impl kan også implementere andre funksjoner, men bare de vi har i Stakk_def vil være synlige utenfra. Forelesning Ark 19 av 21

20 Eksempel på bruk - val s = Stakk_impl.empty; val s = empty : a Stakk_impl.Stakk - val s = Stakk_impl.push(1, Stakk_impl.push(2, s)); val s = push (1,push (2,empty)) : int Stakk_impl.Stakk - Stakk_impl.top(s); valit=1:int - Stakk_impl.pop(s); val it = push (2,empty) : int Stakk_impl.Stakk For å få direkte tilgang til innholdet (slippe å skrive Stakk_impl. hele tiden), kan strukturen åpnes med: open Stakk impl; Forelesning Ark 20 av 21

21 Stakk implementert ved liste structure Stakk_impl: Stakk_def = struct datatype elem Stakk = elem list; exception TomStakk; val empty = nil; fun push(x,s) = x::s; fun top(s) = case s of nil => raise TomStakk x::s => x; fun pop(s) = case s of nil => raise TomStakk x::s => s; fun nonempty(s) = case s of nil => false _ => true; end; Forelesning Ark 21 av 21