Paradigmer i Programmering 3

Højere ordens funktionerIdag:

Højere ordens funktioner

Algebraiske datatyper

Næste gang: I/O, Filer,

interaktive programmer

Lidt om Lex og Yacc - parsergeneratorer

Flere parametre- fun add(x,y) = x+y;> val add = fn : int * int -> int- add(2,3);> val it = 5 : int- fun add x y = x+y;> val add = fn : int -> int -> int- add 1;> val it = fn : int -> int- val inc = add 1;> val inc = fn : int -> int- inc 4;> val it = 5 : int

mapAnvend funktion på hvert element i en liste:

- fun map f [] = []

| map f (x::xs) =

(f x)::(map f xs);

> val ('a, 'b) map = fn

: ('a -> 'b) -> 'a list -> 'b list

- map inc [1,2,3];

> val it = [2, 3, 4] : int list

Eksempel- fun upString x =

implode (map Char.toUpper (explode x));

> val upString = fn : string -> string

- upString "hejsahj+986543";

> val it = "HEJSAHJ+986543" : string

all, exists- fun all p [] = true

| all p (x::xs) =

(p x) andalso (all p xs);

> val 'a all = fn

: ('a -> bool) -> 'a list -> bool

- fun exists p [] = false

| exists p (x::xs) =

(p x) orelse (exists p xs);

> val 'a exists = fn

: ('a -> bool) -> 'a list -> bool

Programmering med exists- fun eq x y = x=y;

> val ''a eq = fn : ''a -> ''a -> bool

- fun member elm lst = exists (eq elm) lst;

> val ''a member = fn

: ''a -> ''a list -> bool

- member 3 [1,2,3,4];

> val it = true : bool

- member 3 [1,2,4,5];

> val it = false : bool

Foldning af liste- fun foldr f b [] = b | foldr f b (x::xs) = f(x,foldr f b xs);> val ('a, 'b) foldr = fn : ('a * 'b -> 'b) -> 'b -> 'a list -> 'b- fun app xs ys = foldr op:: ys xs;> val 'a app = fn : 'a list -> 'a list -> 'a list- app [1,2,3] [4,5,6];> val it = [1, 2, 3, 4, 5, 6] : int list- fun sum xs = foldr op+ 0 xs;> val sum = fn : int list -> int- sum [1,2,3,4];> val it = 10 : int

Anonyme funktioner: fn- fun len xs = foldr (fn (_,x) => x+1) 0 xs;> val 'a len = fn : 'a list -> int- len [1,2,3];> val it = 3 : int- len [];> val it = 0 : inteller..- fun snd (x,y) = y;> val ('a, 'b) snd = fn : 'a * 'b -> 'b- fun len xs = foldr (inc o snd) 0 xs;> val 'b len = fn : 'b list -> int- len [1,2];> val it = 2 : int

Algebraiske datatyper

I mængdelæren:• N M i SML: tupler• Nm i SML: lister• N + M i SML: datatyper

N + M er stort set N M, men man kan se om en

værdi kommer fra den ene eller anden.

Eksempel- datatype Val = Chr of char | Str of string | Int of int;> New type names: =Val datatype Val = (Val,{con Chr: char -> Val, con Int: int -> Val, con Str: string -> Val})

con Chr = fn : char -> Val con Int = fn : int -> Val con Str = fn : string -> Val- Chr #"2";> val it = Chr #"2" : Val- Int 3;> val it = Int 3 : Val-

Min liste- datatype Liste = Tom | Hoved of (int * Liste);> New type names: =Liste datatype Liste =(Liste,{con Hoved : (int * Liste) -> Liste, con Tom : Liste}) con Hoved = fn : (int * Liste) -> Liste con Tom = Tom : Liste- val x = Hoved(1,Hoved(2,Hoved(3,Tom)));> val x = Hoved(1,Hoved(2,Hoved(3,Tom))): Liste- fun len Tom = 0 | len (Hoved(x,xs)) = 1+ len xs;> val len = fn : Liste -> int- len x;> val it = 3 : int

Træer- datatype 'a trae = blad of 'a | gren of ('a trae * 'a trae );> New type names: =trae datatype 'a trae = ('a trae, {con 'a blad : 'a -> 'a trae, con 'a gren :

('a trae * 'a trae) -> 'a trae}) con 'a blad = fn : 'a -> 'a trae con 'a gren = fn : ('a trae * 'a trae) -> 'a

trae- val t = gren(gren(blad 1, blad 2), gren(blad 3, blad 4));> val t = gren(gren(blad 1, blad 2), gren(blad

3, blad 4)) : int trae

Funktion på træer- fun flad (blad(b)) = [b]

| flad (gren(t1,t2)) = (flad t1) @ (flad t2);

> val 'a flad = fn : 'a trae -> 'a list

- flad t;

> val it = [1, 2, 3, 4] : int list

Eksempel – binært søgetrædatatype 'a trae = blad | node of ('a * 'a trae * 'a trae );fun cmpr (a,b) = if a=b then EQUAL else if a<b then LESS else GREATER;fun insert cmp x blad = node(x,blad,blad) | insert cmp x (node(y,lf,rt)) = case cmp(x,y) of EQUAL => node(x,lf,rt) | LESS => node(y,insert cmp x lf,rt) | GREATER => node(y,lf,insert cmp x rt) ;

New type names: =traedatatype 'a trae =('a trae,{ con 'a blad : 'a trae, con 'a node : ('a * 'a trae * 'a trae) -> 'a trae})con 'a blad = blad : 'a traecon 'a node = fn : ('a * 'a trae * 'a trae) -> 'a traeval cmpr = fn : int * int -> orderval 'a insert = fn : ('a * 'a -> order) -> 'a -> 'a trae -> 'a trae

Eksempel – binært søgetræMoscow ML version 2.00 (June 2000)

Enter `quit();' to quit.

- val x1=blad;

> val 'a x1 = blad : 'a trae

- val x2 = insert cmpr 3 x1;

> val x2 = node(3, blad, blad) : int trae

- val x3 = insert cmpr 7 x2;

> val x3 = node(3, blad, node(7, blad, blad)) : int trae

- val x4 = insert cmpr 5 x3;

> val x4 = node(3, blad, node(7, node(5, blad, blad), blad)) : int trae

Options datatype 'a option = NONE | SOME of 'a;

Bruges når man måske ikke får en værdi

- fun last [] = NONE

| last [x] = SOME x

| last (x::xs) = last xs;

> val 'a last = fn : 'a list -> 'a option

- last [1,2,3];

> val it = SOME 3 : int option

Undtagelser- exception TomListe;

> exn TomListe = TomListe : exn

- fun last [] = raise TomListe

| last [x] = x

| last (x::xs) = last xs;

> val 'a last = fn : 'a list -> 'a

- last [];

! Uncaught exception:

! TomListe

Fange undtagelser- fun trylast ls =

last ls

handle TomListe => 0;

> val trylast = fn : int list -> int

- trylast [];

> val it = 0 : int

Fange undtagelser- fun f x = if x = 0 then x div 0 else if x = 1 then raise TomListe else x;> val f = fn : int -> int- fun g x = f x handle TomListe => 17 | x => 18;> val g = fn : int -> int- g 0;> val it = 18 : int- g 1;> val it = 17 : int- g 2;> val it = 2 : int

Parametrisk polymorfi i C++#include <stdio.h>

template <class T> T max(T a,T b){

return ( a>b ? a : b );}

template <class T> void swap(T &a,T &b){

T tmp = a; a=b; b=tmp; }

int main(){

printf ("max =%6.3g\n",max(2.34,3.45));

printf ("max =%d\n",max(334,245));

char a = 'c', b='q';

swap(a,b); printf ("a=%c b=%c\n",a,b);

int x=6,y=9;

swap(x,y); printf ("x=%d y=%d\n",x,y);

return(0);

}

Parametrisk polymorfi i SMLMoscow ML version 2.00 (June 2000)

Enter `quit();' to quit.

- fun swap (a,b) = (b,a);

> val ('a, 'b) swap = fn : 'a * 'b -> 'b * 'a

- swap (12,34);

> val it = (34, 12) : int * int

- swap ("hej","hallo");

> val it = ("hallo", "hej") : string * string

I C++ laves en version af swap og max for hver type den bruges med. I ML checkes typen en gang og funktionen bruges uafhængig af typen.

”højereordens” kald i javainterface Visitor{ int call(int x); }class List{ int x; List next; List(int x1,List n1){x=x1;next=n1;} void visit(Visitor vv){ x=vv.call(x); if(next!=null) next.visit(vv);} public String toString(){return ""+x+" :: "+next;} }class incv implements Visitor{ public int call(int x){ return x+1; } }public class visit{ public static void main(String args[]){ List l = new List(3,new List(5,new List(2,null))); System.out.println(l); l.visit(new incv()); System.out.println(l); } }

3 :: 5 :: 2 :: null4 :: 6 :: 3 :: null

Opgaver7.2: lav funktion min: int list -> int option der finder mindste

tal i en liste

9.3 lav funktion rod: (int -> int) -> int så rod f finder mindste tal n (n>0) så f(n) = 0;

9.4, 9.5

Flere opgaver1. Fakultetsfunktionen kan skrives fun fak(n) = if n = 1 then 1 else n * (fak n) Skriv den så den i stedet laver en liste af tal og derefter ganger dem sammen.

2. Skriv en funktion "flat" der tager en liste af lister og hæfter dem sammen til en liste. F.eks. skal [[1,2],[3],[4,5]] laves om til [1,2,3,4,5]

3. Overvej at skrive den med brug af fold og append (op@)

4. (Opgave for dem der kan matrixregning..) Lad en matrix være en liste af liste af heltal. Definer funktioner til multiplikation, sum, transponering og udregning af determinant.

5. lav funktion "subset" med to argumenter s1 og s2 og som undersøger om alle elementer i listen s1 også findes i listen s2. F.eks er

subset [1,2] [0,1,2,3] = truemens subset [0,1,2,3] [1,2] = false

6. Lav funktion "subsets" der danner en liste af alle delmængder af en liste. F.eks skal subsets [1,2] = [[],[1],[2],[1,2]]

7. lav funktion fun dropwhile p lst som fjerner elementer fra listen lst så længe funktionen p anvendt på elementet returnerer sand F.eks. antag f.eks. en funktion odd : int -> bool der undersøger om et tal er ulige da skal dropwhile odd [1,3,4,5,6] = [4,5,6]

Flere opgaver8. lav funktion fun takewhile p lst

som tager indeledende del af liste hvor funktion p returnerer sand for elementerne. F.eks. skal

takewhile odd [1,3,4,5,6] = [1,3]

9. lav funktion repeat f n lst som anvender funktionen f antallet n gange på argumentet så f.eks "repeat f 2 lst" er det samme som "(f (f lst))"

10. typen "(string * string) list" kan være nyttig som en slags "property list" a la maps fra javas collection frameworkskriv en funktion

lookup nm alst : string -> (string * string) list -> string så f.eks lookup "y" [("x","1"),("y","hej"),("z","$$$")] = "hej"

Det kan antages at hvis der ikke findes et et par i listen hvor første komponent passer så returnerer man blot en tom tekststreng

11. Skriv funktion "update" update nm vl alst : string -> string -> (string * string) list -> (string * string) list som fungerer som fun update nm vl alist = (nm,vl)::alst; bortset fra at hvis der findes et par hvor førstekomponenten er nm så erstates det par med

(nm,vl)