Einleitung

Programmierung im Studium bisher

Worin besteht jetzt der Fortschritt?

Formen der deklarativen Programmierung

Definition: Funktionale Programmierung

Softwaretechnische Vorteile

…der funktionalen Programmierung

Beispiel Spezifikation/Test

import Test.LeanCheck

append :: forall t . [t] -> [t] -> [t]
append [] y = y
append (h : t) y = h : (append t y)

associative f = 
   \ x y z -> f x (f y z) == f (f x y) z
commutative f = \ x y -> ...

test = check
  (associative (append::[Bool]->[Bool]->[Bool]))

Übung: Kommutativität (formulieren und testen)

Beispiel Verifikation

app :: forall t . [t] -> [t] -> [t]
app [] y = y
app (h : t) y = h : (app t y)

Lemma: app x (app y z) .=. app (app x y) z

Proof by induction on List x
  Case []
    To show: app [] (app y z) .=. app (app [] y) z
  Case h:t
    To show: app (h:t) (app y z) .=. app (app (h:t) y) z
    IH: app t (app y z) .=. app (app t y) z

CYP https://github.com/noschinl/cyp,

ist vereinfachte Version
von Isabelle https://isabelle.in.tum.de/

Beispiel Parallelisierung (Haskell)

Klassische Implementierung von Mergesort

sort :: Ord a => [a] -> [a]
sort [] = [] ; sort [x] = [x]
sort xs =  let ( left,right ) = split xs
               sleft  = sort left  
               sright = sort right 
           in  merge sleft sright

wird parallelisiert durch Annotationen:

  sleft  = sort left  
              `using` rpar `dot` spineList
  sright = sort right `using` spineList

vgl. http://thread.gmane.org/gmane.comp.lang.haskell.parallel/181/focus=202

Beispiel Parallelisierung (C#, PLINQ)

vgl. Introduction to PLINQ

https://msdn.microsoft.com/en-us/library/dd997425(v=vs.110).aspx

Softwaretechnische Vorteile

…der statischen Typisierung

The language in which you write profoundly affects the design of programs written in that language.

For example, in the OO world, many people use UML to sketch a design. In Haskell or ML, one writes type signatures instead. Much of the initial design phase of a functional program consists of writing type definitions.

Unlike UML, though, all this design is incorporated in the final product, and is machine-checked throughout.

Simon Peyton Jones, in: Masterminds of Programing, 2009;

http://shop.oreilly.com/product/9780596515171.do

Deklarative Programmierung in der Lehre

Beziehungen zu weiteren LV: Voraussetzungen

Anwendungen:

Konzepte und Sprachen

Funktionale Programmierung ist ein Konzept. Realisierungen:

Die Erkenntnisse sind sprachunabhängig.

Gliederung der Vorlesung

Softwaretechnische Aspekte

Literatur (allgemein)

Literatur (speziell diese VL)

Alternative Quellen

Organisation der LV

Übungen

Aufgaben (allgemeines)

Aufgaben

(im SS 22: Aufgaben 3 für KW 15, Aufgabe 2 für KW 16)

  1. zu: E. W. Dijkstra: Answers to Questions from Students of Software Engineering (Austin, 2000) (EWD 1035)

    • putting the cart before the horse

      • übersetzen Sie wörtlich ins Deutsche,

      • geben Sie eine entsprechende idiomatische Redewendung in Ihrer Muttersprache an,

      • wofür stehen cart und horse hier konkret?

  2. sind die empfohlenen exakten Techniken der Programmierung für große Systeme anwendbar?

    Erklären Sie lengths of …grow not much more than linear with the lengths of ….

    • Welche Längen werden hier verglichen?

    Modellieren Sie das System als Graph, die Knoten sind die Komponenten, die Kanten sind deren Beziehungen (direkte Abhängigkeiten).

    • Welches asymptotische Wachstum ist bei undisziplinierter Entwicklung des Systems zu befürchten?

    • Welche Graph-Eigenschaft impliziert den linearen Zusammenhang?

    • Wie gestaltet man den System-Entwurf, so daß diese Eigenschaft tatsächlich gilt? Welchen Nutzen hat das für Entwicklung und Wartung?

  3. Über ein Monoid \((M,\circ, 1)\) mit Elementen \(a, b\in M\) (sowie eventuell weiteren) ist bekannt: \(a^2= b^2 = (ab)^2 = 1\).

    Dabei ist \(ab\) eine Abkürzung für \(a\circ b\) und \(a^2\) für \(aa\), usw.

    • Geben Sie ein Modell mit \(1\neq a\neq b\neq 1\) an.

    • Überprüfen Sie \(ab = ba\) in Ihrem Modell.

    • Leiten Sie \(ab=ba\) aus den Monoid-Axiomen und gegebenen Gleichungen ab.

    Das ist eine Übung zur Wiederholung der Konzepte abstrakter und konkreter Datentyp sowie Spezifikation.

  4. im Rechnerpool live vorführen:

    • ein Terminal öffnen

    • ghci starten (in der aktuellen Version), Fakultät von 100 ausrechnen

    • Datei F.hs mit Texteditor anlegen und öffnen, Quelltext f = ... (Ausdruck mit Wert 100!) schreiben, diese Datei in ghci laden, f auswerten

    Dabei wg. Projektion an die Wand:

    Schrift 1. groß genug und 2. schwarz auf weiß.

    Vorher Bildschirm(hintergrund) aufräumen, so daß bei Projektion keine personenbezogenen Daten sichtbar werden. Beispiel: export PS1="$ " ändert den Shell-Prompt (versteckt den Benutzernamen).

    Wer eigenen Rechner im Pool benutzt:

    • Aufgaben wie oben und

    • ssh-Login auf einen Rechner des Pools

      (damit wird die Ausrede GHC (usw.) geht auf meinem Rechner nicht hinfällig)

    • ssh-Login oder remote-Desktop-Zugriff von einem Rechner des Pools auf Ihren Rechner (damit das projiziert werden kann, ohne den Beamer umzustöpseln)

    (falls das alles zu umständlich ist, dann eben doch einen Pool-Rechner benutzen)

  5. welcher Typ ist zu erwarten für die Funktion,

    • (wurde bereits in der Übung behandlelt) die das Spiegelbild einer Zeichenkette berechnet?

    • die die Liste aller (durch Leerzeichen getrennten) Wörter einer Zeichenkette berechnet?

      f "foo bar" = [ "foo", "bar" ]

    Suchen Sie nach Funktionen dieses Typs mit https://www.haskell.org/hoogle/, erklären Sie einige der Resultate, welches davon ist das passende, rufen Sie diese Funktion auf (in ghci).

Daten

Wiederholung: Terme

Beispiele: Signatur, Terme

Abmessungen von Termen

Induktion über Termaufbau (Beispiel)

Algebraische Datentypen (benannte Notation)

Algebraische Datentypen (positionelle Not.)

Datentyp mit mehreren Konstruktoren

Mehrsortige Signaturen

Bsp.: \(S=\{Z,B\}, \Sigma=\{0 \mapsto ([],Z), p \mapsto ([Z,Z],Z),\) \(e\mapsto ([Z,Z],B), a\mapsto([B,B],B)\}\).

Rekursive Datentypen

Daten mit Baum-Struktur

Übung Terme

Hausaufgaben

SS 22: Aufgaben 2, 5 für KW 15; Aufgaben 3, 4 für KW 16.

  1. autotool-Aufgabe 14-1

    Allgemeine Hinweise zur Bearbeitung von Haskell-Lückentext-Aufgaben:

    • Schreiben Sie den angezeigten Quelltext (vollständig! ohne zusätzliche Leerzeichen am Zeilenanfang!) in eine Datei mit Endung .hs, starten Sie ghci mit diesem Dateinamen als Argument

    • ändern Sie den Quelltext: ersetzen Sie undefined durch einen geeigneten Ausdruck, hier z.B.

      solution = S.fromList [ False, G ]

      im Editor speichern, in ghci neu laden (:r)

    • reparieren Sie Typfehler, werten Sie geeignete Terme aus, hier z.B. S.size solution

    • werten Sie test aus, wenn test den Wert True ergibt, dann tragen Sie die Lösung in autotool ein.

  2. Geben Sie einen Typ \(T\) (eine data-Deklaration) an, der alle Terme der einsortigen Signatur \(\Sigma=\{(E/0, F/2, G/3)\}\) enthält.

    Konstruieren Sie Elemente dieses Typs.

    Geben Sie \(t\in\operatorname{Term}(\Sigma)\) an mit

    • \(\operatorname{\textsf {height}}(t)=2\) und \(|t|\) möglichst klein

    • \(\operatorname{\textsf {height}}(t)=2\) und \(|t|\) möglichst groß

  3. Geben Sie einen Typ (eine data-Deklaration) mit genau 91 Elementen an. Sie können andere Data-Deklarationen benutzen (wie in autotool-Aufgabe). Minimieren Sie die Gesamtzahl aller deklarierten Konstruktoren.

  4. Beweisen Sie \(\forall \Sigma: \forall t\in\operatorname{Term}(\Sigma): \operatorname{\textsf {height}}(t) \le |t|-1\).

    durch Induktion über den Term-Aufbau.

    • Induktions-Anfang: \(t=f()\) (nullstelliges Symbol \(f\))

    • Induktions-Schritt:

      \(t=f(t_1,\dots,t_k)\) (\(k\)-stelliges Symbol \(f\), für \(k>0\))

      dabei Induktions-Voraussetzung: die Behauptung gilt für \(t_1,\ldots,t_k\).

      Induktions-Behauptung: …für \(t\).

    Für welche Terme \(t\) gilt Gleichheit? Wo sieht man das im Beweis?

  5. wieviele Elemente des Datentyps data T = L | B T T haben …

    • die Größe 9

    • die Größe \(\le 9\)

    • die Höhe \(0, 1, 2, 3, \dots, k, \dots\)

    Sie müssen diese Elemente nicht alle einzeln angeben.

    Bestimmen sie ihre Anzahl durch dynamische Programmierung (von Hand).

Programme

Plan

Bezeichnungen für Teilterme

dabei bezeichnen:

Operationen mit (Teil)Termen

Operationen mit Variablen in Termen

Termersetzungssysteme

Termersetzungssysteme als Programme

dieses Berechnungsmodell ist im allgemeinen

Konstruktor-Systeme

Für TRS \(R\) über Signatur \(\Sigma\): Symbol \(s\in\Sigma\) heißt

Das TRS \(R\) heißt Konstruktor-TRS, falls:

Übung: diese Eigenschaft formal spezifizieren

Beispiele: \(R_1=\{a(b(x)) \to b(a(x))\}\) über \(\Sigma_1=\{a/1,b/1\}\),

\(R_2=\{f(f(x,y),z) \to f(x,f(y,z))\) über \(\Sigma_2=\{f/2\}\):

definierte Symbole? Konstruktoren? Konstruktor-System?

Funktionale Programme sind ähnlich zu Konstruktor-TRS.

Funktionale Programme (Bsp. und Vergleich)

Alternative Notation f. Gleichungssystem

Pattern Matching

data N = Z | S N ; data Bool = False | True
positive :: N -> Bool
positive x = case x of { Z -> False ; S x' -> True }

Eigenschaften von Case-Ausdrücken

ein case-Ausdruck heißt

Bespiele (für data T = A | B T | F T T)

-- nicht disjunkt:
case t of { F (B x) y -> .. ; F x (B y) -> .. }
-- nicht vollständig:
case t of { F x y -> .. ; A -> .. }

data und case

typisches Vorgehen beim Verarbeiten algebraischer Daten vom Typ T:

Pattern Matching in versch. Sprachen

Nicht verwechseln mit regular expression matching zur String-Verarbeitung. Es geht um algebraische (d.h. baum-artige) Daten!

Rechnen mit Wahrheitswerten

Syntax für Unterprogramm-Aufrufe

Syntax für Fallunterscheidungen

Übung Term-Ersetzung

Für die Signatur \(\Sigma=\{f/1,g/3,c/0\}\):

Für die Signatur \(\Sigma=\{Z/0, S/1, f/2\}\):

Dabei wurde angewendet:

Abkürzung für Anwendung von 0-stelligen Symbolen: anstatt \(Z()\) schreibe \(Z\). (Vorsicht: dann kann man Variablen nicht mehr von 0-stelligen Symbolen unterscheiden. Man muß dann immer die Signatur explizit angeben oder auf andere Weise vereinbaren, wie man Variablen erkennt, z.B. Buchstaben am Ende das Alphabetes (\(\dots,x,y,\dots\)) sind Variablen, das ist aber riskant)

Übung Pattern Matching, Programme

Hausaufgaben

im SS 22: Aufgaben 1, 5.

Aufgabe 3 siehe autotool (Highscore). Aufgabe 2 vlg. VL Th. Inf. (Formale Sprachen).

  1. Arithmetik auf Peano-Zahlen

    • Für \(R=\{ f(S(x),y) \to f(x, S(y)), f(Z,y) \to y\}\)

      bestimme alle \(R\)-Normalformen von \(f(S(Z), S(Z))\).

    • für \(R_d = R\cup\{ d(x)\to f(x,x) \}\)

      bestimme alle \(R_d\)-Normalformen von \(d(d(S(Z)))\).

    • Bestimme die Signatur \(\Sigma_d\) von \(R_d\).

      Bestimme die Menge der Terme aus \(\operatorname{Term}(\Sigma_d)\), die \(R_d\)-Normalformen sind.

    • Welche Rechenoperationen simulieren die Regeln für \(f\), für \(d\)?

    • welche Terme haben große Normalformen?

      Exakt formuliert: Geben Sie eine Funktion \(c:\NN\to\NN\) an, für die gilt: \(\forall n\in\NN: \forall t,t'\in\operatorname{Term}(\Sigma_d): |t|\le n\wedge t\to_{R_d}^* t' \Rightarrow |t'|\le c(n)\).

  2. Simulation von Wort-Ersetzung durch Term-Ersetzung.

    Abkürzung für mehrfache Anwendung eines einstelligen Symbols: \(A(A(A(A(x)))) = A^4(x)\)

    • für \(\{ A(B(x)) \to B(A(x)) \}\)

      über Signatur \(\{A/1, B/1, E/0\}\):

      bestimme Normalform von \(A^k (B^k (E))\)

      für \(k=1, 2, 3,\) allgemein.

    • für \(\{ A(B(x)) \to B(B(A(x))) \}\)

      über Signatur \(\{A/1, B/1, E/0\}\):

      bestimme Normalform von \(A^k (B (E))\)

      für \(k=1, 2, 3,\) allgemein.

  3. für die Signatur \(\{A/2, D/0\}\):

    • definiere Terme \(t_0=D, t_{i+1} = A(t_i, D)\).

      Zeichne \(t_3\). Bestimme \(|t_i|,\operatorname{depth}(t_i)\) .

    • für \(S=\{ A(A(D,x),y)\to A(x,A(x,y)) \}\)

      bestimme \(S\)-Normalform(en), soweit existieren, der Terme \(t_0, t_1, \dots, t_4\).

      Geben Sie für \(t_2\) die ersten Ersetzungs-Schritte explizit an.

    • Normalform von \(t_i\) allgemein.

  4. Für die Deklarationen

    -- data Bool = False | True   (aus Prelude)
data S = A Bool | B | C S S

    entscheide/bestimme für jeden der folgenden Ausdrücke:

    • syntaktisch korrekt?

    • Resultat-Typ (statische Semantik)

    • Resultat-Wert (dynamische Semantik)

    • Menge der Muster ist: disjunkt? vollständig?

    1. case False of { True -> B }
2. case False of { B -> True }
3. case C B B of { A x -> x }
4. case A True of { A x -> False }

5. case A True of { A x -> False ; True -> False }
6. case True of { False -> A ; True -> A False }
7. case True of { False -> B ; False -> A False }
8. case B of { C x y -> False; A x -> x; B -> True }

    weitere Beispiele selbst herstellen und dann in der Übung die anderen Teilnehmer fragen.

  5. für selbst definierte Wahrheitswerte: deklarieren, implementieren und testen Sie:

    • die zweistellige Antivalenz,

    • die Implikation,

    • die dreistellige Majoritätsfunktion.

    import qualified Prelude
data Bool = False | True deriving Prelude.Show
not :: ...
xor :: ...
...

    Definieren Sie die Majorität auf verschiedene Weisen

    • mit einer Gleichung (evtl. mit case, evtl. geschachtelt)

    • ohne case (evtl. mehrere Gleichungen)

    • mit einer Gleichung ohne Fallunterscheidung, mittels anderer (selbst definierter) Funktionen

  6. für binäre Bäume ohne Schlüssel

    data Tree = Leaf | Branch Tree Tree

    deklarieren, implementieren und testen Sie ein einstelliges Prädikat über solchen Bäumen, das genau dann wahr ist, wenn das Argument eine ungerade Anzahl von Blättern enthält.

    Diese Anzahl nicht ausrechnen, sondern direkt den Wahrheitswert!

Beweise

Motivation

Formale Beweise

CYP: Gleichungsketten

CYP: Fallunterscheidung

Peano-Zahlen

Spezifikation und Test

Bsp: Addition von Peano-Zahlen

Spezifikation und Verifikation

Beweis für: Addition von Peano-Zahlen ist assoziativ

Bezeichnungen in Beweisen durch Induktion

CYP: Induktion

Bsp. Programm-Konstruktion/Induktion

Induktion mit Generalisierung

Induktion über Bäume (IA)

Induktion über Bäume (IS)

Multiplikation von Peano-Zahlen

Minimum

Subtraktion

Hausaufgaben

im SS22: Aufgaben 2, optional: 4

  1. Für die Funktion

    f :: N -> N 
f Z = Z ; f (S x) = S (S (f x))

    beweisen Sie (erst auf Papier, dann mit CYP)

    f (plus x y) = plus (f x) (f y)

    durch Induktion nach x.

    Papier: Verwenden Sie die angegebenen Bezeichnungen für die Beweis-Schritte, geben Sie IA, IV, IB explizit an.

  2. Die übliche Peano-Addition ist

    plus Z y = y ; plus (S x) y = S (plus x y)

    Eine andere Implementierung der Addition (vgl. früher angegebenes Termersetzungssystem) ist

    plus' Z y = y ; plus' (S x) y = plus' x (S y)

    Beweisen Sie mit Cyp

    forall x :: N, y :: N : plus' x y .=. plus x y

    Beweisen Sie dazu als Hilfssatz

    forall x :: N, y :: N : plus x (S y) .=. plus (S x) y

    In dieser Induktion nach \(x\) müssen Sie das andere Argument \(y\) generalisieren, da es zwischen Induktionsvoraussetzung und Induktionsbehauptung unterschiedlich ist.

  3. Implementieren Sie Peano-Multiplikation und -Potenz.

    Formulieren, testen (leancheck) und beweisen (Papier, CYP) Sie einige Eigenschaften.

    CYP: formulieren Sie ggf. Hilfssätze als Axiome, d.h., ohne Beweis—aber mit Tests.

  4. Für zweistelliges min und max auf \(\NN\):

    1. Geben Sie eine äquivalente vollständige Spezifikation an, die keine Fallunterscheidung benutzt, sondern nur Addition.

    2. Implementieren Sie min und max nur durch Addition und Subtraktion (\(\ominus\)).

    3. testen (optional: und beweisen) Sie, daß Ihre Implementierung die Spezifikation erfüllt

    4. Implementieren Sie nur mit min und max:

      • den Median von drei Argumenten

      • (optional) den Median von fünf Argumenten

      Geben Sie Tests an (optional: Beweis)

  5. für das TRS \(R=\{A(A(D,x),y)\to A(x,A(x,y))\}\) über der Signatur \(\Sigma=\{D/0,A/2\}\), vgl. frühere Aufgabe,

    1. die Menge (Folge) aller \(R\)-Normalformen ist \(N_0=D, N_1=A(D,N_0), \dots, N_{k+1}=A(D,N_k),\dots\).

      warum gibt es keine anderen \(R\)-Normalformen?

    2. Die \(R\)-Normalform von \(A(N_l,N_r)\) ist \(N_k\) mit \(k=2^l+r\).

      1. Geben Sie Beispiele an (auf Papier oder maschinell)

      2. beweisen Sie durch vollständige Induktion nach \(l\).

        (Auf Papier, aber mit korrekten Bezeichnungen.)

      3. welches sind die Terme (z.B.: der Größe 11) mit größter Normalform?

Polymorphie

Definition, Motivation

Beispiele f. Typkonstruktoren (I)

Beispiele f. Typkonstruktoren (II)

Anwendung von Maybe

Polymorphe Funktionen

Bezeichnungen f. Polymorphie

data List e = Nil | Cons e (List e)

Operationen auf Listen (I)

data List a = Nil | Cons a (List a)

Von der Spezifikation zur Implementierung (II)

Operationen auf Listen (II)

Operationen auf Bäumen

data List e = Nil | Cons e (List e)
data Bin e = Leaf | Branch (Bin e) e (Bin e)

Knotenreihenfolgen

Adressierug von Knoten (False \(=\) links, True \(=\) rechts)

Statische Typisierung und Polymorphie

Bsp. für Programm ohne statischen Typ

Nutzen der stat. Typisierung und Polymorphie

Konstruktion von Objekten eines Typs

Aufgabe (Bsp): x :: Either (Maybe ()) (Pair Bool ())

Lösung (Bsp):

Insgesamt x = Right y = Right (Pair False ())

Vorgehen (allgemein)

Bestimmung des Typs eines Bezeichners

Aufgabe (Bsp.) bestimme Typ von x (erstes Arg. von get):

at :: List N -> Tree a -> Maybe a
at p t = case t of
  Node f ts -> case p of
    Nil -> Just f
    Cons x p' -> case get x ts of
      Nothing -> Nothing
      Just t' -> at p' t'

Lösung:

Vorgehen zur Typbestimmung eines Namens:

Übung Polymorphie

Hausaufgaben

im SS22: Aufgaben 1, 2.

  1. für die folgenden Datentypen: geben Sie einige Elemente an (ghci), geben Sie die Anzahl aller Elemente an.

    1. Maybe (Maybe Bool)

    2. Either (Bool, ()) (Maybe ())

    3. Foo (Maybe (Foo Bool)) mit data Foo a = C a | D

    4. geben Sie ein möglichst kleines Programm an, das nur aus data-Deklarationen besteht, und das einen Typ mit 100 (Zusatz: 1000) Elementen definiert.

      Diskussion: vergleiche frühere Aufgabe. Ein solcher Typ ist

      Maybe (Maybe (Maybe .... (Maybe ()) .. ))

      mit insgesamt nur drei Konstruktoren (Nothing, Just, ()).

      Also sollte man zur gerechten Messung der Programmgröße die Anzahl der Konstruktoren und die Größe der Typ-Ausdrücke addieren. Schlagen Sie eine konkrete Realisierung vor.

  2. Implementieren Sie die Post-Order Durchquerung von Binärbäumen.

    (Zusatz: Level-Order. Das ist schwieriger.)

    Verwenden Sie nur die in der VL definierten Typen (data List a = ..., nicht Prelude.[])

    und Programmbausteine (case _ of)

  3. Beweisen Sie (auf Papier, Zusatz: mit Cyp)

    forall xs . reverse (reverse xs) == xs

    Verwenden Sie ggf.

    rev (app xs ys) = app (rev ys) (rev xs)

    oder andere Hilfssätze ohne Beweis (aber mit Beispielen und Tests)

  4. (von voriger Woche, Typ ist nicht polymorph)

    Definitionen ergänzen; Eigenschaften testen (Einzelfälle, Leancheck), beweisen (Papier oder Cyp)

    data Tree = Leaf | Branch Tree Tree
size :: Tree -> N
leaves :: Tree -> N
branches :: Tree -> N
odd :: N -> Bool
Lemma : 
  size t .=. plus (leaves t) (branches t)
Lemma : odd (size t)

    Folien Induktion über Bäume benutzen.

Lambda-Kalkül: Syntax und dynamische Semantik (Auswertung)

Funktionen als Daten

Der Lambda-Kalkül

Freie und gebundene Variablen(vorkommen)

Semantik des Lambda-Kalküls: Reduktion \(\to_\beta\)

Relation \(\to_\beta\) auf \(\Lambda\) (ein Reduktionsschritt)

Es gilt \(t \to_\beta t'\), falls

Ein (Teil-)Ausdruck der Form \((\lambda x.B)A\) heißt Redex.
(Dort kann weitergerechnet werden.)

Ein Term ohne Redex heißt Normalform.
(Normalformen sind Resultate von Rechnungen.)

Falsches Binden lokaler Variablen

Semantik …: gebundene Umbenennung \(\to_\alpha\)

Umbenennung von lokalen Variablen

Lambda-Terme: verkürzte Notation

Ein- und mehrstellige Funktionen

Lambda-Ausdrücke in C#

Lambda-Ausdrücke in Java

Lambda-Ausdrücke in Javascript

$ node

> let f = function (x){return x+3;}
undefined

> f(4)
7

> ((x) => (y) => x+y) (3) (4)
7

> ((f) => (x) => f(f(x))) ((x) => x+1) (0)
2

Übung Lambda-Kalkül

Hausaufgaben

Für SS22: 1, 3, Zusatz: 4

  1. fvar implementieren (vgl. Übungsaufgabe bvar), Testfälle vorführen (aus Skript und weitere)

  2. für \(t=\lambda f x . f (f x)\): AST von \(t t S Z\) zeichnen,

    Normalform bestimmen: 1. auf Papier, 2. mit ghci.

    let t = \ f x -> f (f x)
...

  3. für \(s=\lambda x y z . x z(y z)\) und \(k=\lambda a b.a\):

    Auswertung von \(s k k 0\) in Haskell, in Javascript (node),

    optional: in C# (csharp), Java (jshell), oder anderer Sprache

  4. Für \(n\in\NN\) bezeichnet \([n]\) den Lambda-Ausdruck \(\lambda f x. f^n(x)\),

    dabei ist \(f^n(x)\) die \(n\)-fach iterierte Anwendung von \(f\) auf \(x\),

    also \([0]=\lambda f x.x, [1]=\lambda f x. f x, [2]=\lambda f x.f (f x), [3]=\lambda f x.f (f (f x))\) usw.

    die Normalform von \([2] s z\) ist \(s (s z)\), das entspricht der Peano-Repräsentation der Zahl 2.

    • für \(p=\lambda a b f x.a f (b f x)\): bestimmen Sie die Normalform von \(p [2] [1] s z\)

    • bestimmen Sie die Normalform von \([3] [2] s z\)

L-K.: statische Semantik (Typisierung)

Motivation, Plan

Grundlagen zur Typisierung

Einfache (monomorphe) Typen

Typ-Abstraktion und -Applikation

Polymorphie: Notation

Polymorphie: Notation: Abkürzungen

Verkürzte Notation für Typen

Nützliche Funktionen höherer Ordnung

Der allgemeinste Typ eines Ausdrucks

Beispiel für Typ-Bestimmung

Aufgabe: bestimme den allgemeinsten Typ von \(\lambda f x. f(f x)\)

Stelligkeit von Funktionen

Beispiele Fkt. höherer Ord.

Fkt. höherer Ord. für Folgen

Fkt. höherer Ord. für Mengen

Polymorphe Unterprogr. in anderen Sprachen

Zusammenfassung, Ausblick

Übung

Hausaufgaben

im SS 22 (für KW22, wg. Feiertagen):

Aufgaben (1 und 3), (4 oder 5)

  1. für die Lambda-Ausdrücke

    1. \(\lambda f g h x y . f (g x) (h y)\):

    2. \((\lambda x.x x) (\lambda y.y y)\)

    AST zeichnen, allgemeinsten Typ bestimmen, falls möglich

    (1. von Hand, mit Begründung,

    2. mit ghci überprüfen)

  2. für die Ausdrücke

    flip
flip flip
flip flip flip
...

    jeweils Argumente \(a_1 a_2\dots\) angeben (passende Anzahl), so daß der Wert von flip flip ... flip a1 a2 ... gleich True ist.

    Dabei alle Typargumente für alle flip explizit angeben.

  3. in Haskell: Lambda-Ausdrücke mit diesen Typen angeben, falls möglich:

    a -> (a -> c) -> c
a -> b
(a -> b) -> (b -> c) -> a -> c

    mit ghci überprüfen (Typen anzeigen lassen)

    die Ausdrücke dann auch mit passenden Argumenten aufrufen, so daß der Wert True ist (oder von einem andern data-Typ, jedenfalls keine Funktion)

  4. (einige der) Funktionen compose, flip, curry, uncurry

    in C# (csharp) und Java (jshell) deklarieren (vorher prüfen, ob es die schon gibt) (anhand von Primärquellen)

    und aufrufen (dabei Typ-Argumente explizit angeben)

    Den Typ für 2-Tupel aus der jeweiligen Standardbibliothek benutzen.

  5. für Data.List, Data.Sequence

    die Funktionen partition, span, inits, tails

    1. aufrufen (in ghci Beispiele vorführen), dabei anwenden auf eine Liste/Folge von Bool

    2. die API-Dokumentation aufsuchen (hackage.org)

    3. die dort angegebenen Eigenschaften als Leancheck-Property überprüfen

Objektorientierte Entwurfmuster

Definition, Geschichte

Beispiel Strategie-Muster

Java: Funktionale Schnittstellen

Rekursionsmuster

Rekursion über Bäume (Beispiele)

Rekursion über Bäume (Schema)

f :: Tree a -> b
f t = case t of
  Leaf -> ...
  Branch l k r -> ... (f l) k (f r)

dieses Schema ist eine Funktion höherer Ordnung:

fold :: ( ... ) -> ( ... ) -> (Tree a -> b)
fold leaf branch = \ t -> case t of
  Leaf -> leaf
  Branch l k r -> 
     branch (fold leaf branch l) 
            k (fold leaf branch r)
summe = fold Z (\ x y z-> plus x (plus y z))

(bei Aufruf ist dann x=summe l, y=k, z=summe r)

Rekursion über Listen (Bsp. und Schema)

and :: List Bool -> Bool
and xs = case xs of 
  Nil -> True ; Cons x xs' -> x && and xs'
length :: List a -> N
length xs = case xs of
  Nil -> Z ; Cons x xs' ->  S (length xs')

fold :: b -> ( a -> b -> b ) -> List a -> b
fold nil cons xs = case xs of
    Nil -> nil
    Cons x xs' -> cons x ( fold nil cons xs' )
and = fold True (&&) 
length = fold Z ( \ x y ->  S y)

Rekursionsmuster (Prinzip)

Rekursionsmuster (Merksätze)

aus dem Prinzip ein Rekursionsmuster anwenden \(=\) jeden Konstruktor durch eine passende Funktion ersetzen folgt:

Argumente für Rekursionsmuster finden

systematisches experimentelles Vorgehen zur Lösung von:

Schreiben Sie Funktion \(f:T \to R\) als fold

Beispiel: reverse :: List a -> List a

Rekursionsschema f. mehrstellige Fkt.

Rekursionsmuster (Peano-Zahlen)

Nicht durch Rekursionmuster darstellbare Fkt.

Darstellung mit Fold und Projektion

Zusammenfassung Rekursionmuster

Spezialfälle des Fold

Rekursion über Listen aus Std.-Bib.

das vordefinierte Rekursionsschema über Listen ist:

foldr :: (a -> b -> b) -> b -> ([a] -> b)
length = foldr ( \ x y -> 1 + y ) 0 -- Bsp

Aufgaben:

Weitere Übungsaufgaben zu Fold

Rekursionsmuster für Bäume (Bsp. 2)

Übung Rekursionsmuster

Implementierungen für natürlichen Zahlen

Merksätze

Hausaufgaben

im SS 22: 1, 2, 4.

  1. Wenden Sie die Vorschrift zur Konstruktion des Rekursionsmusters an auf den Typ

    • Bool

    • Maybe a

    • Pair a b

    • Either a b

    Jeweils:

  2. Rekursionsmuster auf Peano-Zahlen

    • plus, mal, hoch vorführen (jeweils realisiert als fold)

      Testen Sie mit Leancheck einige Eigenschaften.

    • Beweisen Sie, daß die modifizierte Vorgängerfunktion

      pre :: N -> N; pre Z = Z; pre (S x) = x

      kein fold ist.

    ggf. ergänzende Aufgaben in autotool (nicht vorführen):

    • Diese Funktion pre kann jedoch als Projektion einer geeigneten Hilfsfunktion h :: N -> (N,N) realisiert werden. Spezifizieren Sie h und geben Sie eine Darstellung von h als fold an.

    • Implementieren Sie die (modifizierte) Subtraktion minus mit fold (über das erste Argument) (und pre)

  3. Rekursionsmuster auf Eigenbau-Listen:

    • mit fold und ohne Rekursion implementieren:

      isPrefixOf :: Eq a => List a -> List a -> Bool

      siehe Folie Rekursionsmuster für mehrstellige Funktion.

      (Das Typ-Constraint Eq a bedeutet, daß der Operator (==) :: a -> a -> Bool benutzt werden kann, genaue Erklärung dazu später.)

    • die Eigenschaft isPrefixOf xs (append xs ys) mit Leancheck überprüfen (für xs :: List Bool)

      Diese Eigenschaft abändern und Gegenbeispiele diskutieren.

    • für isSuffixOf: 1. konkrete Testfälle, 2. allgemeine Eigenschaft, 3. Implementierung ohne Rekursion, ohne Fold, aber unter Benutzung von reverse angeben.

  4. Rekursionsmuster auf binären Bäumen (Schlüssel in Verzweigungsknoten)

    • Beweisen Sie, daß is_search_tree :: Tree N -> Bool kein fold ist.

    • diese Funktion kann jedoch als Projektion einer Hilfsfunktion h :: Tree N -> (Bool, Maybe (N,N)) erhalten werden, die für Bäume mit nicht-leerer Schlüsselmenge auch noch deren kleinstes und größtes Element bestimmt. Stellen Sie h als fold dar.

    Bemerkung zu \(\NN\) beachten. Hier ist Numeric.Natural sinnvoll.

Eingeschränkte Polymorphie

Typklassen in Haskell: Überblick

Beispiel

sortBy :: (a -> a -> Ordering) -> [a] -> [a]
sortBy ( \ x y -> ... ) [False, True, False]

Kann mit Typklassen so formuliert werden:

class Ord a where 
    compare :: a -> a -> Ordering
sort :: Ord a => [a] -> [a]
instance Ord Bool where compare x y = ...
sort [False, True, False]

Grundwissen Typklassen

Typklassen in Bibliotheks-Schnittstellen

(Eingeschränkt) polymorphe Literale

Unterschiede Typklasse/Interface (Bsp)

Unterschiede Typklasse/Interface (Impl.)

Typklassen/Interfaces: Vergleich

Generische Instanzen (I)

class Eq a where
    (==) :: a -> a -> Bool

Vergleichen von Listen (elementweise)

wenn a in Eq, dann [a] in Eq:

instance Eq a => Eq [a] where
  l == r = case l of
    [] -> case r of
      [] -> True ; y : ys -> False
    x : xs -> case r of
      [] -> False 
      y : ys -> (x == y) && ( xs == ys )

Übung: wie sieht instance Ord a => Ord [a] aus? (lexikografischer Vergleich)

Generische Instanzen (II)

class Show a where
  show ::  a -> String
instance Show Bool where
  show False = "False" ; show True = "True"
instance Show a => Show [a] where
  show xs = brackets 
          $ concat
          $ intersperse "," 
          $ map show xs
instance (Show a, Show b) => Show (a,b) where ...
show False = "False"
show ([True,False],True) 
  = "([True,False],True)"

Benutzung von Typklassen bei Leancheck

Test.LeanCheck—Beispiel

Testen für beliebige Stelligkeit

Überblick über Leancheck-Implementierung

Hausaufgaben

im SS 22: Aufgaben 1, 2.

grundsätzlich (bis Semester-Ende) Falls es Streit gibt, wer präsentiert: es kommen die Personen/Gruppen bevorzugt dran, die bisher weniger Punkte haben.

Wenn diese nicht wollen, nicht vorbereitet sind, oder noch Zeit verbleibt, dann auch andere Gruppen und andere Aufgaben.

  1. diese Aufgabe für selbst definierten Datentyp T, mit Typklassen Eq und Ord aus der Standardbibliothek:

    Definieren Sie für data T = T Bool Bool Bool

    • instance Eq T als komponentenweise Gleichheit

    • instance Ord T als lexikografisches Produkt der Standard-Ordnung auf Bool (zitieren Sie zunächst die mathematische Definition, z.B. aus der VL Modellierung)

    Formulieren Sie allgemein (d.h., polymorph) als leancheck-Eigenschaft, daß die Relation (<=)

    • transitiv

    • antisymmetrisch

    ist und prüfen Sie das für Integer und für T.

    instance Listable T where tiers = cons3 T

leq_is_transitiv :: Ord a => a -> a -> a -> Bool
leq_is_transitiv = \ x y z -> _

:set -XTypeApplications 

check (leq_is_transitiv @T)

  2. diese Aufgabe für selbst definierten Datentyp T, mit Typklassen Semigroup und Monoid aus der Standardbibliothek:

    Definieren Sie für data T = T Bool Bool Bool

    • ‘instance Semigroup T‘ als komponentenweise Disjunktion

    • ‘instance Monoid T‘ als dazu passendes neutrales Element

    Formulieren Sie die Monoid-Axiome allgemein (d.h., polymorph) als Eigenschaft in Leancheck und überprüfen Sie diese für T.

    Geben Sie eine andere korrekte Monoid-Struktur für T an, die nicht kommutativ ist. Testen Sie diese Eigenschaft (leancheck soll das Gegenbeispiel finden).

  3. für Peano-Zahlen: deklarieren Sie instance Num N und implementieren Sie dafür (nur) (+) und (*)

    (mit den bekannten Definitionen als fold)

    Test: S (S Z) * S (S (S Z))

    und: S (S (S Z)) ^ 3 (warum funktioniert das?)

    Implementieren Sie fromInteger

    (rekursiv, mit if x > 0 then ... else ...)

    Test (polymorphes Literal) 42 :: N

  4. Modul Data.Map aus containers, Modul Data.HashMap aus unordered-containers:

    • warum hat fromList ein Typconstraint (oder sogar zwei) für den Schlüsseltyp k, aber nicht für den Werttyp a?

    • Erläutern Sie das Typconstraint (oder dessen Fehlen) für singleton.

    für Data.Map:

    • warum haben die Typen von unionWith und intersectionWith unterschiedliche Anzahl von Typvariablen?

    • Definieren Sie einen Typ data K = ... deriving Eq. Implementieren Sie instance Ord K so, daß die Relation (<=) keine totale Ordnung ist.

      Zeigen Sie durch Beispiele, daß dann M.Map K v nicht funktioniert. Z.B.: mit M.insert eingefügter Schlüssel nicht in M.toList zu sehen, sichtbarer Schlüssel nicht gefunden mit M.lookup.

  5. für instance Semigroup Ordering, instance Monoid Ordering aus der Standardbibliothek:

    Bestimmen Sie die Wertetabelle von (<>).

    Überprüfen Sie (mit leancheck) die Axiome von Semigroup und Monoid. Ist die Verknüpfung kommutativ?

    Für den Datentyp data Pair a b = Pair a b: implementieren Sie den lexikografischen Vergleich

    instance (Ord a, Ord b) => Ord (Pair a b) where
  compare (Pair px py) (Pair qx qy) = _

    • mit Fallunterscheidungen

    • ohne Fallunterscheidung, aber mit (<>)

Verzögerte Auswertung (lazy evaluation)

Motivation: Datenströme

Folge von Daten:

aus softwaretechnischen Gründen diese drei Aspekte im Programmtext trennen,

aus Effizienzgründen in der Ausführung verschränken (bedarfsgesteuerte Transformation/Erzeugung)

Bedarfs-Auswertung, Beispiele

Beispiel Bedarfsauswertung

data Stream a = Cons a (Stream a)
nats :: Stream N ; nf :: N -> Stream N
nats = nf 0 ; nf n = Cons n (nf (n+1))
head (Cons x xs) = x ; tail (Cons x xs) = xs

Obwohl nats unendlich ist, kann Wert von head (tail (tail nats)) bestimmt werden:

   = head (tail (tail (nf 0)))
   = head (tail (tail (Cons 0 (nf 1))))
   = head (tail (nf 1))
   = head (tail (Cons 1 (nf 2)))
   = head (nf 2) = head (Cons 2 (nf 3)) = 2

es wird immer ein äußerer Redex reduziert

(Bsp: nf 3 ist ein innerer Redex)

Strictness

zu jedem Typ \(T\) betrachte \(T_\bot=\{\bot\}\cup T\)

dabei ist \(\bot\) ein Nicht-Resultat vom Typ \(T\)

Def.: Funktion \(f\) heißt strikt, wenn \(f(\bot)=\bot\).

Fkt. \(f\) mit \(n\) Arg. heißt strikt in \(i\),

falls \(\forall x_1 \dots x_n: (x_i=\bot) \Rightarrow f(x_1,\ldots,x_n)=\bot\)

verzögerte Auswertung eines Arguments
\(\Rightarrow\) Funktion ist dort nicht strikt

einfachste Beispiele in Haskell:

Beispiele Striktheit

Implementierung der verzögerten Auswertung

Begriffe:

bei jedem Konstruktor- und Funktionsaufruf:

Bedarfsauswertung in Scala

Diskussion

Anwendg. Lazy Eval.: Ablaufsteuerung

Anwendg. Lazy Eval.: Modularität

Anwendg. Lazy Eval.: Streams

unendliche Datenstrukturen

Primzahlen

primes :: [ Nat ]
primes = sieve ( from 2 )

from :: Nat -> [ Nat ]
from n = n : from ( n+1 )

sieve :: [ Nat ] -> [ Nat ]
sieve (x : ys) = 
  x : sieve (filter (\y ->0 < mod y x) ys)

(Das ist (sinngemäß) das Code-Beispiel auf https://www.haskell.org/)

Semantik von let-Bindungen

Beispiel für Lazy Semantik in Let

Übungsaufgaben zu Striktheit

Hausaufgaben

SS22: Aufgaben 1 und 2, weitere optional

  1. Aufgabe: strikt in welchen Argumenten?

    f x y z = case y || x of
  False -> y
  True -> case z && y  of
    False -> z
    True  -> False

    Bereiten Sie (wenigstens) eine ähnliche Aufgabe vor, die Sie in der Übung den anderen Teilnehmern stellen.

  2. Bestimmen Sie jeweils die ersten Elemente dieser Folgen (1. auf Papier durch Umformen, 2. mit ghci).

    Vorher für die Hilfsfunktionen (map, zipWith, concat):
    1. Typ feststellen, 2. Testfälle für endliche Listen

    1. f = 0 : 1 : f
    2. n = 0 : map (\ x -> 1 + x) n
    3. xs = 1 : map (\ x -> 2 * x) xs
    4. ys = False 
 : tail (concat (map (\y -> [y,not y]) ys))
    5. zs = 0 : 1 : zipWith (+) zs (tail zs)

    siehe auch https://www.imn.htwk-leipzig.de/~waldmann/etc/stream/

  3. Für Peano-Zahlen und Eigenbau-Listen implementieren: len :: List a -> N als fold, Vergleich (gt: greater than, größer als) mit Rekursion:

    gt :: N -> N -> Bool
gt Z y = _
gt (S x) Z = _
gt (S x) (S y) = gt _ _

    und diese Auswertung erklären:

    gt (len (Cons () (Cons () undefined)))
   (len (Cons () Nil))

    Unterschiede erklären zu

    length (() : () : undefined) > length (() : undefined)

  4. Folie Ablaufsteuerung: Ifthenelse als Funktion in Haskell, in Javascript, Simulation der nicht-strikten Auswertung.

  5. Algorithmus aus Appendix A aus Chris Okasaki: Breadth-First Numbering: Lessons from a Small Exercise in Algorithm Design (ICFP 2000) implementieren (von where auf let umschreiben), testen und erklären

Fkt. höherer Ord. für Streams

Motivation

Motivation: Parallel-Verarbeitung

geeignete Fkt. höherer Ordnung \(\Rightarrow\) triviale Parallelisierung:

Func<int,int> f = x => ... // teure Rechnung
var s = Enumerable.Range(1, 20000)
     .Select( f ).Sum() ;
var s = Enumerable.Range(1, 20000)
     .AsParallel()
     .Select( f ).Sum() ;

Dadurch werden

vgl. http://msdn.microsoft.com/en-us/library/dd460688.aspx

Strom-Operationen

Struktur-erhaltende Strom-Transf.

Struktur-ändernde Strom-Transf.

Linq (Language integrated query) in C#

Kombination von Strömen mit SelectMany

Anwendung von Bind

do-Notation

Verbrauch von Datenströmen: Fold

Wiederholung, Motivation

Fold-Left: Beispiel

Fold-Left: Implementierung

Fold-Left: allgemeiner Typ

Das strikte Fold-Left: Anwendung

Fold-Left mit nicht-striktem Argument

Zusammenfassung: Ströme

Theorem-Geschenke

Beispiel, Motivation

Theorem-Geschenke: Quelle

Struktur-erhaltende Transformationen

Theorem-Geschenke: Systematik, Beispiele

Geschenk-Theoreme für Fkt. höherer Ord.

Hausaufgaben

im SS22: Aufgaben 2, 6. andere optional, empfohlen: 5

  1. definieren Sie den Operator

    f >=> g = \ xs -> f xs >>= g

    Bestimmen Sie den Typ dieses Operators.

    Ergänzen Sie den Ausdruck, so daß er den gegebenen Wert hat:

    ghci> ((\x ->[1,x]) >=>  _ ) 5
[4,2,8,2]

  2. die Funktion fromBits :: [Bool] -> Integer, Beispiel fromBits [True,False,False,True,False]=18

    …als foldr oder als foldl ?

    Geben Sie die eine Darstellung an, begründen Sie, daß die andere unmöglich ist.

  3. Vervollständigen Sie die Gleichung

    foldl f a (map g xs) = foldl _ _

    so, daß rechts kein map steht. Dieses Verschwinden des map heißt stream fusion (Coutts, Leshchinsky, Stewart, 2007) http://citeseer.ist.psu.edu/viewdoc/summary?doi=10.1.1.104.7401

  4. Vervollständigen Sie die Gleichung

    foldr f a xs = foldl _ _  (reverse xs)

  5. In einem Kommentar in GHC.List https://hackage.haskell.org/package/base-4.15.0.0/docs/src/GHC-List.html#filter stellt SLPJ (wer ist das?) fest, daß man in der Gleichung

    filter p (filter q xs) 
  = filter (\ x -> q x && p x) xs

    , die zur Programmtransformation während der Kompilation verwendet wird, die Reihenfolge der Argumente im Teilausdruck q x && p x nicht vertauschen darf.

    Warum—die Konjunktion ist doch kommutativ?

  6. Geben Sie die Theorem-Geschenke für diese Typen an

    (a -> a -> Ordering) -> [a] -> [a]
(a -> Bool) -> [a] -> ([a],[a])

    überprüfen Sie diese experimentell für die Funktionen sortBy, partition, span aus Data.List

    Bemerkung zur ersten Teilaufgabe: für den Typ

    sort :: Ord a => [a] ->  [a]

    gibt es kein Theorem geschenkt, denn die Polymorphie ist eingeschränkt durch das Typconstraint. Man erhält eine uneingeschränkt polymorphe Funktion (mit einem Geschenk-Theorem) wenn das Typconstraint entfernt und stattdessen seine Methode als zusätzliches Argument eingeführt wird:

    sortBy :: (a -> a -> Ordering) -> [a] -> [a]

  7. (Funktionen aus Data.List)

    • implementieren Sie scanr mittels foldr.

      scanr f z = foldr (\x (y:ys) -> _) _

    • implementieren Sie scanr mittels mapAccumR.

      scanr f z = uncurry (:) . mapAccumR _ _

    • ergänzen Sie die allgemeingültige Aussage

      scanr f z (reverse xs) = _ (scanl _ _ xs)

  8. Geben Sie jeweils die strukturerhaltende Transformation als Funktor-Instanz an:

    -- | einfach verkettete Listen
data List a = ... 
instance Functor List where 
  fmap f xs = case xs of ...
-- | Binärbäume mit Schlüssel in Verzweigungsknoten
data Tree a = ... 
instance Functor Tree where
  fmap f t = case t of ...

    Überprüfen Sie (mit Leancheck) die Funktor-Axiome.

    Geben Sie das geschenkte Theorem für den Typ der Funktion preorder an.

    preorder :: Tree a -> List a

    Überprüfen Sie mit Leancheck.

    Da postorder den gleichen Typ hat, gilt das gleiche Theorem auch dafür. Überprüfen Sie.

Algorithmen f. unveränderliche Daten

Überblick

Beispiel: Einfügen in Baum

Beispiel: unbalancierter Suchbaum

Löschen in unbalancierten Suchbäumen

Größen-balancierter Suchbaum

Massen-Operationen mit Suchbäumen

Persistente Objekte in Git

Objekt-Versionierung in Git

Effiziente Repräsentation von Folgen

Balancierte Repräsentation

Balance durch Typisierung

Konsumption von Collections durch Foldable

Hausaufgaben

SS22: optional, empfohlen: 4, 5, 6, (7).

ebenso Aufgaben 8, 7, 6 vorige Woche.

  1. für \(\alpha\)-balancierte Suchbäume

    • Geben Sie einen \(1/4\)-balancierten Baum mit (z.B.) 10 Schlüsseln an, der möglichst hoch ist. In jedem Branch l k r soll \(|l|\le |r|\) gelten.

      Vergleichen Sie die Höhe mit der in der VL berechneten Schranke.

    • Vergleichen Sie die Implementierung von split und (z.B.) union (Fig. 1 des zitierten Papers) mit der Implementierung der entsprechenden Funktion aus https://hackage.haskell.org/package/containers-0.6.4.1/docs/Data-Set.html

    • für Data.Set: erläutern Sie Laufzeit-Unterschiede zwischen fromList und fromAscList

  2. Für rose trees (Rhododendron)

    data Tree k = Node k [Tree k]

    • Implementieren Sie das Rekursionsschema

      fold :: (k -> [res] -> res) -> Tree k -> res

    • Bestimmen Sie mit diesem fold die Anzahl der Knoten, die Höhe, die Summe der Schlüssel.

    • Konstruieren Sie Binomialbäume:

      \(B_n\) hat Schlüssel \(n\) und Kinder \([B_0, \ldots, B_{n-1}]\)

      insbesondere: \(B_0\) hat Schlüssel 0 und keine Kinder.

    • berechnen Sie die o.g. Parameter für kleine \(B_n\), geben Sie allgmeine Aussagen (für alle \(B_n\) an), beweisen Sie diese.

  3. git bisect erläutern und vorführen. Dazu ein überschaubares kleines Projekt verwenden (oder anlegen) (ca. 10 commits) mit einfachem Testfall sowie einem einfachen Fehler irgendwo.

    In diesem Zusammenhang Verhaltensregeln/Empfehlungen diskutieren (master always buildable, squash commits?)

  4. Vorrede: wer außerhalb einer Übungsaufgabe sortiert, macht einen Fehler (hätte stattdessen Data.Set benutzen sollen). Wer einfach verkettete Listen benutzt, auch (\(\Rightarrow\) Data.Sequence, Data.Vector). Corollar: Wer Strings benutzt, auch (\(\Rightarrow\) Data.Text)

    Aufgabe: zum Sortieren bezüglich einer Maßfunktion, z.B. Strings nach der Länge, kann man verwenden

    import Data.Function (on)
sortBy (compare `on` length) ["foo", "barrr", ""]

    aber auch

    sortOn length ["foo", "barrr", ""]

    Erklären Sie `on`. Erklären Sie den Unterschied (Laufzeit, Platz) zwischen beiden Varianten.

    Zur Messung mit ghci: siehe Aufgabe weiter unten. Benutzen Sie diese Testdaten:

    xs = take (10^6) $ map show $  iterate (*3) (1::Int)

    Auswertung der Testdaten erzwingen mit

    sum $ map length xs

    erst danach zum Sortieren verwenden.

    Messung der Kosten des Sortierens mit

    last $ sortOn length xs

    Warum nicht so?

    head $ sortOn length xs

  5. Data.Sequence: beschreiben Sie die Form

    • eines möglichst tiefen,

    • einen möglichst flachen

    Fingerbaums mit genau 1000 Elementen.

    In dem zitieren Papier von Hinze und Paterson steht: concatenation …in time logaritmic in the size of the smaller piece. Wann ist das besser als …in the size of the result? Wie wird das durch die Implementierung erreicht?

  6. Data.Set.intersection: vergleichen Sie Laufzeiten der naiven und der richtigen Implementierung.

    In ghci messen mit :set +s. Dabei Laziness von let-Bindungen beachten. Auswertung erzwingen durch Anwenden der strikten Funktion length.

    ghci> import qualified Data.Set as S
ghci> :set +s
ghci> s1 = S.fromList  [ 1 .. 10^6 :: Int ]
(0.03 secs, 33,432 bytes)
ghci> length s1
1000000
(0.34 secs, 144,071,248 bytes)
ghci> length s1
1000000
(0.00 secs, 37,832 bytes)

ghci> s2 = S.fromList [ 0 .. 10^6-1 :: Int ]
(0.00 secs, 30,888 bytes)
ghci> length s2
1000000
(0.21 secs, 144,071,320 bytes)
ghci> length $ S.intersection s1 s2
999999
(0.07 secs, 75,069,072 bytes)

    Konstruieren Sie eine Menge \(s_3\) mit \(|s_3| = |s_2|\), so daß \(s_1\cap s_3\) (viel) schneller ausgewertet wird als \(s_1\cap s_2\)

  7. Data.Set.cartesianProduct: die Kosten sind mit \(O(m\cdot n)\) conjectured angegeben. Lesen Sie den Kommentar im Quelltext, messen Sie, vergleichen Sie mit der naiven Implementierung, (Forschungsaufgabe) beweisen Sie die conjecture.

Ergänzg., Zusammenfassg., Ausblick

Erläuterung/Wiederholung: Currying

Erläuterung/Wiederholung: Extensionalität

Wiederholung/Bsp: generische Polymorphie

Zusammenfassung: Themen

Prüfungen

Aussagen

Programmierer(in) sollte

Objekt- (Klassen-) orientierte Progr.

Ausdrucksstarke Typen

Daten-abhängige Typen (dependent types)

Wie weiter?