Prof. Dr. Max Mühlhäuser Dr. Guido Rößling Grundlagen der Informatik I Thema 4: Auswertungsreihenfolge und Lexikalisches Scoping Prof. Dr. Max Mühlhäuser Dr. Guido Rößling

Nochmal: Applikative vs. Normale Auswertungsreihenfolge SKT 04 Nochmal: Applikative vs. Normale Auswertungsreihenfolge Zur Erinnerung: Applikative Reihenfolge: Erst Operator und alle Operanden auswerten, dann substituieren Normale Reihenfolge: Operator auswerten, dann die (unausgewerteten) Operanden für die formalen Argumente des Operators substituieren Wir hatten gesagt: Die Reihenfolge der Auswertung spielt für das Ergebnis keine Rolle, wenn es ein Ergebnis gibt Diesen letzten Punkt wollen wir nun beleuchten

Nochmal: Applikative vs. normale Auswertungsreihenfolge SKT 04 Nochmal: Applikative vs. normale Auswertungsreihenfolge Beispiel: “Eigenbau” eines if-statements als Prozedur mit Hilfe von “cond” Scheint zu funktionieren: (my-if true 3 5)  3 (my-if false 3 5)  5 Betrachten wir nun folgendes Programm: Ersetzen wir nun das if durch my-if (define (my-if test then-exp else-exp) (cond (test then-exp) (else else-exp))) ;; ! : N -> N ;; computes the faculty function (define (! n) (if (zero? n) 1 (* n (! (pred n)))))

Nochmal: Applikative vs. normale Auswertungsreihenfolge SKT 04 Nochmal: Applikative vs. normale Auswertungsreihenfolge Version der Funktion mit my-if Ein Aufruf wie (! 2) terminiert nicht bei applikativer Auswertungsreihenfolge, bei normaler Reihenfolge jedoch schon Wieso? ;; ! : N -> N ;; computes the faculty function (define (! n) (my-if (zero? n) 1 (* n (! (pred n)))))

Nochmal: Applikative vs. normale Auswertungsreihenfolge SKT 04 Nochmal: Applikative vs. normale Auswertungsreihenfolge Viele Sonderformen in Scheme müssten keine Sonderformen sein, wenn Scheme die normale Auswertungsreihenfolge benutzen würde z.B. if, cond, and, or Das würde die Semantik der Sprache vereinfachen Normale Auswertungsreihenfolge ermöglicht zudem sehr elegante Programmiertechniken (z.B. “streams”) Wieso benutzt Scheme also applikative Auswertung (wie die meisten anderen Programmiersprachen)? Einige Features wie Zuweisungen oder E/A (später…) zerstören die Konfluenz (die Auswertungsreihenfolge beeinflusst das Ergebnis) In diesem Fall ist applikative Auswertungsreihenfolge vorzuziehen, weil transparenter ist, wann ein Ausdruck ausgewertet wird Es gibt allerdings moderne Techniken (z.B. sogenannte “Monaden”), die Zuweisungen, E/A etc. ermöglichen und trotzdem die Unabhängigkeit von der Ausführungsreihenfolge erhalten Das ist ein Thema der Vorlesung “Konzepte der Programmiersprachen”

Blockstruktur Wir haben gesehen, dass Hilfsprozeduren wertvoll sind SKT 04 Blockstruktur Wir haben gesehen, dass Hilfsprozeduren wertvoll sind Deren Verwendung verursacht aber auch Probleme: Wenn die Anzahl der Prozeduren zu groß wird, verliert man schnell den Überblick Jede Prozedur „kostet“ einen Namen: der Namensraum für Prozeduren wird immer kleiner Gefahr von Verwechselungen oder Namenskonflikten wächst Sehr viele Daten müssen explizit als Parameter an Hilfsprozeduren weitergegeben werden Daher gibt es die Möglichkeit, lokale Namen zu definieren und an Werte oder Prozeduren zu binden Bevor wir die Scheme Konstrukte dazu diskutieren, werden wir zunächst die bisher verwendete Untermenge von Scheme formaler definieren … To 1: Shortly discuss the value of procedural abstraction  let students discuss To 3: Tell that almost all languages have such support

Syntax & Semantik von Scheme SKT 04 Intermezzo: Syntax & Semantik von Scheme

SKT 04 Syntax Ähnlich wie die natürlichen Sprachen haben auch die Programmiersprachen ein Vokabular und eine Grammatik Das Vokabular ist eine Sammlung der „Wörter“', aus denen wir „Sätze“' in unserer Sprache bilden können. Ein Satz in einer Programmiersprache ist ein Ausdruck oder eine Funktion Die Grammatik der Sprache sagt uns, wie wir ganze Sätze aus Wörtern bilden. Der Ausdruck Syntax bezieht sich auf Vokabular und Grammatik von Programmiersprachen Thus far we have approached Scheme as if it were a spoken language. Like toddlers, we learned the vocabulary of the language, we acquired an intuitive understanding of its meaning, and we figured out some basic rules of how to compose and not to compose sentences. Truly effective communication, however, in any language -- be it natural like English or artificial like Scheme -- eventually requires a formal study of its vocabulary, its grammar, and the meaning of sentences.

Semantik Nicht alle grammatikalisch richtigen Sätze sind sinnvoll SKT 04 Semantik Nicht alle grammatikalisch richtigen Sätze sind sinnvoll Weder in Deutsch noch in Programmiersprachen. „Die Katze ist schwarz“' ist ein sinnvoller Satz. „Der Ziegel ist ein Auto“ macht wenig Sinn, auch wenn der Satz grammatikalisch richtig ist. Um herauszufinden ob ein Satz sinnvoll ist, müssen wir die Bedeutung oder die Semantik der Wörter und Sätze verstehen Für Programmiersprachen gibt es verschiedene Wege, um den Sinn von einzelnen Sätze/Ausdrücken zu erklären. Den Sinn von Scheme-Programmen diskutieren wir mit einer Erweiterung der bekannten Gesetze aus Arithmetik und Algebra (Substitutionsmodell)

Das Vokabular von Scheme (Syntax) SKT 04 Das Vokabular von Scheme (Syntax) <var> =   x | a | alon| ... <fct> area-of-disk | perimeter | ... <con>   true | false |   'a | 'doll | 'sum | ...   1 | -1 | 3/5 | 1.22 | ... <prm>   + | - | ... Vier Kategorien von Wörtern, jede durch eine Zeile definiert: Variablen <var>: Namen von Werten Funktionen <fct>: Namen von Funktionen Konstanten <con>: boolean, Symbole, numerische Konstanten Primitive Operationen <prm>: Die Grundfunktionen, die Scheme von Anfang an zur Verfügung stellt Notation: Zeilen zählen einfache Beispiele auf, getrennt durch ein „|“ Punkte bedeuten, dass es noch mehr Dinge derselben Art in der Kategorie gibt

Beginning Student Scheme: Die Grammatik (Syntax) SKT 04 Beginning Student Scheme: Die Grammatik (Syntax) <def> =   (define (<fct> <var> ...<var>) <exp>) | (define <var> <exp>) | (define-struct <var0> (<var-1> ...<var-n>)) <exp>   <var> | <con> | (<prm> <exp> ...<exp>) | (<fct> <exp> ...<exp>) | (cond [<exp> <exp>] ... [<exp> <exp>]) | (cond [<exp> <exp>] ... [else <exp>]) | (and <exp> <exp>) | (or <exp> <exp>) Zwei Kategorien von Sätzen: Definitionen (<def>) und Ausdrücke (<exp>)

Beginning Student Scheme: Die Grammatik (Syntax) SKT 04 Beginning Student Scheme: Die Grammatik (Syntax) Die Kategorie der Ausdrücke besteht aus 8 Alternativen: Variablen, Konstanten, primitive Anwendungen, (Funktions-) Anwendungen, zwei Sorten von Konditionalformen; and, or Spezialformen Die letzten 6 sind wiederum aus anderen Ausdrücken zusammengesetzt Die Schlüsselworte define, cond, and, or identifizieren Sonderformen Schlüsselworte haben keine Bedeutung. Ihre Rolle gleicht der der Interpunktion (Kommata und Semikolons in der deutschen Schrift) Schlüsselworte dürfen nicht als Namen für Variablen benutzt werden While the grammar does not dictate the use of white space between the items of sentences, we follow the convention to put at least one blank space behind each item unless an item is followed by a right parenthesis ``)''. Scheme is flexible concerning blank space, and we can replace a single blank space by many spaces, line breaks, and page breaks. The two grammar definitions describe how to form atomic sentences and compound sentences, which are sentences built from other sentences. For example, a function definition is formed by using ``('', followed by the keyword define, followed by another ``('', followed by a non-empty sequence of variables, followed by ``)'', followed by an expression, and closed by a right parenthesis ``)'' that matches the very first one. The keyword define distinguishes definitions from expressions.

Grammatik von Scheme: Beispiele SKT 04 Grammatik von Scheme: Beispiele Beispiele für Ausdrücke: 'all: Symbol, also ein Ausdruck x: jede Variable ist ein Ausdruck (f x): eine Funktionsanwendung, weil x eine Variable ist Die folgenden Sätze sind keine korrekten Ausdrücke: (f define): stimmt teilweise mit der Form einer Funktionsanwendung überein, aber es benutzt define als sei es eine Variable. (cond x): kann kein korrekter cond-Ausdruck sein, weil an zweiter Stelle eine Variable steht, und nicht ein geklammertes Paar von Ausdrücken (): Grammatik verlangt, dass nach jeder linken Klammer etwas anders kommt als eine rechte Klammer

Grammatische Terminologie SKT 04 Grammatische Terminologie Eine Definition (<def>) besteht aus: Header: Die zweite Komponente einer Definition, z.B. die nicht leere Sequenz von Variablen Parameter einer Funktion: Die Variablen, die der ersten Variable im Header folgen Body: Die Ausdruck-Komponente einer Definition Eine Anwendung besteht aus Funktion: Die erste Komponente Argumente (tatsächliche Argumente): die übrigen Komponenten Ein cond-Ausdruck besteht aus cond-Zeilen (cond-Bedingungen) die jeweils aus zwei Ausdrücken bestehen: Frage (Bedingung) und Antwort (define (<function-name> <parameter> ...<parameter>) <body>) Components of compound sentences have names. We have introduced some of these names on an informal basis; for better communication, we introduce all useful ones here (<function-name> <argument> ...<argument>) (cond (<question> <answer>) <cond-clause> ...)

Syntax des local-Ausdrucks SKT 04 Syntax des local-Ausdrucks (local ((define PI 3)) (* PI 5 5)) <exp> = ... | ( local (<def-1> ...<def-n>) <exp> ) Local Definition: Parametrisierte Sequenz nach dem Schlüsselwort local Definitionen werden „LOCALLY DEFINED“ Variablen, Funktionen oder Strukturen genannt. Definitionen in dem Definitions-Fenster werden „TOP-LEVEL DEFINITIONS“ genannt. Jeder Name kann höchstens einmal auf der linken Seite vorkommen, sei es in einer Variablen- oder Funktionsdefinition. Der Ausdruck einer Definition wird der RIGHT-HAND SIDE Ausdruck genannt. Body: Ausdruck (<exp>) nach den Definitionen The keyword local distinguishes this new class of expressions from other expressions, just as cond distinguishes conditional expressions from applications. The purpose of a local-expression is to define a variable, a function, or a structure for the evaluation of the body expression. Outside of the local-expression the definitions have no effect. Consider the following expression: (local ((define (f x) exp-1)) exp) It defines the function f during the evaluation of exp. The result of exp is the result of the entire local-expression. Similarly, (local ((define PI 3)) exp) temporarily lets the variable PI stand for 3 during the evaluation of exp.

Syntax & Semantik von Scheme SKT 04 Ende Intermezzo: Syntax & Semantik von Scheme

Blockstruktur: Beispiel SKT 04 Blockstruktur: Beispiel (local ( (define (f x) (+ x 5)) (define (g alon) (cond [(empty? alon) empty] [else (cons (f (first alon)) (g (rest alon)))]))) (g (list 1 2 3)) ) LOCAL DEFINITION BODY Zwei lokal definierte Prozeduren: f und g g ruft f auf Body ruft g auf

Eigenschaften von lokalen Definitionen SKT 04 Eigenschaften von lokalen Definitionen Der Rumpf der lokalen Definitionen kann auf weiter außen definierte Namen zugreifen Hilfsprozedur plus-y-sqr kann auf y zugreifen Bei nicht-lokaler Definition müsste y stets explizit übergeben werden Lokale Definitionen können also Parameter einsparen Von außen sind die lokal definierten Namen nicht sichtbar An anderen Stellen könnte lokal noch mal derselbe Name definiert werden (define (f x y z) (local ( (define (square n) (* n n)) (define (plus-y-sqr q) (square (+ q y)))) (+ (plus-y-sqr x) (plus-y-sqr z)))) (x+y)² + (z+y)²

Eigenschaften von lokalen Definitionen SKT 04 Eigenschaften von lokalen Definitionen Ein local Konstrukt ist ein Ausdruck, und daher universell einsetzbar z.B. als Operator, Operand oder Rumpf einer Prozedur Abgeschlossenheitseigenschaft Insbesondere können lokale Definitionen beliebig geschachtelt werden (sogenannte Blockstruktur) z.B. im Rumpf einer lokalen Definition Skalierbarkeit (define (f x y z) (local ( (define (plus-y-sqr q) (define (square n) (* n n))) (square (+ q y))))) (+ (plus-y-sqr x) (plus-y-sqr z)))) (x+y)² + (z+y)²

Eigenschaften von lokalen Definitionen SKT 04 Eigenschaften von lokalen Definitionen Eine wichtige Eigenschaft lokaler Definitionen ist lexikalisches Scoping Scoping ist die Strategie, nach der ein Name einer Definition zugeordnet wird Lexikalisches Scoping bedeutet, dass immer die in der Schachtelungsstruktur nächste Definition benutzt wird So können wir den Parameter von square auch z nennen Trotzdem wird z im Rumpf von square nicht mit dem Parameter z von f verwechselt Überdeckt äußeres z innerhalb von square (define (f x y z) (local ( (define (square z) (* z z)) (define (plus-y-sqr q) (square (+ q y)))) (+ (plus-y-sqr x) (plus-y-sqr z)))) (x+y)² + (z+y)²

Lexikalisches Scoping SKT 04 Lexikalisches Scoping Um lexikalisches Scoping zu verstehen, ist es wichtig, zwischen Namensbindungen, gebundenen Namen und freien Namen zu unterscheiden „frei“ und „gebunden“ sind immer relativ zu einem Ausdruck Namensbindung (local ( (define (square x) (* x x)) (define (ge q) (square (+ q y)))) (+ (ge x) (ge z)))) define ergeben Namensbindung damit sind einige namen gebunden beachte: g ist eine funktion ! gebundener Name freier Name

Lexikalisches Scoping SKT 04 Lexikalisches Scoping Der Scope einer Namensbindung ist der textuelle Bereich, in dem sich ein Auftreten des Namens auf diese Namensbindung bezieht Top-Level Definitionen haben globalen Scope Der Scope eines Prozedurparameters ist der Körper der Prozedur Der Scope einer lokalen Definition ist der Ausdruck (letzter Operand) in der local Definition Wie wir gesehen haben, kann es „Löcher“ im Scope einer Namensbindung geben Durch Überdeckung der Namensbindung durch eine andere Namensbindung desselben Namens

SKT 04 Testen Sie lexikalisches Scoping mit dem „Check Syntax“ Feature von DrScheme

Zur Erinnerung: Auswertungsregel für Prozeduren SKT 04 Zur Erinnerung: Auswertungsregel für Prozeduren Anwendungsregel für Prozeduren Die Prozedur ist eine primitive Prozedur  führe die entsprechenden Maschineninstruktionen aus. Die Prozedur ist eine zusammengesetzte Prozedur Werte den Rumpf der Prozedur aus Ersetze dabei jeden formalen Parameter mit dem entsprechenden aktuellen Parameterwert, der bei der Anwendung angegeben wird. (define (f x ) (* x x)) (f 5 )

Ersetzung der Parameter und Lexikalischer Scope SKT 04 Ersetzung der Parameter und Lexikalischer Scope Bei der Ersetzung der Parameter durch die aktuellen Werte darf nicht einfach blind ersetzt werden Nur das Auftreten der Parameternamen im Scope der Parameterdefinition darf ersetzt werden! Genauer: Die Vorkommen des Namens, die im Prozedurkörper frei sind, müssen ersetzt werden Beispiel: Keine Ersetzung von x durch 2 in square Kein freies Vorkommen von x in square (define (f x y z) (local ( (define (square x) (* x x)) (define (plus-y-sqr q) (square (+ q y)))) (+ (plus-y-sqr x) (plus-y-sqr z)))) (f 2 3 4) 

Auswertung von local Blöcken im Substitutionsmodell SKT 04 Auswertung von local Blöcken im Substitutionsmodell Wir müssen unser Substitutionsmodell erweitern, um lokale Blöcke auswerten zu können Wir haben bisher keine Regel für lokale Blöcke Idee: Lokale Definitionen werden auf Top-Level “gezogen” Bei diesem Prozess müssen “neue” Namen vergeben werden Er muss bei jeder Auswertung der local Definition gemacht werden Kann nicht statisch erfolgen

Auswertung von local Blöcken: Beispiel SKT 04 Auswertung von local Blöcken: Beispiel (define y 10) (+ y (local ((define y 10) (define z (+ y y))) z)) Schritt 1: Umbenennung der lokalen Namen mit “neuen” Namen (define y 10) (+ y (local ((define y1 10) (define z1 (+ y1 y1))) z1)) Schritt 2: Herausziehen der lokalen Definitionen auf die oberste Ebene (define y 10) (define y1 10) (define z1 (+ y1 y1)) (+ y z1) Die weitere Auswertung erfolgt nach dem bisherigen Substitutionsmodell

Auswertung von local Blöcken SKT 04 Auswertung von local Blöcken Wieso ist es wichtig, dass die lokalen Definitionen bei jeder Auswertung neu (mit neuen Namen) auf die Top-Level Ebene gezogen werden? Zur Veranschaulichung verfolgen Sie die Auswertung des folgenden Programms mit dem DrScheme Stepper: (define (fac n) (local ((define m (- n 1))) (if (zero? n) 1 (* n (fac m))))) (fac 5)

Benutzung von local Richtlinien für die Benutzung von local: SKT 04 Benutzung von local Richtlinien für die Benutzung von local: Wenn Sie bei der Entwicklung einer Prozedur nach dem Designrezept feststellen, dass Sie Hilfsprozeduren benötigen, die sie lediglich innerhalb der zu schreibenden Prozedur benötigen, definieren Sie diese auch nur innerhalb eines local Blocks. Nutzen Sie aus, dass Sie innerhalb des local Blocks Zugriff auf lexikalisch weiter außen liegende Namen (z.B. Prozedurparameter) haben. Wenn Sie innerhalb eines Prozedurkörpers einen Wert mehrfach ausrechnen, definieren Sie einen lokalen Namen mit diesem Wert und benutzen ihn an allen Stellen, wo sie diesen Wert zuvor berechneten.

Benutzung von local: Beispiel SKT 04 Benutzung von local: Beispiel (define (make-rat n d) (make-xy (/ n (gcd n d)) (/ d (gcd n d)))) (define (make-rat n d) (local ((define t (gcd n d))) (make-xy (/ n t) (/ d t)))) die 2. variante sieht zwar komplizierter aus - spart aber rechenaufwand… (sollte eigentlicher ein compiler fuer sie tun…;-)