In der funktionalen Programmierung sind Monaden ein abstrakter Datentyp. Wesentliche Eigenschaft von Monaden ist die Fähigkeit der Übertragung von Werten und Berechnungen eines „einfacheren“ Typs zu Berechnungen eines „höheren“ Typs, der mittels eines Typkonstruktors aus dem einfacheren Typ hervorgeht, sowie die Verknüpfung mehrerer solcher Übertragungen zu einer einzigen.

Hintergrund

Der Hauptnutzen von Monaden ist es, Ein- und Ausgabeoperationen, zustandsbehaftete Berechnungen, Nichtdeterminismus (auch als Iteration über Kollektionen und ihren Kombinationen interpretierbar) und Anderes auszudrücken. Dabei soll die Sprache keine Nebeneffekte einführen.

Das Konzept der Monade stammt aus der Kategorientheorie, einem Zweig der Mathematik, welcher mathematische Objekte mittels Morphismen oder Funktoren vergleicht. Die Wörter Monade oder aber auch Funktor sind wiederum von Konzepten in der Philosophie abgeleitet.

Die Programmiersprache Haskell ist eine funktionale Sprache, die Monaden stark einsetzt und versucht, monadische Kompositionen zu vereinfachen, beispielsweise durch syntaktischen Zucker (u. a. die sogenannte do-Notation).

Definitionen

Die übliche Formulierung einer Monade in der Programmierung hat folgende Komponenten:

1. Ein Typkonstruktor, der für jeden zugrunde liegenden Typ definiert, wie der korrespondierende Monadentyp zu erhalten ist. Der Name dieses Typkonstruktors wird dabei oft synonym mit der ganzen Monade verwendet. Wenn M der Name der Monade und t der Datentyp ist, so ist M t der korrespondierende monadische Typ.
2. Eine Einheitsfunktion, die einen Wert des zugrunde liegenden Typs auf den Wert des korrespondierenden Monadentyps abbildet. Das Ergebnis ist der "einfachste" Wert im korrespondierenden Typ, der sich aus dem Originalwert gewinnen lässt. In Haskell wird diese Funktion return genannt. Die Einheitsfunktion hat den polymorphen Typ t→M t.
3. Mindestens eine weitere Operation (siehe dazu die folgenden Abschnitte), welche die Verknüpfung monadischer Operationen beschreibt.

Die folgenden Operationen sind typisch für Monaden und können für deren Definition Verwendung finden:

1. Die Einheitsfunktion

   return :: a -> m a
   

2. Der bind-Operator

   (>>=) :: m a -> (a -> m b) -> m b
   

   erlaubt, einen monadischen Typ an eine Funktion zu übergeben, die nur den zugrundeliegenden Typ verwendet. Sein erstes Argument ist ein Wert von monadischem Typ und sein zweiter ist eine Funktion, die vom zugrunde liegenden Typ des ersten Arguments auf einen anderen monadischen Typ abbildet. Der Rückgabewert ist vom anderen Monadentyp.
3. Der Kleisli-Operator

   (>=>) :: (a -> m b) -> (b -> m c) -> (a -> m c)
   

   realisiert eine Komposition (Hintereinanderausführung) für Funktionen, die einen monadischen Typ zurückgeben, aber nur den jeweils zugrundeliegenden Typ verwenden.
4. Der Funktor

   fmap :: (a -> b) -> m a -> m b
   

   erlaubt, einen monadischen Typ an eine Funktion zu übergeben, die nur den zugrundeliegenden Typ verwendet. Sein erstes Argument ist eine Funktion f, von einem beliebigen Typ a auf einen beliebigen Typ b abbildet. Sein zweites Argument ist ein Wert von einem monadischen Typ, dem der Typ a des Argumentes von f zugrunde liegt. Der Rückgabewert ist von einem monadischen Typ, dem der Typ b des Rückgabewertes von f zugrunde liegt.
5. Eine natürliche Transformation

   join :: m (m a) -> m a
   

   welche ein „Abflachen“ des monadischen Typs um eine Verschachtelungsebene erlaubt (dabei steht m für den Typkonstruktor).

Diese Operationen müssen folgenden Gesetzen gehorchen:

1. "Assoziativität" von >>=

     (ma >>= f) >>= g == ma >>= ( \a -> ((f a) >>= g) )
   

2. Assoziativität von >=>

     (f >=> g) >=> h  == f >=> (g >=> h)
   

3. Kompatibilität von Verkettung und fmap

         fmap (f . g) == (fmap f) . (fmap g)
   

4. join ist eine natürliche Transformation von fmap . fmap auf fmap

      (fmap f) . join == join . ((fmap . fmap) f)
   

5. Kommutativität von fmap und join

         join . join  == join . (fmap join) -- das zweite join hat den typ m (m (m a)) -> m (m a)
   

6. return ist eine natürliche Transformation von id auf fmap

    (fmap f) . return == return . f
   

7. Neutralität von return unter >>=

         ma >>= return == ma
      (return a) >>= f == f a
   

8. Neutralität von return unter >=>

         f >=> return == return >=> f == f
   

9. Neutralität von return unter >=>, in fmap/join-Notation

        join . return == join . (fmap return) == id
   

class Monad m where
  return ::   a -> m a
  (>>=)  :: m a -> (a -> m b) -> m b

(f >=> g) a = f a >>= g
(fmap f) ma =  ma >>= (return . f)
   join mma = mma >>= id

class Monad m where
  return ::  a -> m a
  (>=>)  :: (a -> m b) -> (b -> m c) -> (a -> m c)

   ma >>= f = (id >=>  f)  ma
     fmap f =  id >=> (return . f)
       join =  id >=> id

class Monad m where
  fmap   :: (a -> b) -> m a -> m b
  return ::       a  ->  m a
  join   ::  m (m a) ->  m a

   ma >>= f = (join . (fmap f)) ma
    f >=> g =  join . (fmap g) . f

Beziehungen zu anderen Typklassen

Jede Monade ist auch ein Applikativer Funktor und mithin auch ein Funktor. Umgekehrt gilt das nicht.

Diese Eigenschaft fand sich aus historischen Gründen nicht explizit in Haskells Standardbibliothek, der Glasgow Haskell Compiler hat dies jedoch mit Version 7.10 eingeführt.

Besonders deutlich wird diese Beziehung auch, vergleicht man die kategorientheoretische Definition mit der Funktor-Klasse in Haskell:

class Functor f where
  fmap   :: (a -> b) -> f a -> f b

Dabei muss fmap ebenfalls die Kompatibilitätsbedingung mit der Komposition (.) erfüllen.

Beispiele

-- Hier nochmal zur Erinnerung, der Listentyp ist folgendermaßen definiert:
data [a] = [] | a:[a]
-- Als syntaktischer Zucker kann [a,b,c] für a:b:c:[] verwendet werden.

instance Monad [] where
--return :: a -> [a]
  return a = [a] -- Per Definition eine Liste mit einem Element zurückgeben
--(>>=) :: [a] -> (a -> [b]) -> [b]
  liste >>= f  = concat zwischenergebnis where -- Die einzelnen Teillisten zusammenfügen
    zwischenergebnis :: [[b]]
    zwischenergebnis = map f liste -- Die Funktion auf die Liste abbilden

-- Den Zähler hochzählen und den alten Zähler zurückgeben
hochzählen :: Int -> Int -> (Int,Int)
hochzählen schrittweite zählerstand = (zählerstand,neuerZählerstand) where ...

data Status s a = Status (s -> (a,s))

-- Beispiel:
hochzählen :: Int -> Status Int Int
hochzählen schrittweite = Status $ \zählerstand -> (zählerstand,zählerstand+schrittweite)

setStatus :: s -> Status s ()
setStatus s = Status $ \_ -> ((),s) -- Der alte Status wird ignoriert und durch den neuen ersetzt. Rückgabewert, da unnötig, ().

getStatus :: Status s s
getStatus = Status $ \s -> (s,s) -- Dupliziere den Status in den Rückgabewert.

instance Monad (Status s) where -- Die Typvariable  s ist irrelevant für die Definition
--return :: a -> Status s a
  return a = Status $ \s -> (a,s) -- Status bleibt unverändert
--(>>=)  :: Status s a -> (a -> Status s b) -> Status s b
  (Status aktion1) >>= f = Status $ \s -> aktion2 zwischenstatus where -- Status aus aktion1 in aktion2 einspeisen.
    (rückgabe1,zwischenstatus) = aktion1 s   -- aktion1 ausführen
    Status aktion2              = f rückgabe1 -- Rückgabewert aus aktion1 in f einspeisen

hochzählen :: Int -> Status (Int,Int)
hochzählen schrittweite = do zählerstand <- getStatus -- Zählerstand ermitteln
                             setStatus (zählerstand + schrittweite) -- Zähler setzen
                             return zählerstand -- alten Zählerstand zurückgeben

-- Hier entzuckert
hochzählen schrittweite = getStatus >>= \zählerstand ->
                          setStatus (zählerstand + schrittweite) >>= \_ ->
                          return zählerstand

Andere Sprachen

LINQ-Abfrageausdrücke in C# sind direkt inspiriert von Haskells do-Notation. Ein Analogon zur Typklasse Monad ist in C# jedoch nicht ausdrückbar; der Compiler übersetzt LINQ-Abfrage-Ausdrücke blind in Aufrufe von Methoden mit festgelegten Namen. Diese sind Select und SelectMany. Auch benutzerdefinierte Klassen können also mittels LINQ-Abfrageausdrücken angesprochen werden, wenn diese Methoden mit entsprechenden Namen zur Verfügung stellen.

Dieselbe Strategie verfolgt Scala im Fall von for-Comprehensions. Die Methoden heißen da map und flatMap.

In der Standardbibliothek von Java 8 sind mindestens zwei Monaden vorhanden, die derselben Namenskonvention gehorchen: die Schnittstellen Optional und Stream definieren Methoden namens map, flatMap und of.

Weblinks

• Papers von Philip Wadler
• You Could Have Invented Monads! (And Maybe You Already Have.)
• What a Monad is not
• Brent Yorgey: Typeclassopedia (PDF; 722 kB) in: The Monad.Reader Issue 13

Einzelnachweise

1. ↑ Simon L. Peyton Jones, Philip Wadler: Imperative Functional Programming. Conference record of the Twentieth Annual ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages, Charleston SC 1993
2. ↑ https://downloads.haskell.org/~ghc/7.10.1/docs/html/users_guide/release-7-10-1.html
3. ↑ Erik Meijer: The World According to LINQ. (acm.org). 
4. ↑ http://www.scala-lang.org/files/archive/spec/2.11/06-expressions.html
5. ↑ Monads in Groovy
6. ↑ Monads in Python
7. ↑ Monads in Scala (Memento des Originals vom 7. Juni 2011 im Internet Archive)  Info: Der Archivlink wurde automatisch eingesetzt und noch nicht geprüft. Bitte prüfe Original- und Archivlink gemäß Anleitung und entferne dann diesen Hinweis.@1@2Vorlage:Webachiv/IABot/lamp.epfl.ch
8. ↑ Monads in Clojure
9. ↑ Monads in JavaScript (Memento vom 22. Dezember 2010 im Internet Archive)
10. ↑ Wes Dyer: The Marvels of Monads. In: Yet Another Language Geek. MSDN Blogs, Microsoft, 10. Januar 2008, abgerufen am 21. März 2013. 
11. ↑ Mike Hadlow: Monads in C#. In: Code Rant. 9. Januar 2011, abgerufen am 21. März 2013. 
12. ↑ Muraad Nofal: Monads-CSharp. In: GitHub. 10. März 2014, abgerufen am 21. März 2013.