Haskell angefangen

documents/Programmierparadigmen/Arbeitszeit.md

@@ -5,4 +5,4 @@ in dem Erstellen dieses Skripts steckt:
 |-----------|---------------|----------------------------------------
 |01.02.2014 | 13:30 - 13:45 | Thoma | Initialisierung; Grobe Struktur
 |01.02.2014 | 14:00 - 14:45 | Thoma | ASCII-Tabelle in C angefangen; Kapitel "Programmiersprachen" hinzugefügt; erste Definitionen
-
+|01.02.2014 | 14:45 - 15:30 | Thoma | Haskell angefangen

documents/Programmierparadigmen/C.tex

@@ -1,6 +1,14 @@
 \chapter{C}
 \index{C|(}
-C ist eine imperative Programmiersprache.
+C ist eine imperative Programmiersprache. Sie wurde in vielen Standards
+definiert. Die wichtigsten davon sind:\todo{Wo sind unterschiede?}
+
+\begin{itemize}
+    \item C89
+    \item C99
+    \item ANSI C
+    \item C11
+\end{itemize}
 
 \section{Datentypen}\xindex{Datentypen}
 Die grundlegenden C-Datentypen sind

documents/Programmierparadigmen/Haskell.tex

@@ -1,10 +1,80 @@
 \chapter{Haskell}
 \index{Haskell|(}
-Haskell ist eine funktionale Programmiersprache.
+Haskell ist eine funktionale Programmiersprache, die von Haskell 
+Brooks Curry entwickelt wurde und 1990 in Version~1.0 veröffentlicht 
+wurde.
+
+Wichtige Konzepte sind:
+\begin{enumerate}
+    \item Funktionen höherer Ordnung
+    \item anonyme Funktionen (sog. Lambda-Funktionen)
+    \item Pattern Matching
+    \item Unterversorgung
+    \item Typinferenz
+\end{enumerate}
+
+Haskell kann mit \enquote{Glasgow Haskell Compiler} mittels 
+\texttt{ghci} interpretiert und mittels 
+
+\section{Erste Schritte}
+Haskell kann unter \href{http://www.haskell.org/platform/}{\path{www.haskell.org/platform/}}
+für alle Plattformen heruntergeladen werden. Unter Debian-Systemen
+ist das Paket \texttt{ghc} bzw. \texttt{haskell-platform} relevant.
 
 \section{Syntax}
+\subsection{Klammern}
+Haskell verzichtet an vielen Stellen auf Klammern. So werden im
+Folgenden die Funktionen $f(x) := \frac{\sin x}{x}$ und $g(x) := x \cdot f(x^2)$
+definiert:
+
+\inputminted[numbersep=5pt, tabsize=4]{haskell}{scripts/haskell/einfaches-beispiel-klammern.hs}
+
+\subsection{if / else}
+Das folgende Beispiel definiert den Binomialkoeffizienten 
+\[\binom{n}{k} := \begin{cases}
+        1                               &\text{falls } k=0 \lor k = n\\
+        \binom{n-1}{k-1}+\binom{n-1}{k} &\text{sonst}
+        \end{cases}\]
+für $n,k \geq 0$:
+
+\inputminted[numbersep=5pt, tabsize=4]{haskell}{scripts/haskell/binomialkoeffizient.hs}
+\inputminted[numbersep=5pt, tabsize=4]{bash}{scripts/haskell/compile-binom.sh}
+
+\todo[inline]{Guards}
+
+\subsection{Rekursion}
+Die Fakultätsfunktion wurde wie folgt implementiert:
+\[fak(n) := \begin{cases}
+        1              &\text{falls } n=0\\
+        n \cdot fak(n) &\text{sonst}
+    \end{cases}\]
+\inputminted[numbersep=5pt, tabsize=4]{haskell}{scripts/haskell/fakultaet.hs}
+
+Diese Implementierung benötigt $\mathcal{O}(n)$ rekursive Aufrufe und
+hat einen Speicherverbrauch von $\mathcal{O}(n)$. Durch einen
+\textbf{Akkumulator}\xindex{Akkumulator} kann dies verhindert werden:
+\inputminted[numbersep=5pt, tabsize=4]{haskell}{scripts/haskell/fakultaet-akkumulator.hs}
+
+\todo[inline]{Endrekursion ... macht für mich unter "Haskell" wenig sinn. Vielleicht einen neuen Abschnitt mit Techniken? Was würde da noch landen?}
+
 \section{Beispiele}
+\subsection{Hello World}
+Speichere folgenden Quelltext als \texttt{hello-world.hs}:
+\inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=hello-world.hs]{haskell}{scripts/haskell/hello-world.hs}
+
+Kompiliere ihn mit \texttt{ghc -o hello hello-world.hs}. Es wird eine
+ausführbare Datei erzeugt.
+
+\subsection{Fibonacci}
 \inputminted[linenos, numbersep=5pt, tabsize=4, frame=lines, label=fibonacci.hs]{haskell}{scripts/haskell/fibonacci.hs}
 
+\subsection{Quicksort}
+
+\section{Weitere Informationen}
+\begin{itemize}
+    \item \href{http://www.haskell.org/hoogle/}{\path{haskell.org/hoogle}}: Suchmaschine für das Haskell-Manual
+    \item \href{http://wiki.ubuntuusers.de/Haskell}{\path{wiki.ubuntuusers.de/Haskell}}: Hinweise zur Installation von Haskell unter Ubuntu
+\end{itemize}
+
 \index{Haskell|)}
 

documents/Programmierparadigmen/Programmierparadigmen.tex

@@ -90,6 +90,7 @@
 \setcounter{page}{1}
 \input{Programmiersprachen}
 \input{Haskell}
+\input{Prolog}
 \input{Scala}
 \input{X10}
 \input{C}

documents/Programmierparadigmen/Programmiersprachen.tex

@@ -25,6 +25,20 @@ man Probleme löst.
     lösen.
 \end{definition}
 
+Haskell ist eine funktionale Programmiersprache, C ist eine
+nicht-funktionale Programmiersprache.
+
+Wichtige Vorteile von funktionalen Programmiersprachen sind:
+\begin{itemize}
+    \item Sie sind weitgehend (jedoch nicht vollständig) frei von Seiteneffekten.
+    \item Der Code ist häufig sehr kompakt und manche Probleme lassen
+          sich sehr elegant formulieren.
+\end{itemize}
+
+\begin{definition}[Logisches Paradigma]\xindex{Programmierung!logische}
+    In der logischen Programmierung baut man Unifikation.\todo{genauer!}
+\end{definition}
+
 \section{Typisierung}
 Eine weitere Art, Programmiersprachen zu unterscheiden ist die stärke
 ihrer Typisierung.
@@ -40,3 +54,20 @@ Beispiele sind Python und PHP.
 \end{definition}
 
 Beispiele sind C, Haskell und Java.
+
+\section{Kompilierte und interpretierte Sprachen}
+Sprachen werden überlicherweise entweder interpretiert oder kompiliert,
+obwohl es Programmiersprachen gibt, die beides unterstützen.
+
+C und Java werden kompiliert, Python und TCL interpretiert.
+
+\section{Dies und das}
+\begin{definition}[Seiteneffekt]\xindex{Seiteneffekt}\xindex{Nebeneffekt}\xindex{Wirkung}
+    Seiteneffekte sind Veränderungen des Zustandes.\todo{Das geht besser}
+\end{definition}
+
+Manchmal werden Seiteneffekte auch als Nebeneffekt oder Wirkung bezeichnet.
+
+\begin{definition}[Unifikation]\xindex{Unifikation}
+    \todo[inline]{Was ist das?}
+\end{definition}

documents/Programmierparadigmen/Prolog.tex

@@ -0,0 +1,7 @@
+\chapter{Prolog}
+\index{Prolog|(}
+\section{Syntax}
+\section{Beispiele}
+
+\index{Prolog|)}
+

documents/Programmierparadigmen/Vorwort.tex

@@ -1,10 +1,15 @@
 \chapter*{Vorwort}
-Dieses Skript wird/wurde im Wintersemester 2013/2014 geschrieben
-von Martin Thoma geschrieben.
+Dieses Skript wird/wurde im Wintersemester 2013/2014
+von Martin Thoma geschrieben. Das Ziel dieses Skriptes ist vor allem
+in der Klausur als Nachschlagewerk zu dienen; es soll jedoch auch
+vorher schon für die Vorbereitung genutzt werden können und nach
+der Klausur als Nachschlagewerk dienen.
 
 \section*{Was ist Programmierparadigmen?}
 
 TODO
 
 \section*{Erforderliche Vorkenntnisse}
-TODO
+Grundlegende Kenntnisse vom Programmieren, insbesondere mit Java,
+wie sie am KIT in \enquote{Programmieren} vermittelt werden, werden
+vorausgesetzt.

documents/Programmierparadigmen/scripts/haskell/binomialkoeffizient.hs

@@ -0,0 +1,4 @@
+binom n k =
+    if (k==0) || (k==n)
+    then 1
+    else binom (n-1) (k-1) + binom (n-1) k

documents/Programmierparadigmen/scripts/haskell/compile-binom.sh

@@ -0,0 +1,9 @@
+$ ghci binomialkoeffizient.hs 
+GHCi, version 7.4.2: http://www.haskell.org/ghc/  :? for help
+Loading package ghc-prim ... linking ... done.
+Loading package integer-gmp ... linking ... done.
+Loading package base ... linking ... done.
+[1 of 1] Compiling Main             ( binomialkoeffizient.hs, interpreted )
+Ok, modules loaded: Main.
+*Main> binom 5 2
+10

documents/Programmierparadigmen/scripts/haskell/einfaches-beispiel-klammern.hs

@@ -0,0 +1,2 @@
+f x = sin x / x
+g x = x * (f (x*x))

documents/Programmierparadigmen/scripts/haskell/fakultaet-akkumulator.hs

@@ -0,0 +1,2 @@
+fakAcc n acc = if (n==0) then acc else fakAcc (n-1) (n*acc)
+fak n = fakAcc n 1

documents/Programmierparadigmen/scripts/haskell/fakultaet.hs

@@ -0,0 +1 @@
+fak n = if (n==0) then 1 else n * fak (n-1)

documents/Programmierparadigmen/scripts/haskell/hello-world.hs

@@ -0,0 +1 @@
+main = putStrLn "Hello, World!"