Wir setzen fort mit den Sachen zur Umgebung. Die Umgebung
spielt hier eine wichtige Rolle, weil sie das darstellt,
worauf sie uns in Reckett immer beziehen,
wo wir Werte und Bindungen immer haben.
Das war jetzt auf der Folie 46 zunächst erst mal hier
die dynamische Umgebung. Ja, das ist,
hier werden Namensbindungen gespeichert, hierfür gelten die und in diesen
Umgebungen können wir jeweils den Wert von Variablen ermitteln
Wie schon gesagt, die Namensbindung werden da drin gespeichert.
Und das wird als Sequenz gespeichert. Die Abbildung von Bezeichnern
zu Werten, das war ja diese Bindung.
Und damit ist der Kontext auch gegeben. Wir verwenden jetzt hier
dieses Zuweisungssymbol, das ist kein Record-Symbol. Und das ist das Symbol,
damit wir hier deutlich machen, welche Bindungen existieren denn zu diesem Zeitpunkt?
Beispiel, wir können eine leere Umgebung haben. Und wenn wir mit der leeren Umgebung starten,
dann haben wir können wir zum Beispiel dem X,
das X-Binden an den Wert dieses Ausdrucks,
dieser Ausdruck wird ausgewertet, zu drei,
das kriegen sie jetzt mittlerweile schon, denke ich, hin.
Also plus, und dann kommen zwei Argumente, so,
und damit ist das auf die drei zugewiesen.
Ja, ist eine Sequenz von Bindungen. Ja, die
haben dann die drei noch zusätzlich. Jetzt würden wir noch,
zum Beispiel noch einen weiteren, eine weitere Bindung machen.
Wir binden das Y an das Produkt von vier und X.
Das können sie sich unschwer ausrechnen.
Das ist die zwölf. Also wir binden das Y an
die zwölf und wir haben X an die drei gebunden
Dann können wir noch eine Differenz zum Beispiel und dem Namen DIF
, können wir noch eine Differenz hier binden.
Und dann hätten wir die Differenz zwischen den beiden,
zwischen 12 und 3 ist 9 und an das Wort DIF
binden wir dann in den Bezeichnertif.
Binden wir dann die Neuen. Ja, so,
das könnten wir auch noch Test daran binden und hier nehmen wir das kleinere Symbol als Operation,
als Funktion und die zwei Argumente ist X und DIF.
Wir wissen, X hat den Wert. Drei,
Diff hat den Wert, 9 und ist nun
drei kleiner als
Moment, bin ich jetzt richtig? Genau. Drei ist
kleiner, genau. Drei ist leider als neun.
Mal selber schon mal schauen. Ja, dann ergibt sich
hieraus True und wir werfen das True dem Test zu.
Also sie sehen schon hier diese Sequenz, die ist in der Umgebung vorhanden.
Die sehen wir nicht so. Ich schreibe das hier jetzt
so aufgeschrieben, damit sie sich das zuwenden.
Also deswegen hier nochmal für diejenigen, die nur die Folie sich ausgedruckt haben.
Ja, das ist nur für die Bindung.
Das ist kein Rekord-Symbol. Ja, so und dann
können wir natürlich entsprechend weitermachen. Das Letzte. Lassen wir
gleich mal als Quiz. Was kommt denn da für sie
Wenn wir Funktionen aufrufen, sie kamen jetzt schon immer,
das erste, die Operation,
die Funktion ist und dann kommen die Argumente,
dann geht das System so vor, dass die Werte ausgewertet werden.
So, wenn wir jetzt, wir werden jeweils,
wir nehmen diese, was hier steht,
nimmt die Laufzeitumgebung als das System als wert oder als Ausdruck und wertet das aus.
Jeweils wird der Funktionsabschluss ausgewertet und dann wird geschaut,
was für Bindungen existieren denn zu diesem Zeitpunkt,
wobei die neuesten Bindungen immer die sind, die da sind.
Und dann schauen wir mal, ob diese Auswertung möglich ist und
wenn die nicht möglich ist, gibt es einen Fehler.
Wir schauen uns das jetzt mal im Beispiel an.
Und zwar haben wir hier zunächst erstmal eine Funktion, Lamdar von X,
Das ist hier das erste Argument und danach kommt hier so eine Multiplikation, x mal x.
Und das ist etwas, was wir gleich noch weiter behandeln werden.
Also wir definieren hier etwas, Lambda ist eine Funktion der höheren Ordnung.
Aber sie hatten ja schon gehört, Lambda Kalkül,
also irgendwas wissen sie jetzt schon, hat es damit zu tun.
Wir definieren hier eine Funktion, dieser Ausdruck enthält zunächst
erstmal hier eine Funktion, nämlich Lambda.
Und dann einen Operanten, x und
noch einen Operanten
Diesen Ausdruck. Ja, so. Und hier hinten haben wir einen zweiten Ausdruck,
der ist wiederum ein Operant hier, ein Argument.
Und wir werten den aus und werten den aus.
Und das wird zunächst erstmal ausgewertet, wenn die Argumente definiert sind.
Ja, und wir müssen das X erstmal irgendwo hinbinden,
wenn wir das X nicht haben,
können wir erstmal das X nur so stehen lassen.
Ja, und die Zahlen, das ist ganz klar,
die werden, die bleiben, sind Literale,
die sind sofort auswertbar, das ist die vier.
Und dann steht das hier da und dann
haben wir eine
So, wir haben jetzt schon eine ganze Menge über Typen geredet und über Funktionen.
Aber ich möchte sich darauf hinweisen, es geht nicht alles.
Ich hatte schon gelegentlich über Fehlermeldungen gesprochen. Also wir schauen
mal an, was für Sachen denn gehen. Ja,
also ich kann durchaus schreiben, die feinen Apfel 1,
dann weiß ich, dem Apfel eine Zahl zu.
Das Ganze ist eine Zahl. Ja,
hier kommt erstmalig so ein höherer Ausdruck,
auch das einzige Mal, wo wir das jetzt haben,
wir gehen nicht so weit.
Wieso gebe ich eine Liste an mit so einem Hochkomma?
Und da habe ich eine Liste und Sie wissen ja,
in Listen können unterschiedliche Elemente drin sein.
Wir haben hier eine 1,
eine 2 und Apfel und Apfel
ist ja gebunden an die
So, jetzt können wir noch was weiter definieren.
Banane, ja, das ist ein Wahrheitswert.
True geben wir hier an. Und jetzt können wir durchaus
versuchen, hier eine Operation auszuführen, eine Funktion auszuführen.
Zum Beispiel die Addition von Äpfeln und Birnen.
Sie wissen, dass Äpfel und Birnen nicht das Gleiche ist.
Und tatsächlich sagt uns Recke dann hier, also liebe Leute,
das erste Argument war ja irgendwie eine Zahl, Number.
Und der zweite, ich erfordere, möchte dann bitte
auch da eine Zahl haben. Sonst geht das nicht.
Ja, so, also das ist die Fehlermeldung,
die ich hier bekomme.
Soweit dazu
Es gibt, wie gesagt, noch viel mehr.
Wir haben jetzt bis jetzt nur die elementaren Typen besprochen.
Und das bleibt jetzt hier alles mit Keks im Sinne von,
bitte beschäftigen Sie sich bei Interesse gerne selbst drüber.
Wir werden es nicht in der Prüfung von Ihnen abfragen,
was da alles für Operationen möglich sind.
Wir bringen jetzt gleich noch ein paar Beispiele von den höheren Sachen.
Aber das war es dann auch schon.
Wir können leider nicht viel weiter gehen hier.
Zunächst erstmal haben wir strukturierte Typen. Das sind eben solche Sachen,
wie sie die aus anderen Programmiersprachen auch kennen.
Listenmengen, Zeichenkette. Dann, und das ist jetzt
das ganz Besondere, wir haben einen Funktionstypen.
Ja, wir können also
Funktionen angeben
Visinus-Kursinus-Wurzel und so weiter,
aus dem Typ gleich die bildenden Zahlen auf Zahlen ab,
aber es gibt auch genauso Funktionen, die mit Listen arbeiten,
die mit Charakteren arbeiten oder sowas.
Es gibt auch Pullymorphie, das heißt,
es gibt Objekte, die unterschiedliche Typen annehmen können.
Zum Beispiel die Lehrerliste kann unterschiedliche Typen annehmen und dann gibt
es auch noch generische Typen, da sind strukturgleiche Datentypen.
Auf alle diese Sachen, ich nenne die nur mal,
gehen wir jetzt nicht weiter ein. Jetzt kommen wir zu
diesem Land da, wir haben die Möglichkeit, Funktionen zu definieren.
Wir hatten es ja eben schon im Beispiel,
Wir können jetzt hier zum Beispiel Funktionen definieren,
indem wir sie, es ist wieder diese Bindung,
wir bilden, binden die und machen das für die aktuelle Umgebung.
Das ist, dann bezeichnet man dann als Funktionsabschluss,
wenn Sie also weiterlesen, über Recket.
Aber funktionale Programmierung werden Sie auf Closure stoßen. Closure gibt
es in Java auch, da bildet man das nach.
Und diese Funktionsdefinition ist erstmal nur die neue Funktion,
da wird noch nicht gleich was ausgewertet.
Das war so ähnlich bei dem Beispiel 2 zurück.
Ich gehe mal dahin
Nein, genau das hier. Ja,
also das wird zu dem Zeitpunkt hier noch nicht gleich ausgewertet.
Ich hatte das eben ein bisschen in ein kleines bisschen unterschlagen,
um nicht gleich zu viel zu sagen.
Jetzt sehen wir das. Nein, hier waren wir.
Genau. Und die Funktionsdefinition selber ist ein Ausdruck,
die kann ich so weitergeben. Ja, und das ist
das Besondere bei funktionalen Programmiersprachen. Das ist auch der Punkt,
den wir dann gerne immer verwenden wollen, wo die Stärke davon ist.
Dieses Funktionen geht tatsächlich auch an Namen zu binden.
Ja, und damit ist es das, wo sie eigentlich
etwas weitergeben können. Ja, das ist jetzt das,
was Frage 9
auch erfragt
Ja, also wie kann man eine Umgebung verwenden,
um eine Funktion weiterzugeben, um sie bereitzustellen, also in einer aktuellen,
was müssen wir hier, genau hier, in einer aktuellen Umgebung,
kann ich einen Namen definieren und den Namen verwenden, um eine Funktion weiterzugeben.
Ja, und das könnte ich auf diese Weise machen,
zum Beispiel hier, das Quadrat, ja,
indem ich diese Funktion mit dem Namen Quadrat gebe und dann habe ich ab dem Zeitpunkt die Möglichkeit,
solche Und hier steht dabei,
es gibt ein Argument dabei und dieses Argument kann ich hier,
das kann ich dann in Süßer Form verwenden,
ab dem Zeitpunkt, wo ich es definiert habe.
In Reckett funktioniert, gibt es diese Definition im oberen Fenster
jeweils. So, jetzt noch etwas kurz zu den,
ganz abschließend, zu den höherwertigen Sachen, also die Elemente.
Die Liste besteht so ähnlich wie das in anderen Programmiersprachen.
Auch ist immer das erste Element und der Rest,
der Rumpf. Und wir starten mit einer leeren Liste,
die können wir so bezeichnen,
App,
Oder mit diesem Hochkomma, der das als Literalbezirk kennzeichnet,
hochkomma und Klammeraufklammer zu, ist dann die Lehrerliste.
Wir können hier konkatinieren, etwas dranhängen,
das ist die Funktion Cons, die ein weiteres Element hinzufügt.
Oder wir können auch das zweite Element, kann auch eine Liste sein.
Soweit dazu, wir haben ein kleines Beispiel hier, Also,
wenn wir mit der Lernliste starten und da Karl dranhängen,
dann ist der Meerkraut und die Lehrerliste.
Und wenn wir da noch rosa dranhängen, dann haben wir
rosa Akkrall und die Lehrerliste und in der Klara dranhängen,
dann sieht das halt so aus.
Wichtig ist hier für uns, das ist ja farblich gekennzeichnet,
das sind separate Listen.
Wir können auch eine längere Liste machen,
das würde auch gehen
Soweit. Dazu und als letzten Punkt Funktionen höhere Ordnung.
Das ist ja das, wo wir eigentlich hinwollen.
Wir wollen Funktionen weitergeben. Und das ist leider der Punkt,
wo wir mit dieser Veranstaltung auch dann aufhören.
Die Funktionen können in der funktionalen Programmiersprache so verwendet werden,
wie in Imperativen eben nur Werte. Wir können die Funktionen weitergeben.
Wir können Funktionen benutzen als Argument an einer anderen Funktion.
Wir können die Funktionen als Ergebnis erhalten. Wir können Funktionen
in einer Liste aufführen und damit können wir eben sehr flexibel
mal je nach Situation etwas tun, was wir woanders auch brauchen.
Das ist der Punkt
Was wir Ihnen bei den Werkzeugklassen genannt hatten,
wo der Lamda-Kalkulator ganz gut funktionieren kann.
Wie gesagt, das kann man in Javan nachbilden,
aber sie sollten verstanden haben, wie es im Original funktioniert.
Deswegen gibt es diesen Teil funktionale Programmierung. Und diese Funktion
höhere Ordnung, die haben dann Arbeiten mit Funktionen.
Soweit ihr zwei Vertreter. Der erste Vertreter ist die Map-Funktion
. Das ist etwas sehr, sehr Mächtiges.
Also wenn Sie es nicht gleich komplett verstehen beim ersten Versuch,
versuchen Sie es mal aus.
Es gibt eine ganze Menge Beispiele dazu.
Das ist eine Funktion, die selber eine Funktion als
Argument erhält
Das ist vordefiniert. Wir schauen uns das mit Inkrement mal an hier.
Das ist eine Funktion, die jetzt etwas hier jeweils erhöht.
Ja, und wir wenden das auf eine Liste an.
Ja, und zunächst wird es erstmal so definiert,
dass wir das Inkrement X, ist X und 1. Hier,
sehe ich gerade, es fehlt ein Leerzeichen.
Also das muss plus Leerzeichen X, Leerzeichen 1 heißen.
Ja, und dann wählen wir das,
führen wir das auf die Liste 1, 2,
3, 4 an.
Und da kommt 2, 3,
4,
5 raus
Hier ist das nochmal grafisch dargestellt. Also dieser Map,
diese Map-Funktion, ermöglicht es, eine andere Funktion mehrfach anzuwenden.
Das ist ein Beispiel für eine höherwertige Funktion, höhere Ordnung und das
ist etwas, wo wir wirklich etwas sehr Leistungsfähiges haben.
Wenn Sie sowas in Java haben wollen,
müssten Sie in Iterationen basteln und das ist auch nicht so richtig klar,
wie machen Sie das mit Argumenten und Parameter als Argumente,
Funktionen als Parameter,
das würde dann
ganz schwierig werden
Und die zweite Sache und damit auch letzte Sache ist,
dass die Filterfunktion, die erhält eine Funktion als Argument.
Und wir können jetzt, das heißt deswegen Filter,
weil es so eine Liste dann dadurch zum Beispiel reduziert wird.
Wir haben hier die Funktion. Evan,
also geradzahlige Werte, wollen wir hier nur haben.
Und wir wenden das auf die Funktion auf eine Liste an.
Und es kommt raus, dass nur noch die Elemente drin sind,
die True ergeben haben bei der Auswertung.
Hier, Evan ist definiert als eine gerade Zahl
Das kann man mit dem Modul-Operator ja ganz gut machen.
Ich hoffe, Sie kennen den noch, wenn ich erklären wir
es gern nochmal weiter. Das ist der Rest einer Division,
also der Rest der Division durch zwei Winter Null ist,
dann war es die durch zwei teilbar.
Das ist das, was hier steht. Dann ist es nämlich
eine gerade Zahl und das wird diesem Even zugewiesen. Und wir filtern,
dass Even, indem wir Even auf die Liste 1,
2, 3, 4 anwenden und dann kommt eine Liste zurück,
die 2 und die 4 enthält.
Soweit. Dazu Wir haben Ihnen jetzt einen kleinen Geschmack gegeben,
wie das Ganze aussehen kann. Ich möchte Sie ermutigen,
versuchen Sie damit. Spielen Sie erst mal ein bisschen damit rum.
Schauen Sie sich weitere Sachen an, schauen Sie sich Tutorials dazu an,
funktionale Programmierung, ist etwas sehr Mächtiges.
Und Sie können damit sehr effizient Datenverarbeitung erreichen.
Und wir kommen noch mal zu diesem Punkt,
was wir vorher beim Abschnitt Ende des letzten Abschnittes gesagt hatten.
Nein, wir wollten eins weitergehen. Ja,
diese Kombination zwischen beiden, nämlich die Daten,
eine eigentliche Datenverarbeitung als funktionalen Kern zu machen
Und das, was wir gui-mäßig außenrum haben,
was fachliche Regeln sind oder sowas, das könnte man dann imperativ programmieren.
Vielleicht kann man die fachlichen Regeln in manchen Fällen auch
sogar funktional programmieren, weil sie die Datenverarbeitung darstellen.
Somit möchte ich Ihnen das mitgeben. Das war das Ende der Lehrveranstaltung,
Softwareentwicklung. Zwei, danke, dass Sie durchgehalten haben.
Ich wünsche Ihnen viel Erfolg für die weiteren Benutzung unserer Inhalte,
die sind Basis für ganz vieles,
was Sie im Informatikstudium oder Informatikfächern noch brauchen werden und natürlich
erstmal viel Erfolg bei der Prüfung