GeoTopo images for easier compiling; Lazy evalution; Logik

documents/Programmierparadigmen/Haskell.tex

@@ -1,3 +1,4 @@
+%!TEX root = Programmierparadigmen.tex
 \chapter{Haskell}
 \index{Haskell|(}
 Haskell ist eine funktionale Programmiersprache, die von Haskell 
@@ -122,6 +123,28 @@ in etwa folgendem Haskell-Code:
 \end{itemize}
 
 \section{Typen}
+\subsection{Standard-Typen}
+Haskell kennt einige Basis-Typen:
+\begin{itemize}
+  \item \textbf{Int}: Ganze Zahlen. Der Zahlenbereich kann je nach Implementierung variieren,
+  aber der Haskell-Standart garantiert, dass das Intervall 
+  $[-2^{29}, 2^{29}-1]$ abgedeckt wird.
+  \item \textbf{Integer}: beliebig große ganze Zahlen
+  \item \textbf{Float}: Fließkommazahlen
+  \item \textbf{Double}: Fließkommazahlen mit doppelter Präzision
+  \item \textbf{Bool}: Wahrheitswerte
+  \item \textbf{Char}: Unicode-Zeichen
+\end{itemize}
+
+Des weiteren gibt es einige strukturierte Typen:
+\begin{itemize}
+  \item Listen: z.~B. $[1,2,3]$
+  \item Tupel: z.~B. $(1,'a',2)$
+  \item Brüche (Fractional, RealFrac)
+  \item Summen-Typen: Typen mit mehreren möglichen Repräsentationen
+\end{itemize}
+
+\subsection{Typinferenz}
 In Haskell werden Typen aus den Operationen geschlossfolgert. Dieses
 Schlussfolgern der Typen, die nicht explizit angegeben werden müssen,
 nennt man \textbf{Typinferent}\xindex{Typinferenz}.
@@ -139,6 +162,18 @@ Ein paar Beispiele zur Typinferenz:
     \label{fig:haskell-type-hierarchy}
 \end{figure}
 
+\section{Lazy Evaluation}\xindex{Lazy Evaluation}
+Haskell wertet Ausdrücke nur aus, wenn es nötig ist.
+
+\begin{beispiel}[Lazy Evaluation]
+    Obwohl der folgende Ausdruck einen Teilausdruck hat, der einen Fehler zurückgeben
+    würde, kann er aufgrund der Lazy Evaluation zu 2 evaluiert werden:
+    \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=lazy-evaluation.hs]{haskell}{scripts/haskell/lazy-evaluation.hs}
+\end{beispiel}
+
+Ein spezialfall der Lazy-Evaluation ist die sog. \textit{Kurzschlussauswertung}.\xindex{Kurzschlussauswertung}\xindex{Short-circuit evaluation}
+Das bezeichnet die Lazy-Evaluation von booleschen Ausdrücken.
+
 \section{Beispiele}
 \subsection{Quicksort}
 \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=qsort.hs]{haskell}{scripts/haskell/qsort.hs}
@@ -163,7 +198,8 @@ sich das ganze sogar noch kürzer schreiben:
 \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=fibonacci-pattern-matching.hs]{haskell}{scripts/haskell/fibonacci-pattern-matching.hs}
 
 \subsection{Quicksort}
-\subsection{Funktionen höherer Ordnung}
+\subsection{Funktionen höherer Ordnung}\xindex{Folds}\xindex{foldl}\xindex{foldr}\label{bsp:foldl-und-foldr}
+\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=folds.hs]{haskell}{scripts/haskell/folds.hs}
 
 
 \section{Weitere Informationen}

documents/Programmierparadigmen/Programmierparadigmen.tex

@@ -92,6 +92,7 @@
 \setcounter{page}{1}
 \input{Programmiersprachen}
 \input{Programmiertechniken}
+\input{Logik}
 \input{Haskell}
 \input{Prolog}
 \input{Scala}

documents/Programmierparadigmen/Programmiertechniken.tex

@@ -1,3 +1,4 @@
+%!TEX root = Programmierparadigmen.tex
 \chapter{Programmiertechniken}
 \section{Rekursion}
 \index{Rekursion|(}
@@ -107,6 +108,8 @@ Auf Englisch heißen endrekursive Funktionen \textit{tail recursive}.
     \end{bspenum}
 \end{beispiel}
 
+Wenn eine rekursive Funktion nicht terminiert oder wenn 
+
 \index{Rekursion|)}
 \section{Backtracking}
 \index{Backtracking|(}
@@ -129,5 +132,6 @@ Bekannte Beispiele sind:
           Nun steckt \texttt{reduce} zuerst zwei Elemente aus \texttt{list}
           in \texttt{function}, merkt sich dann das Ergebnis und nimmt
           so lange weitere Elemente aus \texttt{list}, bis jedes 
-          Element genommen wurde.
+          Element genommen wurde.\\
+          Bei \texttt{reduce} ist die Assoziativität wichtig (vgl. \cref{bsp:foldl-und-foldr})
 \end{itemize}

documents/Programmierparadigmen/Symbolverzeichnis.tex

@@ -1,10 +1,9 @@
 %!TEX root = Programmierparadigmen.tex
 \markboth{Symbolverzeichnis}{Symbolverzeichnis}
-\twocolumn
 \chapter*{Symbolverzeichnis}
 \addcontentsline{toc}{chapter}{Symbolverzeichnis}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-% Reguläre Ausdrücke                                                 %
+% Reguläre Ausdrücke                                                %
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 \section*{Reguläre Ausdrücke}
 $\emptyset\;\;\;$ Leere Menge\\
@@ -15,4 +14,7 @@ $L(\alpha | \beta) = L(\alpha) \cup L(\beta)$\\
 $L(\alpha \cdot \beta) = L(\alpha) \cdot L(\beta)$\\
 $\alpha^+ = L(\alpha)^+$ TODO: Was ist $L(\alpha)^+$\\
 $\alpha^* = L(\alpha)^*$ TODO: Was ist $L(\alpha)^*$\\
-\onecolumn
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% Reguläre Ausdrücke                                                %
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+$\bot\;\;\;$ Bottom\\

documents/Programmierparadigmen/scripts/haskell/folds.hs

@@ -0,0 +1,12 @@
+summer :: [Int] -> Int
+summer = foldr (-) 0
+
+summel :: [Int] -> Int
+summel = foldl (-) 0
+
+main :: IO ()
+main = do
+	print (summer [1,2,3])
+	-- 0-(1-(2-3)) = 0-(1-(-1)) = 2
+	print (summel [1,2,3])
+	-- ((0-1)-2)-3 = -6

documents/Programmierparadigmen/scripts/haskell/lazy-evaluation.hs

@@ -0,0 +1,6 @@
+g a b c
+	| c > 0     = b
+	| otherwise = a
+
+main = do
+	print (g (1/0) 2 3)