Zobrazení zdroje stránky Monáda (funkcionální programování)

'''Monáda''' je [[Funktor|funktoriální]] [[datový typ]] vybavený dvěma přirozenými transformacemi umožňujícími [[Asociativita|asociativní]] skládání operací nad monádami. Formálně je monáda [[monoid]]em v kategorii [[Endofunktor|endofunktorů]] v kategorii typů (v [[Haskell (programovací jazyk)|Haskellu]] kategorie '''Hask'''). Obecně je-li <math>(\mathcal{C},\otimes,I)</math> [[Tenzor|tenzorová]] [[Kategorie (matematika)|kategorie]] (kde <math>\otimes</math> je bifunktor a <math>I \in \mathrm{Ob}(\mathcal{C})</math>), monády jsou monoidy v <math>([\mathcal{C},\mathcal{C}],\circ,I)</math>.

[[Přirozená transformace|Přirozené transformace]] jsou u každé monády <math>T</math> multiplikace <math>\mu:T^2 \rightarrow T</math> a jednotka <math>\eta:I \rightarrow T</math> splňující <math>\mu \circ \mu T = \mu \circ T\mu (T^3 \rightarrow T)</math> a <math>\mu \circ \eta T = 1 = \mu \circ T\eta</math>. Ve [[Funkcionální programování|funkcionálním programování]] se tyto operace zpravidla nazývají '''join''' a '''unit'''. Příkladem monády je [[continuation|kontinuace]], kde <math>\eta</math> je funkcí z <math>A</math> do <math>(A \rightarrow R) \rightarrow R</math> definovaná jako <math>\eta x=\lambda f.f(x)</math> a
speciální operace vázání je <math>m >\!\!\!>\!\!= f = \lambda g.m(\lambda x.f(x)(g))</math>,
přičemž <math>\mu x</math> je <math>x >\!\!\!>\!\!= \lambda y.y</math>.

Monády umožňují formulovat kód s vedlejšími efekty tak, aby byl [[referenční průhlednost|referenčně transparentní]], a tedy „čistý“ (ve funkcionálním smyslu). Monády jsou zpravidla generické a jejich [[druh (teorie typů)|druh]] je <math>(* \rightarrow *) \rightarrow *</math>.

Z každého endofunktoru lze vytvořit [[volná monáda|volnou monádu]].

== Příklad ==
[[Continuation|Kontinuace]] v [[C++]] lze reprezentovat (s využitím statického [[Polymorfismus (programování)|polymorfismu]]) následující [[Třída (programování)|třídou]]:

<syntaxhighlight lang="cpp">
template<typename T> class Cont {
    std::function<std::any(const std::function<std::any(T)>&)> fn;
public:
    Cont(const decltype(fn)& f) : fn(f) {}
    Cont(T&& x) : fn([x](auto f) { return f(x); }) {}
    std::any operator()(const std::function<std::any(T)>& f) const { return fn(f); }
};
</syntaxhighlight>

Aby byla '''Cont''' funktorem, musíme implementovat '''fmap''' nebo '''bind''':

<syntaxhighlight lang="cpp">
template<template<typename> class M, typename T, typename U> struct Bind;
template<typename T, typename U> struct Bind<Cont,T,U> {
    std::function<Cont<U>(T)> f;
    auto operator()(const Cont<T>& m) {
        return [this,m](auto g) {
            return m([this,g](auto x) { return f(x)(g); });
        };
    }
};
</syntaxhighlight>

C++ nemá typy vyšších [[Druh (teorie typů)|druhů]], nicméně pomocí specializace šablon můžeme dosáhnout stejného efektu.
Konkrétně můžeme například definovat generické monadické operace '''fmap''' a '''join'''.

<syntaxhighlight lang="cpp">
template<template<typename> class M, typename T, typename U> struct Fmap {
    std::function<U(T)> f;
    auto operator()(const M<T>&) const;
};

template<template<typename> class M, typename T> struct Join {
    auto operator()(const M<M<T>>&) const;
};

template<template<typename> class M, typename T, typename U> auto Fmap<M,T,U>::operator()(const M<T>& m) const {
    std::cerr << "generic fmap" << std::endl;
    return Bind<M,T,U>{[&](auto x) { return M<U>{f(x)}; }}(m);
}

template<template<typename> class M, typename T> auto Join<M,T>::operator()(const M<M<T>>& m) const {
    std::cerr << "generic join" << std::endl;
    return Bind<M,M<T>,T>{[](M<T> x) { return x; }}(m);
}
</syntaxhighlight>

Takto koncipovaný kód má tu výhodu, že poskytuje definice monadických funkcí bez ohledu na konkrétní typ. Proto stačí pro konkrétní monadický typ implementovat pouze buď '''bind''', nebo '''fmap''' a '''join''', podobně jako v čistě funkcionálních jazycích à la [[Haskell (programovací jazyk)|Haskell]].

== Externí odkazy ==
* [https://web.archive.org/web/20171015150120/https://scitech.blog/article?id=14e7d734f959f9b3-9bb465d0-8f580c8c-085d8148-f645e774 A monad is...]
{{Autoritní data}}

[[Kategorie:Funkcionální programování]]
[[Kategorie:Teorie kategorií]]