\begin{slide}{Streams}

für bessere Programmstruktur: Trennung von
\begin{itemize}
\item Produzent
\item Transformator(en)
\item Konsument
\end{itemize}

\begin{verbatim}
sum $ map ( \ x -> x ^3 ) $ [ 1 .. 100 ]
\end{verbatim}
aus Effizienzgründen \emph{verschränkte} Auswertung

\begin{itemize}
\item Pipes zwischen Prozessen, 
\item Enumeratoren in OO.
\end{itemize}

\end{slide}

\begin{slide}{Laziness}

in Haskell: Listen \emph{sind} Streams,
der Tail wird erst bei Bedarf ausgewertet.

\bigskip
\emph{jeder} Wert wird erst bei Bedarf ausgewertet.

\bigskip
wann genau? Kann man nicht beobachten. 
Die Auswertung hat keine Nebenwirkungen.

\bigskip

eine unendliche Datenstruktur:
\begin{verbatim}
naturals :: [ Integer ]
naturals = from 0 where
    from x = x : from (x+1)
\end{verbatim}
Liste aller Quadratzahlen? Primzahlen?

\end{slide}

\begin{slide}{Laziness: Anwendungen}

Bindungsreihenfolge in let-Blöcken ist egal:
\begin{verbatim}
let  xs = 'a' : ys
     ys = 'b' : zs
     zs = 'c' : xs
in   xs
\end{verbatim}

\bigskip

If-then-else könnte als Funktion geschrieben werden
(kein Makro nötig)
\begin{verbatim}
ite b y n = 
    case b of { True -> y ; False -> n }
\end{verbatim}

\end{slide}

\begin{slide}{Aufgabe}

schreibe eine Funktion,
die jeden Schlüssel eines Baumes durch die Summe aller Schlüssel ersetzt
\begin{verbatim}
sum = fold 0 ( \ x y z -> x + y + z ) 
replace r = 
      fold Leaf ( \ x y z -> Branch x r z ) 

sumrep :: Tree Int -> Tree Int
sumrep t = replace ( sum t ) t
\end{verbatim}
und den Baum nur \emph{einmal} durchquert.

\end{slide}

\begin{slide}{Hinweis}

mit einer so spezifizierten Hilfsfunktion
\begin{verbatim}
help :: Int -> ( Tree Int ) 
     -> ( Tree Int, Int )
help r t = ( replace r t, sum t )
\end{verbatim}

\bigskip

kann man die Aufgabe lösen:
\begin{verbatim}
sumrep t = 
    let ( u, s ) = help s t  in  u
\end{verbatim}

\bigskip
\dots wenn man \verb|help| als \emph{ein}  \verb|fold| schreibt!

\end{slide}
