\begin{slide}{Beispiel: Interpreter (I)}

arithmetische Ausdrücke:
\begin{verbatim}
data Exp = Const Integer 
         | Plus Exp Exp | Times Exp Exp
    deriving ( Show )
ex1 :: Exp
ex1 = Times ( Plus ( Const 1 ) ( Const 2 ) ) ( Const 3 )
value :: Exp -> Integer
value x = case x of
    Const i -> i
    Plus x y -> value x + value y
    Times x y -> value x * value y
\end{verbatim}
\end{slide}

\begin{slide}{Beispiel: Interpreter (II)}
lokale Variablen und Umgebungen:

\begin{small}
\begin{verbatim}
data Exp = ...
         | Let String Exp Exp | Ref String
ex2 :: Exp
ex2 = Let "x" ( Const 3 ) 
     ( Times ( Ref "x" ) (Ref "x" ) )
type Env = ( String -> Integer )
value :: Env -> Exp -> Integer
value env x = case x of
    Ref n -> env n
    Let n x b -> value ( \ m -> 
      if n == m then value env x else env m )  b
    Const i -> i
    Plus x y -> value env x + value env y
    Times x y -> value env x * value env y
\end{verbatim}
\end{small}
\end{slide}

\begin{slide}{Übung (Haskell)}

  \begin{itemize}
  \item
    Wiederholung Haskell
    \begin{itemize}
    \item Interpreter/Compiler: ghci \url{http://haskell.org/}
    \item Funktionsaufruf nicht \verb|f(a,b,c+d)|, sondern \verb|f a b (c+d)|
    \item Konstruktor beginnt mit Großbuchstabe und ist auch eine Funktion
    \end{itemize}
  \item 
    Wiederholung funktionale Programmierung/Entwurfsmuster
    \begin{itemize}
    \item rekursiver algebraischer Datentyp (ein Typ, mehrere Konstruktoren)

      (OO: Kompositum, ein Interface, mehrere Klassen)
    \item rekursive Funktion
    \end{itemize}
  \item
    Wiederholung Pattern Matching:
    \begin{itemize}
    \item beginnt mit \verb|case ... of|, dann  Zweige
    \item jeder Zweig besteht aus Muster und Folge-Ausdruck
    \item falls das Muster paßt, werden die Mustervariablen gebunden
      und der Folge-Ausdruck auswertet
    \end{itemize}

  \end{itemize}
\end{slide}  

\begin{slide}{Übung (Interpreter)}
  \begin{itemize}\itemsep 0pt
\item Benutzung:

  \begin{itemize}
  \item Beispiel für die Verdeckung von Namen bei geschachtelten Let
  \item Beispiel dafür, daß der definierte Name
    während seiner Definition nicht sichtbar ist
  \end{itemize}

\item Erweiterung:

Verzweigungen mit C-ähnlicher Semantik:

Bedingung ist arithmetischer Ausdruck,
verwende 0 als Falsch und alles andere als Wahr.

\begin{verbatim}
data Exp = ...
         | If Exp Exp Exp
\end{verbatim}

  \end{itemize}


\end{slide}
