Høyere-ordens prosedyrer

Transkript

1 INF2810: Funksjonell programmering Høyere-ordens prosedyrer Stephan Oepen & Erik Velldal Universitetet i Oslo 8. februar, 2013

2 Tema 2 Forrige uke Lister og listerekursjon Høyere-ordens prosedyrer Prosedyrer som argumenter Anonyme prosedyrer I dag Mer om høyere-ordens prosedyrer Sekvensoperasjoner Prosedyrer som returverdi Lokale variabler Lister av lister

3 Listerekursjon og en abstraksjon 3 Ofte vil vi utføre en enkel transformasjon av hvert liste-element. Enkelt å generalisere dette mønsteret til en høyere-ordens prosedyre: (define (map proc items) (if (null? items) () (cons (proc (car items)) (map proc (cdr items))))) Vi sender med en prosedyre proc som et argument. Heter vanligvis map (en mer generell versjon er innebygd).? (map round ( )) ( )

4 lambda-uttrykk 4? (define square (lambda (x) (* x x)))? (square 4) 16? ((lambda (x) (* x x))) 4) 16? (map (lambda (x) (* x 0.1)) (2 3 4)) ( )? (map (lambda (x) (list x (* x x))) (2 3 4)) ((2 4) (3 9) (4 16)) lambda-uttrykk returnerer prosedyrer. Trenger ikke nødvendigvis bindes til et symbol; Kan kalles direkte som såkalt anonyme prosedyrer. Brukes ofte i forbindelse med høyere-ordens prosedyrer. Terminologien avslører noe av røttene...

5 lambda-uttrykk (forts.) 5 Stammer fra lambdakalkylen til Alonzo Church. Basis for all funksjonell programmering. Var på 30-tallet opptatt av mye av det samme som Alan Turing: Å lage en modell for hva beregninger er og hva som kan beregnes. Lambdakalkyle: (λx. x x)(4) Scheme: ((lambda (x) (* x x)) 4)

6 Flere høyere-ordens prosedyrer 6 Mens vi fortsetter å gjøre oss kjent med konseptet høyere-ordens prosedyrer skal vi se på noen klassiske sekvensoperasjoner: map har vi allerede sett. reduce og filter er neste.

7 reduce Sist nevnte vi et viktig punkt om å bygge opp et resultat rekursivt: Hva skal returneres når vi når basistilfellet? Avhenger av operasjonen vi bruker for å kombinere resultatene. Danner utgangspunktet for en annen klassisk høyere-ordens prosedyre:? (define (reduce proc init items) (if (null? items) init (proc (car items) (reduce proc init (cdr items)))))? (reduce + 0 ( )) 15? (reduce * 1 ( )) 120? (reduce cons () ( )) ( )? (reduce max 0 ( )) 5 7

8 reduce 8 reduce er også kjent som fold, compress, accumulate, eller inject. En måte å tenke på reduce: Vi beskrev lister som en rekursiv datastruktur i seg selv, bygget opp fra grunnverdien () med kjeder av cons-operasjoner. reduce re-kombinerer elementene med en ny operasjon og grunnverdi. (cons 1 (cons 2 (cons 3 (cons 4 (cons 5 ()))))) ( ) (+ 1 (+ 2 (+ 3 (+ 4 (+ 5 0))))) 15 (* 1 (* 2 (* 3 (* 4 (* 5 1))))) 120 (max 1 (max 2 (max 3 (max 4 (max 5 0))))) 5

9 Eksempel på bruk av map + reduce 9 Vi skal se på et kort eksempel på bruk av reduce sammen med map. Med vektorer representert som sekvenser (lister). Husk at den innebygde map tar en n-arguments prosedyre og n liste-argumenter.

10 Eksempel på bruk av map + reduce (forts.) 10 (define a (list 2 1 3)) Gitt to vektorer a = 2, 1, 3 b = 1, 3, 0 så beregnes prikk-produktet som x y = i x i y i a b = = 5 Versjon 2: Mer modulær design; kjede av høyere-ordens sekvensoperasjoner. (define b (list 1 3 0)) (define (dot-product x y) (if (null? x) 0 (+ (* (car x) (car y)) (dot-product (cdr x) (cdr y))))) (define (dot-product x y) (reduce + 0 (map * x y))) (dot-product a b) 5

11 Fjerning av elementer? (filter-odd ( )) ( )? (filter-odd ()) () (define (filter-odd items) (cond ((null? items) ()) ((odd? (car items)) (cons (car items) (filter-odd (cdr items)))) (else (filter-odd (cdr items))))) filter-odd returnerer en liste der alle partall er fjernet. Basistilfellet gir (). Tester det første elementet i lista. cons samler opp resultatet dersom elementet tester sant. Rekurserer på cdr av lista. 11

12 Muligheter for generalisering igjen 12 Igjen kan vi forestille oss et mere generelt mønster: (define (filter items)(define (filter predicate items) (cond ((null? items) ()) ((predicate (car items)) (cons (car items) (filter (cdr items))))(filter predicate (cdr it (else (filter (cdr items)))))(else (filter predicate ( Og igjen kan vi abstrahere mønsteret til en høyere-ordens prosedyre: Vi lar predicate bli et parameter.

13 filter 13? (define (filter pred items) (cond ((null? items) ()) ((pred (car items)) (cons (car items) (filter pred (cdr items)))) (else (filter pred (cdr items)))))? (filter odd? ( )) ( )? (filter even? ( )) ( ) Anvender et predikat på hvert element. Returnerer en ny liste med kun de elementene som predikatet tester sant for.? (filter (lambda (x) (and (> x 2) (< x 8))) ( )) ( )

14 Halerekursivt filter? 14 (define (filter pred items) (define (filter-iter in out) (cond ((null? in) out) ((pred (car in)) (filter-iter (cdr in) (cons (car in) out))) (else (filter-iter (cdr in) out)))) (filter-iter items ()))? (filter odd? ( )) ( )? (reverse (filter odd? ( ))) ( ) Hva med halerekursjon når vi bygger opp lister? La oss forsøke å skrive en halerekursiv versjon av filter! Hva er problemet her? Bygger opp lista bakvendt. (Vi skal komme tilbake til halerekursive listeoperasjoner nå vi introduserer destruktive operasjoner.)

15 Høyere-ordens prosedyrer del 2 Vi har så langt sett på prosedyrer som argumenter. Men vi kan øke uttrykkskraften betydelig når vi også tar med prosedyrer som returverdi. Enkelt: alt vi trenger å gjøre er å returnere et lambda-uttrykk.λ15

16 Prosedyrer som returverdi 16? (define (make-interval-test x y) (lambda (z) (and (> z x) (< z y))))? (make-interval-test 2 7) #<procedure>? (filter (make-interval-test 2 7) ( )) ( )? (filter (make-interval-test 3 6) ( )) (4 5) make-interval-test lager et predikat som vil sjekke om dens argument er innenfor et gitt intervall. lambda-uttrykket i kroppen anvendes ikke; Prosedyren som uttrykket evaluerer til er i seg selv returverdien. Så kan vi senere bruke den returnerte prosedyren som vi vil.

17 Prosedyrer som returverdi (forts.) 17? (define (make-scaler factor) (lambda (x) (* x factor)))? ((make-scaler 0.1) 10) 1.0 Returnerer en prosedyre som skalerer argumentet sitt med en gitt faktor.? (map (make-scaler -1) ( )) ( )

18 Prosedyrer som returverdi (forts.) 18 Enkel søk-og-erstatt, versjon 1:? (define (make-replacer x y) (lambda (z) (if (eqv? z x) y z)))? (map (make-replacer 42 towel)) ( )) (1 towel 2 towel 3)? (map (make-replacer 42 (0))) ( )) (1 (0) 2 (0) 3)

19 Prosedyrer inn, prosedyrer ut Enkel søk-og-erstatt, versjon 2:? (define (make-replacer pred proc) (lambda (z) (if (pred z) (proc z) z)))? (map (make-replacer (make-interval-test 40 45) (make-scaler 0.1)) ( )) ( )? (map (make-replacer odd? (lambda (x) (+ 1 x))) ( )) ( ) 19

20 Prosedyrer inn, prosedyrer ut (forts.) 20? (define (square x) (* x x))? (define (compose fn1 fn2) (lambda (x) (fn1 (fn2 x))))? (define foo (compose (make-interval-test 5 10) square))? (foo 2) #f? (foo 3) #t Et siste eksempel: compose. Setter sammen to prosedyrer til én ny. Her lager vi et nytt predikat som for et tall x sjekker om x 2 (5, 10)? (foo 4) #f

21 Lokale variabler og lambda 21 Ennå ikke ferdig med lambda for i dag. Nå skal vi se på hvordan vi kan bruke funksjonsapplikasjon med lambda for å få lokale variabler.

22 Lokale variabler og lambda (forts.) 22 I normalize kalles length én gang for hvert liste-element.? (normalize ( )) ( ) Mer effektivt om midlertidige beregninger tas vare på underveis. En måte å gjøre dette på er å definere en hjelpe-prosedyre; Argument-lista introduserer en ny lokal variabel som kan binde lengde-utregningen. Kan også gjøre det samme direkte via en anonym prosedyre. (define (normalize items) (map (lambda (x) (/ x (length items))) items)) (define (normalize items) (define (helper l) (map (lambda (x) (/ x l)) items)) (helper (length items))) (define (normalize items) ((lambda (l) (map (lambda (x) (/ x l)) items)) (length items)))

23 Lokale variabler, lambda og let 23 Behovet for lokale variabler er såpass vanlig at det finnes en kortform: let. (define (normalize items) ((lambda (l) (map (lambda (x) (/ x l)) items)) (length items))) (define (normalize items) (let ((l (length items))) (map (lambda (x) (/ x l)) items)))

24 Lokale variabler, lambda og let 24 Generell form for let Ekvivalent lambda-uttrykk (let (( var1 exp1 ) ( var2 exp2 ). ( varn expn )) body ) ((lambda ( var1 var2... varn ) body ) exp1 exp2... expn ) Vi ser at rekkevidden til variablene er kroppen til let-uttrykket, og at verdiene beregnes utenfor let-uttrykket. Variablene har ikke tilgang til hverandre under bindingen.

25 Noen eksempler med let? (define foo 42)? (let ((x foo) (y 1)) (list x y)) (42 1)? (let ((x foo) (y x)) (list x y)) error: x undefined? (let ((x foo) (y foo)) (list x y)) (42 42)? (let ((foo 7) (y foo)) (list foo y)) (7 42)? (let ((foo 7)) (let ((y foo)) (list foo y))) (7 7)? (let* ((foo 7) (y foo)) (list foo y)) (7 7) 25

26 Lokale variabler, lambda og let* 26 Generell form for let* Ekvivalent lambda-uttrykk (let* (( var1 exp1 ) ( var2 exp2 ). ( varn expn )) body ) ((lambda ( var1 ) ((lambda ( var2 ) ((lambda ( varn ) body ) expn )) exp2 )) exp1 ) Mens let binder variablene parallelt så gjør let* det sekvensielt. let* er en kortform for flere omsluttende let- eller lambda-uttrykk.

27 Lister som sekvenser 27 Så langt ha vi sett på lister som sekvenser. Kjeder av cons-par der siste elementet er den tomme lista; ().? (cons 1 (cons 2 (cons 3 (cons 4 ()))))) ( ) Rekursiv struktur; en liste er enten () eller et par der cdr er en liste.

28 Lister av lister 28 Hvert liste-element kan selv være en liste... Som igjen kan bestå av nye lister.? (cons (list 1 2) (list 3 4)) ((1 2) 3 4)

29 Lister som trær 29 Lister av lister kan sees som trær: Hvert element i en liste er en gren. Elementer som selv er lister er subtrær. Løvnodene i treet er de atomære elementene som ikke er lister.

30 Rekursjon på lister av lister 30 Rekursjon på lister av lister: Må passe på at rekursjonen går ned i hver liste. map er definert for lister; tree-map er definert for lister av lister:? (define (tree-map proc tree) (cond ((null? tree) ()) ((pair? tree) (cons (tree-map proc (car tree)) (tree-map proc (cdr tree)))) (else (proc tree))))? (tree-map square ((1 2) 3 4)) ((1 4) 9 16)? (tree-map square (((1 2) ((3))) (4))) (((1 4) ((9))) (16))