Programmierparadigmen

Transkript

1 Programmierparadigmen in Scheme D. Rösner Institut für Wissens- und Sprachverarbeitung Fakultät für Informatik Otto-von-Guericke Universität Magdeburg Sommer 2013, 17. Juni 2013, c D.Rösner D. Rösner PGP

2 Gliederung 1 Funktionales Programmieren: Scheme D. Rösner PGP

3 Historie Funktionales Programmieren: Scheme Frage: Welches sind die zwei ältesten und (in modernisierter Form) immer noch benutzten Programmiersprachen? Frage: Wann wurden diese Sprachen entwickelt?... D. Rösner PGP

4 Historie Funktionales Programmieren: Scheme unterschiedliche Ausrichtungen: Fortran: numerische Berechnungen Lisp: Symbolverarbeitung Symbolverarbeitung? Beispiele: symbolisches Rechnen (z.b. Differentiation, Integration) logisches Schliessen Analyse und Synthese chemischer Formeln Verarbeitung natürlicher Sprache Repräsentation von Wissen (z.b. semantische Netze)... D. Rösner PGP

5 Symbolverarbeitung mit Lisp Sprachmittel für Symbolverarbeitung in Lisp Atome als elementare Bausteine zusammengesetzte Strukturen auf der Basis verschachtelter Listen Beispiel: mögliche Darstellung eines Syntaxbaums (S (NP (DET Der) (N Mann)) (VP (V fragt) (PP (P nach) (NP (DET dem) (N Weg) (PP (P zum) (NP (N Bahnhof))))))) Scheme ist ein Dialekt von Lisp D. Rösner PGP

6 Scheme als funktionale Sprache: Diskussion von Scheme im Vergleich mit Haskell m.a.w. Gemeinsamkeiten und Unterschiede Haskell als Blaupause für funktionale Sprachen Grundlegendes: Interpreter Definition von Assoziationen zwischen Namen und Werten mit define (define <name> <wert>) D. Rösner PGP

7 Scheme als funktionale Sprache: wichtig: Funktionen sind Objekte erster Ordnung eine Interaktion: 1 ]=> (define pi ) ;Value: pi 1 ]=> pi ;Value: ]=> (define quadriere (lambda (zahl) (* zahl zahl))) ;Value: quadriere 1 ]=> (quadriere pi) ;Value: D. Rösner PGP

8 Scheme: Anonyme Funktionen Syntax: (lambda <parameterliste> <koerper>) überall dort verwendbar, wo auch mit Symbol auf Funktion verwiesen werden kann 1 ]=> ((lambda (n) (* n n)) 3) ;Value: 9 D. Rösner PGP

9 Scheme: Anonyme Funktionen alternative Syntax für benannte Funktionen (define (<name> <par-1>... <par-n>) <koerper>) statt (define <name> (lambda (<par-1>... <par-n>) <koerper>)) D. Rösner PGP

10 Scheme: Übersicht vordefinierte Datentypen Zahlen: ganze, rationale, Fliesskomma,... Strings: z.b. "ein String" Zeichen: z.b. #\a #\Z #\* #\space boolesche Werte: #t, #f... D. Rösner PGP

11 Scheme: Übersicht wichtigster aggregierter Datentyp: Liste Konstruktor: cons Selektoren: car, cdr Prädikate: list?, null? wichtige Kontrollstrukturen: if cond Funktionen zur Konversion zwischen verschiedenen Typen, z.b. number->string string->list... D. Rösner PGP

12 Syntax: in Scheme: Klammerung innerhalb geschachtelter Ausdrücke in Haskell: Vorrangregeln, Layoutregel Typisierung? in Scheme: keine Typisierung; in Haskell: strenge Typisierung Striktheit? Scheme: strikt Haskell: non-strikt rein funktional (pur)? Scheme: nicht pur, Seiteneffekte möglich z.b. mit set! Haskell: pur D. Rösner PGP

13 in Scheme: keine Typisierung Typüberprüfung durch vor- oder eigendefinierte Typprädikate Beispiele: number? list? string?... D. Rösner PGP

14 Striktheit vs. Non-Striktheit Eine (seiteneffekt-freie) Funktion heisst strikt, wenn gefordert wird, dass alle ihre Argumente definiert sind und so die Evaluationsordnung das Ergebnis nicht verändert. Eine Funktion heisst non-strikt, wenn für sie die Forderung nach Striktheit nicht erhoben wird. Eine Sprache heisst strikt, wenn gefordert wird, dass alle ihre Funktionen strikt. Eine Sprache heisst non-strikt, wenn sie die Definition non-strikter Funktionen zulässt. s.a. [Sco00], Ch D. Rösner PGP

15 Art der Auswertung? in Haskell: verzögerte Auswertung (lazy evaluation) für alle Argumente in Scheme: Auswertung für alle Argumente; aber: verzögerte Auswertung und call-by-need möglich mit delay und force s.a. [Sco00], Ch in Scheme nicht vordefiniert vorhanden sind u.a. Listenkomprehensionen und Fallunterscheidung durch Pattern Matching D. Rösner PGP

16 Scheme: weitere Aspekte Funktionen mit beliebiger Anzahl von Argumenten möglich (sog. Restparameter, der an Liste gebunden) Beispiel: (define (avg. nums) (average nums)) average erwartet Liste als Argument Definition: (define (average nums) (/ (apply + nums) (length nums))) D. Rösner PGP

17 Scheme: map... Anwenden einer Funktion auf die Elemente einer Liste und Rückgabe der Liste der Ergebnisse > (define (map f l) (if (null? l) () (cons (f (car l)) (map f (cdr l))))) > (map (lambda (x) (* x x)) ( )) ( ) D. Rösner PGP

18 Scheme: z.b. Falten einer zweistelligen Funktion in eine Liste: (define fold (lambda (f l i) (if (null? l) i ;; identity for f (f (car l) (fold f (cdr l) i))))) D. Rösner PGP

19 Scheme: partielle Anwendungen sind bei Funktionen im Curry-Format möglich (define curry (lambda (f) (lambda (a) (lambda (b) (f a b))))) 1 ]=> (((curry +) 3) 4) ;Value: 7 (define curried-plus (curry +)) D. Rösner PGP

20 : Sichtbarkeit von Definitionen die Definitionen auf dem Toplevel von Scheme sind global sichtbar wechselseitige Bezugnahme in rekursiven Definitionen ist möglich Beispiel: 1 ]=> (define (isodd n) (if (<= n 0) () (iseven (- n 1)))) ;Value: isodd... D. Rösner PGP

21 : Sichtbarkeit von Definitionen Beispiel cont.: 1 ]=> (define (iseven n) (if (< n 0) () (if (= n 0) #t (isodd (- n 1))))) ;Value: iseven 1 ]=> (iseven 5) ;Value: () 1 ]=> (isodd 5) ;Value: #t D. Rösner PGP

22 Lokale Definitionen Motivation: Vermeiden wiederholter Berechnungen klarer strukturierter Code Beispiel: eine Funktion addpairwise, die korrespondierende Elemente zweier Zahlenlisten addiert und falls eine Liste keine Elemente mehr hat den aktuellen Rest der anderen an die Liste der Paarsummen anhängt D. Rösner PGP

23 Scheme: lokale Bindungen mit let und let* Syntax: (let ((var1 val1) (var2 val2)... (varn valn)) <body>) Semantik: bei der Auswertung von <body> sind die in var1, var2,..., varn gebundenen Werte val1, val2,..., valn verfügbar D. Rösner PGP

24 Scheme: lokale Bindungen mit let und let* Beispiel: addpairwiserest als Äquivalent zu addpairwise (define (addpairwiserest list1 list2) (let ((front (addpairwise list1 list2)) (minlength (min (length list1)(length list2)))) (let ((rear (append (drop minlength list1) (drop minlength list2)))) (append front rear)))) D. Rösner PGP

25 Scheme: lokale Bindungen mit let und let* Beachte: bei let erfolgt die Auswertung und Bindung in den einzelnen (var1 val1) (var2 val2)... (varn valn) parallel daher folgendes falsch: (define (addpairwiserest list1 list2) (let ((front (addpairwise list1 list2)) (minlength (min (length list1)(length list2))) (rear (append (drop minlength list1) (drop minlength list2)))) (append front rear))) 1 ]=> (addpairwiserest ( ) (8 15)) ;Unbound variable: minlength D. Rösner PGP

26 Scheme: lokale Bindungen mit let und let* let* ist wie let, nur erfolgt Auswertung und Bindung in den einzelnen (var1 val1) (var2 val2)... (varn valn) sequentiell m.a.w. für die Ausdrücke vali (für 2 <= i <= n) stehen die Bindungen var1, var2,..., var(i-1) zur Verfügung D. Rösner PGP

27 Scheme: lokale Bindungen mit let und let* Beispiel für let*: (define (addpairwiserest list1 list2) (let* ((front (addpairwise list1 list2)) (minlength (min (length list1)(length list2))) (rear (append (drop minlength list1) (drop minlength list2)))) (append front rear))) 1 ]=> (addpairwiserest ( ) (8 15)) ;Value 12: ( ) D. Rösner PGP

28 Beispiel cont. Funktionales Programmieren: Scheme Hilfsfunktionen a la Haskell: (define (addpairwise list1 list2) (if (or (null? list1)(null? list2)) () (cons (+ (car list1)(car list2)) (addpairwise (cdr list1)(cdr list2))))) (define (take n list) (if (= n 0) () (cons (car list) (take (- n 1) (cdr list))))) (define (drop n list) (if (= n 0) list (drop (- n 1) (cdr list)))) D. Rösner PGP

29 Scheme: Berechnung Quadratwurzel mit Newton-Verfahren (define (sqrt x) (sqrt-iter 1 x)) (define (sqrt-iter guess x) (if (good-enough? guess x) guess (sqrt-iter (improve guess x) x))) (define (good-enough? guess x) (< (abs (- (square guess) x)).001)) (define (improve guess x) (average guess (/ x guess))) D. Rösner PGP

30 Blockstruktur: Funktionales Programmieren: Scheme (define (sqrt x) (define (good-enough? guess x) (< (abs (- (square guess) x)).001)) (define (improve guess x) (average guess (/ x guess))) (define (sqrt-iter guess x) (if (good-enough? guess x) guess (sqrt-iter (improve guess x) x))) (sqrt-iter 1 x) ) D. Rösner PGP

31 Interne Definitionen Ausnutzen, daß x in sqrt gebunden (lexikalischer ): (define (sqrt x) (define (good-enough? guess) (< (abs (- (square guess) x)).001)) (define (improve guess) (average guess (/ x guess))) (define (sqrt-iter guess) (if (good-enough? guess) guess (sqrt-iter (improve guess)))) (sqrt-iter 1)) D. Rösner PGP

32 lexikalischer : freie Variable in einer Prozedur verweisen auf Variable in umfassenden Prozeduren m.a.w.: Werte freier Variable werden in der Umgebung gesucht, in der die Prozedur definiert wurde D. Rösner PGP

33 Symbolisches Differenzieren zentrale Funktion: deriv (s.a. [AGJ96]) (define (deriv exp var) (cond ((constant? exp) 0) ((variable? exp) (if (same-variable? exp var) 1 0)) ((sum? exp) (make-sum (deriv (addend exp) var) (deriv (augend exp) var))) ((product? exp) (make-sum (make-product (multiplier exp) (deriv (multiplicand exp) var)) (make-product (deriv (multiplier exp) var) D. Rösner PGP

34 Symbolisches Differenzieren Darstellung von Summen (s.a. [AGJ96]) (define (make-sum a1 a2) (list + a1 a2)) (define (sum? x) (if (not (atom? x)) (eq? (car x) +) nil)) (define (addend s) (cadr s)) (define (augend s) (caddr s)) D. Rösner PGP

35 Symbolisches Differenzieren allgemein: Darstellung von Datenstrukturen Konstruktoren Prädikate Selektoren s.a. [AGJ96] D. Rösner PGP

36 Symbolisches Differenzieren Darstellung von Produkten (s.a. [AGJ96]) (define (make-product m1 m2) (list * m1 m2)) (define (product? x) (if (not (atom? x)) (eq? (car x) *) nil)) (define (multiplier p) (cadr p)) (define (multiplicand p) (caddr p)) D. Rösner PGP

37 Symbolisches Differenzieren Hilfsfunktionen (s.a. [AGJ96]) (define (constant? x) (number? x)) (define (variable? x) (symbol? x)) (define (same-variable? v1 v2) (and (variable? v1) (variable? v2) (eq? v1 v2))) D. Rösner PGP

38 Symbolisches Differenzieren Hilfsfunktionen (s.a. [AGJ96]) (define (atom? x) (or (number? x) (string? x) (symbol? x) (null? x) (eq? x #t))) D. Rösner PGP

39 Symbolisches Differenzieren Beispiele (s.a. [AGJ96]) Welcome to DrRacket, version [3m]. Language: R5RS [custom]; memory limit: 128 MB. > (deriv (+ x 3) x) (+ 1 0) > (deriv (* x y) y) (+ (* x 1) (* 0 y)) > (deriv (* (* x y) (+ x 3)) x) (+ (* (* x y) (+ 1 0)) (* (+ (* x 0) (* 1 y)) (+ x 3))) Welche Vereinfachungen von Termen? D. Rösner PGP

40 Symbolisches Differenzieren verbesserte Konstruktor-Funktionen (s.a. [AGJ96]) (define (make-sum a1 a2) (cond ((and (number? a1) (number? a2)) (+ a1 a2)) ((number? a1) (if (= a1 0) a2 (list + a1 a2))) ((number? a2) (if (= a2 0) a1 (list + a1 a2))) (else (list + a1 a2)))) D. Rösner PGP

41 Symbolisches Differenzieren Anwendung verbesserter Konstruktor-Funktion make-sum (s.a. [AGJ96]) > (deriv (+ x 3) x) 1 > (deriv (* (* x y) (+ x 3)) x) (+ (* (* x y) 1) (* (+ (* x 0) (* 1 y)) (+ x 3))) D. Rösner PGP

42 Symbolisches Differenzieren verbesserte Konstruktor-Funktionen (s.a. [AGJ96]) (define (make-product m1 m2) (cond ((and (number? m1) (number? m2)) (* m1 m2)) ((number? m1) (cond ((= m1 0) 0) ((= m1 1) m2) (else (list * m1 m2)))) ((number? m2) (cond ((= m2 0) 0) ((= m2 1) m1) (else (list * m1 m2)))) (else (list * m1 m2)))) D. Rösner PGP

43 Symbolisches Differenzieren Anwendung verbesserter Konstruktor-Funktion make-product (s.a. [AGJ96]) statt > (deriv (* (* x y) (+ x 3)) x) (+ (* (* x y) 1) (* (+ (* x 0) (* 1 y)) (+ x 3))) jetzt > (deriv (* (* x y) (+ x 3)) x) (+ (* x y) (* y (+ x 3))) D. Rösner PGP

44 Scheme: Programme haben die Form von Listen Scheme (und Lisp) sind homoikonisch, d.h. selbstrepräsentierend Programme können mit allen Listenfunktionen bearbeitet werden Beispiel: (define compose (lambda (f g) (lambda (x) (f (g x))))) 1 ]=> ((compose car cdr) (1 2 3)) ;Value: 2 D. Rösner PGP

45 Scheme: Beispiel cont.: (define compose2 (lambda (f g) (eval (list lambda (x) (list f (list g x))) (scheme-report-environment 5)))) 1 ]=> ((compose2 car cdr) (1 2 3)) ;Value: 2 D. Rösner PGP

46 Literatur: I Funktionales Programmieren: Scheme Harold Abelson, G.J.Sussman, and J.Sussman. Structure and Interpretation of Computer Programs. MIT Press, Cambridge, MA, USA, nd edition; Bem.: dt. Übersetzung existiert, aber engl. Original ist mehr zu empfehlen DR. Michael Lee Scott. Programming Language Pragmatics. Academic Press, San Diego, CA, USA, ISBN D. Rösner PGP