2. Struktur von Monads

• Ein Monad ist ein Typ für den die Operatoren bind und return definiert sind.
• In Haskell wird von der Klasse Monad der Operator >>= für die Operation bind verwendet.
• Die Definition der Klasse Monad in der Hakell Prelude ist

  class Monad m where
    (>>=)  :: m a -> ( a -> m b ) -> m b
    return :: a -> m a
    (>>)   :: m a -> m b -> m b
    fail   :: String -> m a
  
    m >> k = m >>= \_ -> k
    fail s = error s
  

• >> verknüpft, wie >>= zwei Berechnungen und verwirft das Ergebnis der ersten.
• return ist das Nullelement der Operation >>=, und >>= ist assoziativ:

  return a >>= k   = k a
  m >>= return     = m
  m >>= (\x -> k x >>= h) = (m >>= k) >>= h
  

• Die Signatur einer Funktion, die innerhalb des Monads arbeitet, ist (Monad a) => a b.

  hello :: String -> IO ()
  hello x = putStr ("Hello " ++ x)
  

• Es ist sinnvoll, eine Funktion extract zu definieren, wenn eine Berechnung außerhalb des Monads keine Seiteneffekte hat.

2.1 Das Identity-Monad

• Das einfachste Monad.
• Berechnungen in dem Identity-Monad unterscheiden sich nicht von normalen Funktionen.
• Das Identity-Monad ist definiert durch

  data Id a  = Id a
  instance Monad Id where
    (Id x) >>= f  = f x
    return x      = Id x
    (Id _) >>  f  = f
    fail s        = error s
  
  extract :: Id a -> a
  extract (Id x) = x
  

• Beispiel

  mul      :: Int -> Int -> Id Int
  mul x y  =  return (x * y)
  
  div_     :: Int -> Int -> Id Int
  div_ _ 0 =  fail "div 0"
  div_ x y =  return (x ´div´ y)
  
  one      :: Int -> Id Int
  one x    =  mul x x >>= \_ ->
              mul x 1 >>= \y ->
              div_ y x
  
  > one 5 ==> 1
  > one 0 ==> Fehler des Interpreters: "div 0"
  

2.2 die do-Notation

• Vereinfachte Schreibweise von Ausdrücken mit den Operatoren >>= und >>.
• Diese beiden Funktionsdefinitionen sind identisch.

  one x    =  mul x x >>              one x   = do mul x x
              mul x 1 >>= \y ->                    y <- mul x 1
              div_ y x                             div_ y x
  

• Es ist möglich Zwischenergebnisse mit let an einen Namen zu binden.

  one x   = do mul x x
               let eins = 1 in
               y <- mul x eins
               div_ y x
  

• Ausdrücke in der do-Notation lassen sich leicht in Ausdrücke mit >>= und return umwandeln.
• Die Notation sieht der von imperativen Programmiersprachen ähnlich.
• Anstatt des Codelayout können auch geschweifte Klammern und Semikolons verwendet werden.

  one x = do { mul x x; y <- mul x 1; div_ y x; }