Plan. Fortsetter med ML: lister og rekursive typer/funksjoner unntak let-uttrykk moduler og abstrakte datatyper høyere-ordens funksjoner

Transkript

1 Plan Fortsetter med ML: lister og rekursive typer/funksjoner unntak let-uttrykk moduler og abstrakte datatyper høyere-ordens funksjoner Ark 1 av 19 Forelesning

2 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: datatype T =..... T.. Forelesning Ark 2 av 19

3 Lister Lister av tall: datatype TallListe = tom ikketom of int * TallListe; Lister av strenger: datatype TekstListe = tom ikketom of string *TekstListe; Dette gir problemer med overlasting av tom! 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. Kan nå snakke om alle slags lister! Bare én konstant tom! Forelesning Ark 3 av 19

4 Funksjoner over lister Typisk mønster for funksjoner over lister: fun f (l: <type> list) = case l of nil =>... x::r =>... f(r)...; Slike rekursive kall vil terminere! Eksempler fun skjotsammen(l1,l2) = case l1 of nil => l2 x::r => x::skjotsammen(r,l2); val skjotsammen = fn : a list * a list -> a list (skjotsammen er predefinert fun settinnbak(l, x) = case l of nil => [x] y::r => y::settinnbak(r,x); val settinnbak = fn : a list * a -> a list fun snu(l) = case l of nil => nil x::r => settinnbak(snu(r),x); val snu = fn : a list -> a list I siste gren kunne vi også ha skrevet: snu(r)@[x] Forelesning Ark 4 av 19

5 Unntak exception deklarerer et unntak raise for å gi unntak handle for å fange opp unntak Eksempel-skisse exception feil; fun f(..)=... raise feil...; (...f(..)...) handle feil => "Noe gikk galt et sted! " Forelesning Ark 5 av 19

6 Unntak exception finnesikke; fun forste(l) = case l of nil => raise finnesikke x::r => x; val forste = fn : a list -> a fun finn(l, i) = case l of nil => raise finnesikke x::r => if i=1 then x else finn(r, i-1); val finn = fn : a list * int -> a fun finnforste(l, x) = case l of nil => raise finnesikke y::r => if x=y then 1 else finnforste(r,x)+1; val finnforste = fn : a list * a -> int a angir at x (og elementene i l) må være av en type vi har definert likhet for (fordi vi gjør sammenligningen x=y). Forelesning Ark 6 av 19

7 Let-uttrykk Let gjør et navn tilgjengelig i en begrenset del av koden: let D in E end; hvor D er en liste av deklarasjoner og E et uttrykk (som bruker disse deklarasjonene). Eksempel: - let val x = "lang text" in x^x end; val it = "lang textlang text" : string Let-uttrykk kan spare skrivearbeid, ved at et deluttrykk skirves bare én gang, og kan gi bedre effektivitet, ved at det regnes ut bare én gang. Forelesning Ark 7 av 19

8 Eksempel med Let-uttrykk og sammensatt funksjonsverdi fun sumlengde(l) = case l of nil => (0,0) x::r => (x + #1 (sumlengde(r)), 1 + #2 (sumlengde(r))); val sumlengde = fn : int list -> int * int sumlengde([2,3,4,5,6,7,8,9,22,33,44,55,66,77,88,99,90]); val it = (618,17) : int * int (* List.tabulate(1000, fn x => x) gir oss en liste over tallene fra 0 til 999 *) sumlengde (List.tabulate(1000,fn x => x));..får ikke noe resultat.. fun sumlengde(l:int list) = case l of nil => (0,0) x::r => let val (s,l) = sumlengde(r) in (x+s,1+l) end; val sumlengde = fn : int list -> int * int sumlengde (List.tabulate(1000,fn x => x)); val it = (499500,1000) : int * int Forelesning Ark 8 av 19

9 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! (Se neste foil) Forelesning Ark 9 av 19

10 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; exception TomStakk; (* deklarerer 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 10 av 19

11 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 11 av 19

12 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; funpop(s)=casesof 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 12 av 19

13 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); val it = 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 13 av 19

14 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 14 av 19

15 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 15 av 19

16 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) = case l of nil => nil x :: l => f(x) :: oppdater(f, l ); 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 16 av 19

17 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) = case l of nil => nil x :: l => if f(x) then x :: plukk(f, l ) else plukk(f, l ); val plukk = fn : ( a -> bool) * a list -> a list - 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 17 av 19

18 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) = case l of nil => d x :: l => f(x, gjenta(f, d, l )); val gjenta = fn : ( a * b -> b) * b * a list -> b - gjenta(op+, 0, [1, 3, 5]); val it = 9 : int Forelesning Ark 18 av 19

19 Eksempler type stud = string * int; val L1=[("ole",60),("eva",62),("jens",64)]; fun ercm(s:stud):bool = (65 <= #2 s); fun tattin211((n,v):stud):stud = (n,v+3); fun or(x,y) = x orelse y; - val L2 = oppdater(tattin211, L1); val L2 = [("ole",63),("eva",65),("jens",67)] : stud list - val L3 = plukk(ercm, L2); val L3 = [("eva",65),("jens",67)] : stud list - oppdater (#1, L3); val it = ["eva","jens"] : string list - oppdater (#2, L1); val it = [60,62,64] : int list - gjenta(or, false, (oppdater(ercm, L1))); val it = false : bool - gjenta(or, false, (oppdater(ercm, L2))); val it = true : bool Forelesning Ark 19 av 19