Monada (programowanie)

Monada – w programowaniu funkcyjnym: rodzaj konstruktora abstrakcyjnego typu danych, który implementuje funkcje wiązania (ang. bind) oraz jednostki (ang. unit)^[1][2]. Pojęcie to wywodzi się z teorii kategorii, gdzie omawiany abstrakt stanowi monadę nad kategorią typów z funkcjami jako morfizmami. Jednostka określa operację tworzenia singletonu czy też akcji, której wynikiem jest zadana wartość. Wiązanie (w niektórych językach określane jako flat map) buduje na podstawie wyniku poprzedniego obliczenia nowe obliczenie, zachowując przy tym jego formę.

Jedną z głównych cech monad jest to, że pozwalają wynieść pewne mechanizmy i zachowania do abstrakcji, zwalniając tym samym programistę z konieczności ręcznej obsługi kontekstu. Przykładowo, działając na (jakkolwiek zdefiniowanych) zbiorach można opisać jednostkę jako

${\displaystyle unit:A\to P(A)}$

${\displaystyle unit(x)=\{x\}}$

oraz wiązanie jako

${\displaystyle bind:P(A)\to (A\to P(B))\to P(B)}$

${\displaystyle bind(s,f)=\bigcup \{f(x)|x\in s\}}$

by potem w sposób generyczny budować potoki danych w kompletnym oderwaniu od wewnętrznej implementacji czy nawet interpretacji. Dla przykładu konstruowanie iloczynu kartezjańskiego dwóch zbiorów mogłoby przebiegać tak:

${\displaystyle prod(A,B)=bind(A,\lambda a\to bind(B,\lambda b\to unit(\langle a,b\rangle ))).}$

Istotne w tym przykładzie to, że przy definiowaniu operacji prod ani razu nie skorzystano z faktu, że nośnikiem danych jest matematyczny zbiór. Będzie ona zatem działać dla każdej monady, bez względu na jej wewnętrzną reprezentację.

To podejście stanowi popularny wzorzec projektowy, który ma szerokie zastosowanie przy definiowaniu obliczeń zawierających dodatkowe reguły przetwarzające, jak chociażby transformowanie stanu, współbieżność, obsługę wejścia-wyjścia lub wyjątków.

W Haskellu monada jest klasą zrzeszającą typy o rodzaju ${\displaystyle *\to *}$

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

Operacje wiązania >> oraz >>= łączą ze sobą dwie wartości monadyczne, podczas gdy operacja return umieszcza wartość w monadzie. Operator >>= formuje wartość monadyczną obliczającą wynik typu b na podstawie wyniku lewego argumentu będącego wartością monadyczną z wynikiem typu a. Funkcja >> jest używana wtedy, gdy przebieg wiązania nie zależy od wyniku lewego argumentu, a jedynie od jego kontekstu. Haskell posiada syntaktyczne wsparcie monad przy użyciu tzw. notacji do:

bez_do :: (Monad m, Alternative m) => m Int -> m Int -> m Int
bez_do m1 m2 =
  m1 >>= \x1 -> m2 >>= \x2 -> guard (x2 /= 0) >> return (x1 / x2)

z_do :: (Monad m, Alternative m) => m Int -> m Int -> m Int
z_do m1 m2 = do
  x1 <- m1
  x2 <- m2
  guard (x2 /= 0)
  return (x1 / x2)

W Scali monadą jest każda klasa, która implementuje operacje flatMap oraz unit

trait M[A] {
  def flatMap[B](f: A => M[B]): M[B]
}

def unit[A](x: A): M[A]

Odpowiednikiem notacji do w Scali jest for comprehensions:

def bez_for(m1 : M[Int], m2 : M[Int]) : M[Int] =
  m1.flatMap(x1 => m2.flatMap(x2 => unit[M](x1 + x2)))

def z_for(m1 : M[Int], m2 : M[Int]) : M[Int] =
  for {
    x1 <- m1
    x2 <- m2
  } yield (x1 + x2)