\begin{slide}{Implementierung in Haskell}

\begin{verbatim}
map_reduce :: ( Ord ki, Ord ko ) 
  => ( (ki, vi) -> [(ko,vm)] )  -- ^ distribute
  -> ( ko -> [vm] -> Maybe vo ) -- ^ collect
  -> Map ki vi -- ^ eingabe  
  -> Map ko vo -- ^ ausgabe
map_reduce distribute collect input 
    = M.map ( \ ( Just x ) -> x ) 
    $ M.filter isJust   
    $ M.mapWithKey collect
    $ M.fromListWith (++) 
    $ map ( \ (ko,vm) -> (ko,[vm]) )
    $ concat $ map distribute
    $ M.toList $ input
\end{verbatim}


\end{slide}

\begin{slide}{Anwendung: Wörter zählen}

\begin{verbatim}
main :: IO ()
main = do
  files <- getArgs
  texts <- forM files readFile
  let input = M.fromList $ zip files texts
      output = map_reduce    
        ( \ (ki,vi) -> map ( \ w -> (w,1) )
                           ( words vi ) )
        ( \ ko nums -> Just ( sum nums))
        input
  print $ output        
\end{verbatim}
wo liegen die Möglichkeiten zur Parallelisierung?

(in diesem Programm nicht sichtbar.)
\end{slide}
