Grundlagen der Informatik I

Transkript

1 Grundlagen der Informatik I Thema 8: Interpreter-basierte Semantik Intermezzo 1 in HTDP Chap. 4 in SICP () Prof. Dr. Mira Mezini Dr. Michael Eichberg

2 Chapter Overview Thema 8: Interpreter nach dem Substitutionsmodell 8.1 Einführung: Syntax und Semantik 8.2 Interpreterbasierte Semantik 8.3 Meta-Interpreter für ein Teil von Racket 8.4 Normale Auswertungsreihenfolge 8.5 Zusammenfassung 2

3 Thema 8: Interpreter-basierte Semantik 8.1 Einführung: Syntax und Semantik 3

4 Thema 8: Interpreter-basierte Semantik: Einführung: Syntax und Semantik Syntax Ähnlich wie die natürlichen Sprachen haben auch die Programmiersprachen ein Vokabular und eine Grammatik. 4

5 Thema 8: Interpreter-basierte Semantik: Einführung: Syntax und Semantik Syntax Der Ausdruck Syntax bezieht sich auf Vokabular und Grammatik von Programmiersprachen Vokabular: eine Sammlung der Wörter ', aus denen wir Sätze bilden können. Grammatik: sagt uns, wie wir ganze Sätze aus Wörtern bilden. 5

6 Thema 8: Interpreter-basierte Semantik: Einführung: Syntax und Semantik Das Vokabular von Racket Vier Kategorien von Wörtern Namen von Operationen Namen von Werten Notation: Zeilen zählen Beispiele auf, getrennt durch Punkte bedeuten: es gibt noch mehr Dinge derselben Art in der Kategorie <name> = x a alon... <op> = area-of-disk perimeter... <lit> = true false 'a 'doll 'sum / <prm> = Literale: boolean, Symbole, Zahlen Primitive Operationen <prm>: Racket stellt sie von Anfang an zur Verfügung 6

7 Thema 8: Interpreter-basierte Semantik: Einführung: Syntax und Semantik Grammatik von Beginning Student Racket <def> = (define (<op> <var>...<var>) <exp>) <exp> = <name> (define <var> <exp>) (define-struct <var0> (<var-1>...<var-n>)) <con> (<prm> <exp>...<exp>) (<op> <exp>...<exp>) (cond [<exp> <exp>]... [<exp> <exp>]) (cond [<exp> <exp>]... [else <exp>]) (and <exp> <exp>) Zwei Kategorien von Sätzen: Definitionen (<def>) und Ausdrücke (<exp>) (or <exp> <exp>) (if <exp> <exp> <exp>) 7

8 Thema 8: Interpreter-basierte Semantik: Einführung: Syntax und Semantik Grammatik von Beginning Student Racket <def> = (define (<op> <var>... <var>) <exp>) <exp> = <name> (define <var> <exp>) (define-struct <var0> (<var-1>...<var-n>)) Drei Arten von Definitionen <con> (<prm> <exp>...<exp>) (<op> <exp>...<exp>) (cond [<exp> <exp>]... [<exp> <exp>]) (cond [<exp> <exp>]... [else <exp>]) (and <exp> <exp>) Kann auch leer sein (or <exp> <exp>) (if <exp> <exp> <exp>) 8

9 Thema 8: Interpreter-basierte Semantik: Einführung: Syntax und Semantik Grammatik von Beginning Student Racket <def> = (define (<op> <var>...<var>) <exp>) <exp> = <name> (define <var> <exp>) (define-struct <var0> (<var-1>...<var-n>)) <lit> (<prm> <exp>...<exp>) (<op> <exp>...<exp>) (cond [<exp> <exp>]... [<exp> <exp>]) (cond [<exp> <exp>]... [else <exp>]) (and <exp> <exp>) Mehrere Arten von Ausdrücken Vereinfachte Grammatik: nicht alle erzeugbaren Ausdrücke sind gültig! (or <exp> <exp>) (if <exp> <exp> <exp>) 9

10 Thema 8: Interpreter-basierte Semantik: Einführung: Syntax und Semantik Grammatik von Beginning Student Racket <def> = (define (<op> <var>... <var>) <exp>) (define <var> <exp>) (define-struct <var0> (<var-1>... <var-n>)) <exp> = <name> <lit> (<prm> <exp>... <exp>) (<op> <exp>... <exp>) (cond [<exp> <exp>]... [<exp> <exp>]) (cond [<exp> <exp>]... [else <exp>]) (and <exp> <exp>) (or <exp> <exp>) (if <exp> <exp> <exp>) 10

11 Thema 8: Interpreter-basierte Semantik: Einführung: Syntax und Semantik Grammatik von Racket: Korrekte Ausdrücke 'all: Symbol (Literal), also ein Ausdruck x: Name, also ein Ausdruck (f x): eine Operationsaufruf, da x ein Name ist. 11

12 Thema 8: Interpreter-basierte Semantik: Einführung: Syntax und Semantik Grammatik von Racket: Inkorrekte Ausdrücke (f define): stimmt teilweise mit der Form einer Operationsaufrufs überein, aber es benutzt define als sei es eine <exp>. (): Grammatik verlangt, dass nach jeder linken Klammer etwas anderes kommt als eine rechte Klammer. (cond x): kann kein korrekter cond-ausdruck sein, weil an zweiter Stelle ein Name steht, und nicht ein geklammertes Paar von Ausdrücken 12

13 Thema 8: Interpreter-basierte Semantik: Einführung: Syntax und Semantik Semantik Nicht alle grammatikalisch richtigen Sätze sind sinnvoll weder in Deutsch noch in Programmiersprachen. Beispiele: Die Katze ist schwarz ' ist ein sinnvoller Satz. Der Ziegel ist ein Auto macht wenig Sinn, auch wenn der Satz grammatikalisch richtig ist. 13

14 Thema 8: Interpreter-basierte Semantik: Einführung: Syntax und Semantik Semantik Um herauszufinden ob ein Satz sinnvoll ist, müssen wir die Bedeutung oder Semantik der Wörter und Sätze verstehen. Für Programmiersprachen gibt es verschiedene Wege, um den Sinn von einzelnen Ausdrücken zu erklären. Den Sinn von Racket- Programmen haben wir bisher mit einer Erweiterung der bekannten Gesetze aus Arithmetik und Algebra (Substitutionsmodell) diskutiert. 14

15 Thema 8: Interpreter-basierte Semantik: Einführung: Syntax und Semantik Rückblick: Das bisherige Auswertungsmodell Zahlen, Symbole etc. à selbstauswertend make-struct, cons à selbstauswertend (lambda ( ) ) à selbstauswertend Primitive Operationen à entsprechende Maschinenbefehle ausführen. 15

16 Thema 8: Interpreter-basierte Semantik: Einführung: Syntax und Semantik Rückblick: Das bisherige Auswertungsmodell (define ) à Erweitere die Umgebung (local ) à Herausziehen der lokalen Definitionen auf oberste Ebene, jeweils neuen Namen vergeben (operator op-1 op-n): 1. Auswertung von operator sowie op-1 op-n 2. operator muss (lambda (x-1 x-n) exp) ergeben 3. Auswertung von exp, wobei exp sich aus exp durch Substitution der freien Vorkommen von x-1 x-n durch die Ergebnisse der Auswertung von op-1 op-n ergibt Lexikalisches Scoping 16

17 Thema 8: Interpreter-basierte Semantik 8.2 Interpreter als Semantik-Definition 17

18 Thema 8: Interpreter-basierte Semantik: Interpreter als Semantik-Definition Interpreter-basierte Semantikdefinition Der Auswertungsprozess kann selbst als ein Rechenprozess modelliert werden, der als eine Operation präzisiert und implementiert werden kann. Der Interpreter einer Programmiersprache, der die Bedeutung ihrer Ausdrücke festlegt, ist auch nur ein Programm. Einige Programmiersprachen werden tatsächlich durch Interpreter definiert (z.b. Racket, SML) 18

19 Thema 8: Interpreter-basierte Semantik: Interpreter als Semantik-Definition Interpreter-basierte Semantikdefinition Ein solcher Interpreter kann keine Fehler enthalten, weil er die Bedeutung definiert! Z. B. können wir dem Symbol + in einem Interpreter eine Multiplikationsoperation als Bedeutung zuweisen. Das ist kein Fehler, sondern eine mögliche Definition! Ein Fehler kann immer nur in Bezug auf eine Spezifikation festgestellt werden. 19

20 Thema 8: Interpreter-basierte Semantik: Interpreter als Semantik-Definition Andere Arten von Semantikdefinitionen Informelle Sprachdefinitionen Formale Sprachdefinitionen Denotationelle Semantik Operationale Semantik... Wenn es eine explizite Definition einer Sprache gibt, macht es Sinn, von Fehlern eines Interpreters relativ zu einer Sprachdefinition zu sprechen. 20

21 Thema 8: Interpreter-basierte Semantik: Interpreter als Semantik-Definition Terminologie der Interpreter-basierten Semantik Basissprache: die Sprache, in der der Interpreter implementiert ist (interpretierende Sprache). Interpretierte Sprache: die Sprache, die der Interpreter auswertet. Wenn die interpretierte Sprache und die Basissprache identisch sind, spricht man von einem Meta-Interpreter oder metazirkulären Interpreter. 21

22 Thema 8: Interpreter-basierte Semantik: Interpreter als Semantik-Definition Turing Vollständigkeit Prinzipiell ist es möglich, in jeder Programmiersprache, die ein paar Basiskriterien erfüllt*), einen Interpreter für jede andere Programmiersprache zu schreiben. *) Gelten für nahezu jede universelle Programmiersprache (Java, C, Racket, Pascal, Perl, etc.) Eines der fundamentalen Resultate der Informatik 22

23 Thema 8: Interpreter-basierte Semantik: Interpreter als Semantik-Definition Warum untersuchen wir Interpreter (Semantik)? Geheimnisse aufdecken, wie Konzepte implementiert sind à daraus tieferes Verständnis erlangen. Wir betrachten uns als Sprachentwickler und nicht nur als Nutzer einer Sprache, die andere entwickelt haben. Einblick gewinnen, wie neue Sprachen implementiert werden. 23

24 Thema 8: Interpreter-basierte Semantik: Interpreter als Semantik-Definition Warum untersuchen wir Interpreter (Semantik)? Die Definition neuer Sprachen ist ein mächtiges Mittel, um Komplexität im Design zu kontrollieren. Neue Sprachen erhöhen unsere Fähigkeit, mit komplexen Problemen umzugehen, indem sie uns Mittel zur Verfügung stellen, mit deren Hilfe wir Probleme direkter beschreiben. 24

25 Thema 8: Interpreter-basierte Semantik: Interpreter als Semantik-Definition Warum untersuchen wir Interpreter? Man kann viele Programme als einen Interpreter einer Sprache betrachten. Beispiel: Ein Programm zur Berechnung von Polynomen. Rechenregeln für Polynome werden als Operationen auf Listenstrukturen implementiert. Dieses Programm + Operationen zum Lesen und Ausgeben von Polynomen à Kern einer spezialisierten Sprache für die symbolische Mathematik. 25

26 Thema 8: Interpreter-basierte Semantik: Interpreter als Semantik-Definition Interpreterbasierte Semantik und Rekursion Wenn man einen Interpreter zur Sprachdefinition benutzt, setzt man voraus, dass der Nutzer die Bedeutung der Basissprache bereits versteht. Rekursionsanker ist meistens Prosa (deutsch/englisch) oder die Mathematik. Ein vieldiskutiertes Problem in der Mathematik (Modelltheorie vs. Beweistheorie) und der Philosophie, aber nicht Thema von GdI-1. 26

27 Thema 8: Interpreter-basierte Semantik 8.3 Meta-Interpreter für ein Teil von Racket 27

28 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket Stopp #1 auf dem Weg Randnotiz #1: Racket ist besonders gut geeignet, um Sprachinterpreter zu schreiben. Einfache Syntax, wenige aber mächtige Sprachelemente Randnotiz #2: Der Interpreter enthält die grundlegende Struktur eines Interpreters für jede Ausdrucksorientierte Sprache, die verwendet werden kann, um Programme auf einer sequentiellen Maschine zu schreiben. 28

29 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket Stopp #2 auf dem Weg Verwechseln Sie nicht die Basissprache mit der interpretierten Sprache! Wenn Sie einen Interpreter in Racket schreiben, beeinflusst das nicht die Auswertung des DrRacket Interpreters Wenn Ihr Interpreter bei + multipliziert, ergibt (+ 3 5) in DrRacket nach wie vor 8 J 29

30 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket Die implementierten Sprachkonstrukte Explizit implementierte Sprachelemente Operationen (lambda) und Operationsapplikation Umgebung (define) if Implizit implementierte Sprachelemente Primitive Operationen (Addition, Multiplikation, ) Primitive Werte (Zahlen, boolesche Werte) Rekursion, Speicherverwaltung 30

31 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket Ignorierte Sprachkonstrukte Ignorierte Sprachelemente define-struct local Definition nicht anonymer Operationen(define (f x) ) cond Kein Verlust der Ausdrucksstärke: Strukturen können mit Hilfe von Listen kodiert werden Explizite Operationsdefinitionen und local können mit lambda kodiert werden cond kann mit Hilfe von if kodiert werden 31

32 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket Ignorierte Sprachkonstrukte (define (f x-1 x-n) exp) (define f (lambda (x-1 x-n) exp)) (local ((define var_1 val_1)... (define var_n val_n)) local-body) ((lambda (var_1... var_n) local-body) val_1... val_n) 32

33 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket Aufbau des Interpreters Datendefinitionen für die Darstellung der Programme als Daten des Interpreters und die Überführung eines Programtextes in entsprechende Datenelemente. Auswertungsoperation (eval...) 33

34 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket Darstellung der Programme als Daten Datendefinitionen für die Darstellung der Programme als Daten des Interpreters und die Überführung eines Programtextes in entsprechende Datenelemente. Auswertungsoperation (eval...) 34

35 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Darstellung der Programme als Daten S-Expressions Programme werden als verschachtelte Listen von Symbolen repräsentiert. Solche Listen werden S-Expressions genannt. '((lambda (n) (if (= n 0) 1 (* n (- n 1))) 5) 35

36 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Darstellung der Programme als Daten Parser und abstrakte Syntax Parser: Ein Programm, das ein S-Expression zu einem abstrakten Syntaxbaum (AST: Abstract Syntax Tree) application verwandelt. operator operands '((lambda (n) (if (= n 0) 1 (* n (- n 1))) 5) proc '(5) parameters exp '( ) if-clause predicate consequent alternative PARSER variable name 'n (make-application (make-proc (list n) (make-if-clause...)) (list 5) ) 36

37 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Darstellung der Programme als Daten Definition der abstrakten Syntax ;; An expression exp is either: ;; ;; 1. (make-definition var val) where ;; var is a symbol and val is an exp ;; ;; 2. (make-proc params exp) where ;; params is a list-of-symbols and exp is an exp ;; ;; 3. (make-if-clause predicate c a) where ;; predicate, consequent, and alternative are exp ;; ;; 4. (make-application operator operands) where ;; operator is an exp and operands is (listof exp) ;; ;; 5. (make-variable n) where n is a symbol ;; ;; 6. a number or a boolean or a string 37

38 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Darstellung der Programme als Daten Definition der abstrakten Syntax ;; definition-exp (define-struct definition (variable value)) ;; proc-exp (define-struct proc (parameters exp)) ;; if-exp (define-struct if-clause (predicate consequent alternative)) ;; app-exp (define-struct application (operator operands)) ;; name-exp (define-struct variable (name)) Die Menge der primitiven Operationen ist in der Syntax nicht festgelegt 38

39 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Darstellung der Programme als Daten S-Expressions vereinfachen den Parser Der Parser kann anhand des ersten Elements der Liste entscheiden, welchen AST-Datentyp er erzeugt. Andernfalls würde das Parsen erheblich komplexer. '((lambda (n) (if (= n 0) 1 (* n (- n 1))) 5) PARSER (make-application (make-proc (list n) (make-if-clause...)) (list 5) ) 39

40 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Darstellung der Programme als Daten Abstrakte versus konkrete Syntax Die Datentypdefinitionen für die abstrakte Syntax abstrahieren von der konkreten Syntax des Programms: So sind Klammern, Kommentare usw. nicht repräsentiert. Daher der Name abstrakte Syntax Die konkrete Syntax zu dieser abstrakten Syntax könnte unterschiedlich aussehen, z.b. f(op1, op2) statt (f op1 op2) statt (+ 3 5) 40

41 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Darstellung der Programme als Daten Von Programmtext zu AST... Typischerweise erhält der Parser eine Liste von Zeichen und nicht eine S-expression. [λn.if (n == 0) 1 : n * (n 1)] 5 Er muss daraus Tokens bilden und die abstrakte Syntax extrahieren à Eine Wissenschaft für sich, aber nicht Thema von GdI-1 41

42 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Darstellung der Programme als Daten Von Programmtext zu AST... [λn.if (n == 0) 1 : n * (n 1)] 5 '((lambda (n) (if (= n 0) 1 (* n (- n 1))) 5) Diesen Schritt lassen wir außer Acht. PARSER (make-application (make-proc (list n) (make-if-clause...)) 5 ) 42

43 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Darstellung der Programme als Daten Von Programmtext zu AST... [λn.if (n == 0) 1 : n * (n 1)] 5 Diesen Schritt lassen wir außer Acht. '((lambda (n) (if (= n 0) 1 (* n (- n 1))) 5) PARSER Racket s read Operation produziert die s-expression zu Programmen einer Sprache mit Racketähnlichen konkreten Syntax! (make-application (make-proc (list n) (make-if-clause...)) 5 ) 43

44 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Darstellung der Programme als Daten Ein Parser in Racket ;; parse converts an s-expression into an exp structure ;; parse : s-expression -> exp (define (parse sexp) (cond [(number? sexp)???] [(string? sexp)???] [(boolean? sexp)???] [(symbol? sexp)???] [(cons? sexp)...])) 44

45 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Darstellung der Programme als Daten Ein Parser in Racket ;; parse converts an s-expression into an exp structure ;; parse : s-expression -> exp (define (parse sexp) (cond [(number? sexp) sexp] [(string? sexp) sexp] [(boolean? sexp) sexp] [(symbol? sexp) (make-variable sexp)] [(cons? sexp)...])) 45

46 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Darstellung der Programme als Daten Ein Parser in Racket (define (parse sexp) (cond... [(cons? sexp) (local ((define op (first sexp))) (cond [(and (symbol? op) (symbol=? op 'lambda)) (make-proc (second sexp) (parse (third sexp)))] [(and (symbol? op) (symbol=? op 'if)) (make-if-clause (parse (second sexp)) (parse (third sexp)) (parse (fourth sexp)))] [(and (symbol? op) (symbol=? op 'define)) (make-definition (second sexp) (parse (third sexp)))] [else (make-application (parse (first sexp)) (map parse (rest sexp)))]))])) 46

47 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket Ausführen von Programmen Ein Programm besteht aus einer Reihe von Definitionen und einer Reihe von Ausdrücken Zwei Operationen für die Auswertung Die Ausführung eines Programms wird von der Operation run-prog gesteuert: run-prog :: prog env -> (listof val) Die eval Operation: eval : exp env -> val Kann nur einzelne Ausdrücke auswerten, jedoch keine (define ) Anweisungen. 47

48 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Ausführen von Programmen Die Operation run-prog o Erstellt die Anfangsumgebung. o Erweitert Umgebung nach Auswertung einer (define ) Anweisung. o Für andere Ausdrücke werden die jeweiligen Ergebnisse berechnet (durch Aufruf von eval) und zu einer Ergebnisliste zusammengefügt. 48

49 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Ausführen von Programmen Die Operation run-prog ;; a program prog is a (listof exp) ;; run-prog :: prog env -> (listof val) (define (run-prog prog env) (cond [(empty? prog) empty] [else (local ((define exp (parse (first prog)))) (cond [(definition? exp) (...) [else (...)]) ] ) ) 49

50 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Ausführen von Programmen Ausführen von Programmen ;; a program prog is a (listof exp) ;; run-prog :: prog env -> (listof val) (define (run-prog prog env)... (cond [(definition? exp) (run-prog (rest prog) Erweitern der Umgebung (map-extend (definition-variable exp) (eval (definition-value exp) env) env))] [else (...)]))) 50

51 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Ausführen von Programmen Ausführen von Programmen ;; a program prog is a (listof exp) ;; run-prog :: prog env -> (listof val) (define (run-prog prog env)... (cond [(definition? exp) (run-prog (rest prog) (map-extend (definition-variable exp) (eval (definition-value exp) env) env))] [else Erweitern der Ergebnisliste (cons (eval exp env) (run-prog (rest prog) env)))]))) 51

52 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Ausführen von Programmen Primitive Operationen (define primitive-procedures (local ( (define names '(first rest cons list empty? empty * / - + < =)) (define procs (list first rest cons list empty? empty * / - + < =))) ) ) (map-create names (map make-primitive-procedure procs)) Racket s primitive Operationen werden in einer Hülle verpackt, die sie als primitive Operationen in unserer Sprache gekennzeichnet. 52

53 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Ausführen von Programmen Benutzung des Interpreters (define testprog '((define! (lambda (n) (if (= n 0) 1 (* n (! (- n 1)))))) (! 5))) (run-prog testprog primitive-procedures) Die gewünschten primitiven Operationen bilden die Anfangsumgebung 53

54 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Ausführen von Programmen Bemerkungen über Primitive Operationen Die Sprache kann leicht um neue primitive Operationen erweitert werden. Es besteht kein Zwang, eine primitive Operation durch die primitive Operation desselben Namens in der Basissprache zu implementieren. Wir können auch nicht-primitive Racket Operationen benutzen, die dann in der interpretierten Sprache primitiv sind. Wir könnten hier festlegen, dass das Symbol + in unserer Sprache Multiplikation bedeutet J 54

55 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket Auswertung in einer Umgebung ;; Data type env: ;; An environment env is a (mapof val) ;; eval evaluates an expression exp in an environment env ;; eval : exp env -> val (define (eval exp env) ) (eval (make-application (make-variable '+) (list (make-variable 'x) 3)) env) à 8 env '+ (make-primitive-procedure +) 'x 5 55

56 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Auswertung in einer Umgebung (Selbstauswertende) Werte (define-struct primitive-procedure (the-proc)) ;; A value val is either ;; 1. a number ;; 2. a String ;; 3. a Boolean ;; 4. (make-proc params exp) ;; where params is a list-of-symbols and exp is an exp ;; 5. (make-primitive-procedure p) ;; where p is a Racket procedure ;; all values are self-evaluating ;; self-evaluating :: exp -> boolean (define (self-evaluating? exp) (cond [(number? exp) true] [(string? exp) true] [(boolean? exp) true] procedures are selfevaluating!! [(proc? exp) true] [(primitive-procedure? exp) true] [else false])) 56

57 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Auswertung in einer Umgebung Grundstruktur der Auswertungsfunktion (define (eval exp env) (cond [(self-evaluating? exp) exp] [(variable? exp) (eval-var exp env)] [(if-clause? exp) (eval-if exp env)] [(application? exp) (eval-app (eval (application-operator exp) env) (map (lambda (expr) (eval expr env)) (application-operands exp)) env)] Weiterleitung an Spezialprozeduren für jeden Ausdruckstyp [else (error 'eval (format "Unknown expression type: ~v" exp))])) 57

58 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Auswertung in einer Umgebung Auswertung von Variablen: eval-var ;; evaluates a variable ;; by looking it up in the environment ;; ;; eval-var :: exp env -> val ;; (define (eval-var exp env) (local ((define val (map-lookup (variable-name exp) env))) (if (empty? val) (error 'eval-var (format "Unbound variable: ~v" (variable-name exp))) val))) 58

59 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Auswertung in einer Umgebung Auswertung von if Ausdrücken: eval-if ;; eval-if : exp env -> val (define (eval-if exp env) (if (eval (if-clause-predicate exp) env) (eval (if-clause-consequent exp) env) (eval (if-clause-alternative exp) env))) 59

60 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Auswertung in einer Umgebung Auswertung von Operationsaufrufen: eval-app ;; eval-app: val (listof exp) env -> val (define (eval-app procedure arguments env) (cond [(primitive-procedure? procedure) (... )] [(proc? procedure) (...)] [else (error 'eval-app (format "Procedure expected, found: ~v procedure))])) 60

61 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Auswertung in einer Umgebung Auswertung von primitiven Operationen ;; eval-app: val (listof exp) env -> val (define (eval-app procedure arguments env) (cond [(primitive-procedure? procedure) (apply (primitive-procedure-the-proc procedure) arguments)] [(proc? procedure)... ] [else (error 'eval-app... )])) 61

62 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Auswertung in einer Umgebung Auswertung von primitiven Operationen apply ist eine primitive Operation, mit der die Parameter einer Operation als Liste übergeben werden können (apply + (list 1 2 3)) à ( ) (apply f (list a b)) à (f a b) Wir brauchen apply, weil wir nicht wissen, wie viele Argumente die primitive Prozedur benötigt 62

63 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Auswertung in einer Umgebung Auswertung von definierten Operationen ;; eval-app: val (listof exp) env -> val (define (eval-app procedure arguments env) (cond [(primitive-procedure? procedure)...] [(proc? procedure) (eval vgl. Auswertungsregel (subst für selbst-definierte (map-create Operationen (proc-parameters procedure) arguments) (proc-exp procedure)) env)] [else (error 'eval-app... )])) 63

64 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Auswertung in einer Umgebung Substitution ;; subst substitutes all occurrences of names in exp ;; that are associated with a value in a-map with ;; that value, according to the lexical scoping rules ;; subst : (mapof val) exp -> exp (define (subst a-map exp) ) Substitution wird als rekursive Funktion über Ausdrücken definiert. Fallunterscheidung je nach Typ des Ausdrucks, wie bei eval Die zu ersetzenden Namen und Werte werden in einer map übergeben 64

65 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Auswertung in einer Umgebung Variablen und selbst-auswertende Ausdrücke (define (subst a-map exp) (cond [(self-evaluating? exp) exp] [(variable? exp) (local ((define newval (map-lookup (variable-name exp) a-map))) (if (empty? newval) exp newval))] ))... Variable wird ersetzt, falls entsprechender Eintrag in Substitutionstabelle existiert 65

66 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Auswertung in einer Umgebung Substitution innerhalb von Prozeduren (define (subst a-map exp) (cond... [(proc? exp) (make-proc (proc-parameters exp) (subst Lokal mit lambda gebundene Namen überdecken äußere Bindungen. (map-remove-all (proc-parameters exp) a-map) (proc-exp exp)))] ))... (define (op1 x y) (local ((define op2 (x) (... x...))) (op2... x... y) )... (op1 5) 66

67 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Auswertung in einer Umgebung Substitution: if-clause?, application? (define (subst a-map exp) (cond... [(if-clause? exp) (make-if-clause (subst a-map (if-clause-predicate exp)) Ersetze in den Unterausdrücken (subst a-map (if-clause-consequent exp)) (subst a-map (if-clause-alternative exp)))] [(application? exp) (make-application (subst a-map (application-operator exp)) (map (lambda (op) (subst a-map op)) (application-operands exp)))] [else (error 'subst "Unknown expression type: ~v)])) 67

68 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket Interpreter als universelle Maschinen 68

69 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Programme als spezielle Maschinen Die factorial Maschine (define (factorial n) (if (= n 1) 1 (* (factorial (- n 1)) n))) 1 1 = 720 *! - 1 factorial Wir können factorial als Beschreibung einer Maschine verstehen, die Teile zum subtrahieren, multiplizieren und testen auf Gleichheit enthält. 69

70 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Programme als spezielle Maschinen Die factorial Maschine (define (factorial n) (if (= n 1) 1 (* (factorial (- n 1)) n))) 1 1 = factorial *! Darüber hinaus enthält sie einen Kippschalter und eine andere factorial Maschine. 1 Die factorial Maschine ist unendlich, da sie eine andere factorial Maschine enthält. 70

71 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Programme als spezielle Maschinen Interpreter als universelle Maschine Analog können wir einen Interpreter als eine sehr spezielle Maschine ansehen, die als Eingabe die Beschreibung einer anderen Maschine erwartet. Über diese Eingabe konfiguriert sich der Interpreter selbst, so dass er die in der Eingabe beschriebene Maschine nachbildet. Beispiel: wenn wir dem Interpreter die Definition von factorial übergeben, kann er Fakultäten berechnen. 6 eval 720 (define (factorial n) (if (= n 1) 1 (* (factorial (- n 1)) n))) 71

72 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Programme als spezielle Maschinen Interpreter als universelle Maschine Unser Interpreter kann als universelle Maschine betrachtet werden. Er imitiert andere Maschinen, wenn sie als Programme beschrieben sind. 72

73 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Programme als spezielle Maschinen Interpreter als universelle Maschine Stellen Sie sich einen analogen Interpreter für elektrische Schaltkreise vor... ein Schaltkreis, der als Signal die Pläne für andere Schaltkreise empfängt, z.b. ein Filter. Basierend auf diesem Input verhält sich der Schaltkreis wie ein Filter. So ein universeller elektrischer Schaltkreis ist so komplex, dass er kaum vorstellbar ist. Dagegen ist es überraschend, wie einfach der Code des Programm-Interpreters ist. 73

74 Thema 8: Interpreter-basierte Semantik: Meta-Interpreter für ein Teil von Racket - Programme als spezielle Maschinen Programme als Daten Der Interpreter ist eine Brücke zwischen Datenobjekten, die von der Programmiersprache manipuliert werden, und der Programmiersprache selbst. Aus dem Blickwinkel des Nutzers ist die Eingabe (* x x) ein Ausdruck in der Programmiersprache, den der Interpreter ausführen soll. Aus dem Blickwinkel des Interpreter-Programms ist der Ausdruck nur eine Liste von Symbolen, *, x, und x, die nach festgelegten Regeln manipuliert werden sollen. 74

75 Thema 8: Interpreter-basierte Semantik 8.4 Normale Auswertungsreihenfolge 75

76 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge Applikative vs. Normale Auswertung Zur Erinnerung... aus T1 Applikative Auswertung: Erst Operator und alle Operanden auswerten, dann substituieren. Normale Auswertung: Operator auswerten, dann die (nicht ausgewerteten) Operanden für die formalen Argumente des Operators substituieren. Operanden werden nur bei primitiven Operationen ausgewertet. 76

77 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge Applikative vs. Normale Auswertung In T1 haben wir das Substitutionsmodell und Beispiele verwendet, um intuitiv den Unterschied zwischen den beiden Auswertungsstrategien zu erklären. Wissen Sie noch, wie sich die Strategien unterscheiden? 77

78 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge Applikative vs. normale Auswertung Wenn sie einen Wert berechnen, dann liefern beide Strategien die gleichen Werte. Wichtige Voraussetzung: Das Ergebnis hängt nicht von der Auswertungsreihenfolge ab (Konfluenz). Es gibt Sprachelemente (Zuweisungen, Ein-/ Ausgabe), die diese Eigenschaft zerstören. 78

79 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge Applikative vs. normale Auswertung Die beiden Strategien können sich erheblich in der Anzahl der benötigten Schritte unterscheiden. In zwei Fällen: Argument wird nicht benötigt Argument wird mehrfach benötigt 79

80 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge Applikative vs. normale Auswertung Argument wird nicht benötigt à normale Auswertung besser benötigt weniger Schritte/bessere Terminierungseigenschaften. (define (area-of-disk r d) (* 3.14 r r)) (area-of-disk 5 (* 5 2)) Argument wird mehrfach benötigt à applikative Auswertung besser benötigt weniger Schritte. (define (square x) (* x x)) (square (+ 3 4)) 80

81 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge Normale Auswertung im Interpreter Mit Hilfe des Interpreters können wir sehr präzise erklären, was normale Auswertungsreihenfolge ist wie sie sich von applikativer Reihenfolge unterscheidet 81

82 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge - Normale Auswertung im Interpreter Auswertung in jetzigen eval ist??? (define (eval exp env) (cond [(self-evaluating? exp) exp] [(variable? exp) (eval-var exp env)] [(if-clause? exp) (eval-if exp env)] Welche Auswertungsstrategie haben wir implementiert? [(application? exp) (eval-app (eval (application-operator exp) env) (map (lambda (expr) (eval expr env)) (application-operands exp)) env)] applikative Auswertung [else (error 'eval (format "Unknown expression type: ~v" exp))])) 82

83 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge - Normale Auswertung im Interpreter eval bei applikativer Reihenfolge (define (eval exp env) (cond [(self-evaluating? exp) exp] [(variable? exp) (eval-var exp env)] [(if-clause? exp) (eval-if exp env)] [(application? exp) (eval-app (eval (application-operator exp) env) (map (lambda (expr) (eval expr env)) (application-operands exp)) env)] Was ändert sich hier bei einer normalen Auswertungsstrategie? [else (error 'eval (format "Unknown expression type: ~v" exp))])) 83

84 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge - Normale Auswertung im Interpreter eval bei normaler Auswertung (define (eval exp env) (cond [(self-evaluating? exp) exp] [(variable? exp) (eval-var exp env)] [(if-clause? exp) (eval-if exp env)] Argumente werden nicht evaluiert... [(application? exp) (eval-app (eval (application-operator exp) env) (application-operands exp) env)] [else (error 'eval (format "Unknown expression type: ~a" exp))])) 84

85 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge - Normale Auswertung im Interpreter eval-app bei applikativer Auswertung (define (eval-app procedure arguments env) (cond [(primitive-procedure? procedure) (apply (primitive-procedure-the-proc procedure) arguments )] [(proc? procedure)... ] [else... ])) Argumente sind bereits evaluiert (in Werte reduziert)... 85

86 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge - Normale Auswertung im Interpreter eval-app bei normaler Auswertung (define (eval-app procedure arguments env) (cond [(primitive-procedure? procedure) (apply (primitive-procedure-the-proc procedure) (map (lambda (expr) (eval expr env)) arguments) )] [(proc? procedure)... ] [else... ])) Hier wird erst evaluiert, da die Auswertung sonst nicht weitergeführt werden kann. 86

87 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge - Normale Auswertung im Interpreter eval-app bei normaler Auswertung ;; eval-app: val (listof exp) env -> val (define (eval-app procedure arguments env) (cond [(primitive-procedure? procedure)...] [(proc? procedure) arguments ist eine Liste von (eval noch nicht ausgewerteten (subst Ausdrücken. In applikativer (map-create Auswertung sind sie Werte. (proc-parameters procedure) arguments) (proc-exp procedure)) env)] [else (error 'eval-app... )])) 87

88 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge - Normale Auswertung im Interpreter Substitution: Notiz Die Substitutionsprozedur enthält einen Fehler, wir können sie nicht unverändert für die normale Auswertung verwenden. Um welchen Fehler geht es? 88

89 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge - Normale Auswertung im Interpreter Substitution: Notiz Was ist das Ergebnis dieses Programms? (define testprog3 '( ( ((lambda (z x) (lambda (z) (+ z x))) 5 (+ 2 z)) 10) ) ) 89

90 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge - Normale Auswertung im Interpreter Substitution: Notiz ( ) ((lambda (z x) (lambda (z) (+ z x))) 5 (+ 2 z)) 10 ( ) (lambda (z) (+ z (+ 2 z))) 10 90

91 Thema 8: Interpreter-basierte Semantik: Normale Auswertungsreihenfolge - Normale Auswertung im Interpreter Substitution: Notiz Fehler: Wenn der Ausdruck, der eingesetzt wird, eine freie Variable enthält, kann diese durch die Substitution fälschlicherweise gebunden werden. Basisidee für eine Lösung: Vor der Substitution in einem lambda-ausdruck wird geprüft, ob einer der Parameternamen frei in einem der Ausdrücke in der Substitutionstabelle vorkommt Falls ja, wird der Parameter umbenannt 91

92 Thema 8: Interpreter-basierte Semantik 8.5 Zusammenfassung 92

93 Thema 8: Interpreter-basierte Semantik: Zusammenfassung Syntax Syntax = Vokabular und Grammatik Formale Notationen zur Festlegung der Syntax Konkrete versus Abstrakte Syntax. Abstrakte Syntax abstrahiert über bestimmte Details, wie die Begrenzungszeichen oder konkrete Schlüsselworte. Parsen liest die Zeichenkette des Programms und produziert den AST anhand der konkreten und abstrakten Syntax-Definition. 93

94 Thema 8: Interpreter-basierte Semantik: Zusammenfassung Semantik Verschiedene Formen der Semantikdefinition: Interpreter-basierte Denotationelle Semantik,... 94

95 Thema 8: Interpreter-basierte Semantik: Zusammenfassung Semantik In dem wir einen Interpreter schreiben erklären wir der Maschine die Bedeutung der Sprache und verstehen sie auch selbst besser. Jedes Programm kann als ein Interpreter für eine spezielle Domäne betrachtet werden. Basissprache versus interpretierte Sprache. Metazirkulärer Interpreter: Beide Sprachen sind gleich. 95

96 Thema 8: Interpreter-basierte Semantik: Zusammenfassung Meta-zirkulärer Interpreter für Mini-Racket Strukturen für die Darstellung der abstrakten Syntax. Programm als ein s-expresion (verschachtelte) Listen von Symbolen. Auswertung in einer Umgebung, wo Namen-Werte Bindung verwaltet werden. Anfangsumgebung: Bindungen von Namen für primitive Operationen an den entsprechenden Racket Operationen. Interpretation als Substitution von Namen mit entsprechenden Werten. 96