Monadă (informatică)

În programarea funcțională , o monadă este o structură care exprimă o clasă de calcule concatenabile.

Cu ajutorul acestei structuri, este posibil să se efectueze operații secvențiale, chiar și în limbaje pur funcționale , cam așa cum se întâmplă în limbaje imperative sau procedurale . De fapt, fenomene precum efectele secundare , egoul , gestionarea excepțiilor pot fi exprimate cu ajutorul monadelor.

În Haskell , clasa Monad este exprimată după cum urmează ^[1] :

 clasa Monad m unde
  ( >> = ) :: m a -> ( a -> m b ) -> m b
  ( >> ) :: m a -> m b -> m b - nu este strict necesar
  return :: a -> m a
  fail :: String -> m a - nu este strict necesar

Istorie

În anii 1960 , unele limbaje de programare, cum ar fi J și APL , care tindeau să fie limbaje pur funcționale, foloseau termenul de monadă pentru a indica funcții care aveau un singur parametru de intrare. Acest termen a fost opus celui de dyad, adică toate acele funcții având doi parametri în loc de unul singur. După cum se va vedea mai jos, structuri complet diferite vor fi identificate cu monade.

De fapt, în 1991 , Eugenio Moggi , profesor de informatică la Universitatea din Genova , a publicat un eseu, în care a considerat utilizarea monadei, prin semantica calculului Lambda , pentru a gestiona efectele secundare , intrările și ieșirile, excepțiile și altele. Această publicație a influențat munca multor oameni de știință din domeniul calculatoarelor, inclusiv Simon Peyton Jones , care le va implementa apoi în limbajul Haskell pur funcțional (în loc să folosească listele leneșe pentru a gestiona IO ).

Pentru o lungă perioadă de timp, utilizarea acestor structuri a fost limitată la un cerc foarte mic de limbi, dintre care multe sunt pur funcționale (în principal din cauza problemelor legate de gestionarea IO ). Recent, aceste structuri au fost, de asemenea, adaptate limbajelor imperative, mai ales pentru a permite utilizarea unor modele funcționale de programare care sunt mai ușor de înțeles și mai ușor de scris. Unele dintre aceste limbaje sunt Python , Scala , Perl , Racket și Java . Pe lângă limbile imperative și pur funcționale, și limbile familiei ML , cum ar fi F # , evoluează pentru a permite utilizarea monadelor.

Caracteristici

În mod formal, o monadă poate fi exprimată ca un monoid în categoria endofuncționarilor ^[2] .

O monadă poate fi descrisă ca o triplă $\langle T,\nu ,\mu \rangle$ ${\ displaystyle \ langle T, \ nu, \ mu \ rangle}$ ${\ displaystyle \ langle T, \ nu, \ mu \ rangle}$ :

$T.$ ${\ displaystyle T}$ $T.$ : reprezintă tipologia constructului, de exemplu în monada IO, T va fi egal cu IO.
$\nu$ ${\ displaystyle \ nu}$ $\ nu$ : ( eta ) este o funcție astfel încât permite trecerea de la -> T la, deci ar fi echivalentă cu funcția de returnare din Haskell;
$\mu$ ${\ displaystyle \ mu}$ $\ mu$ : ( mu ) este o altă funcție care permite concatenarea sau compoziția monadelor de același tip, utilizate în Haskell prin operatorul de legare (>> =) ;

După cum se poate vedea din descrierea dată mai sus, funcțiile „adecvate” ale unei monade sunt două. Tocmai pe aceste două, se bazează legile pe care fiecare monadă trebuie să le urmeze pentru a-și permite să aibă propriile sale caracteristici.

Cele două legi vor fi exprimate în Haskell ^[3] . La listarea caracteristicilor, vor fi utilizate funcțiile:

funcția de returnare reprezintă funcția de identitate ^[4] ;
operatorul de legare (>> =) reprezintă funcția de compoziție a două monade.

Prima axiomă - Legile identității

Trebuie să existe un element astfel încât, atunci când este compus la o funcție, să aibă ca rezultat funcția cu care a fost compus elementul neutru. Această caracteristică trebuie să posede proprietatea comutativă.

 - identitatea din dreapta:
f >> = return == f

- identitatea din stânga:
returnează a >> = f == f a

- din versiunea 2010 a limbii este, de asemenea
- poate fi scris cu notația do:
- identitatea din „dreapta”:
face x <- m
     returnează x
= m

- cu identitatea din „stânga”:
do y <- returnează x
     f y
= faceți f x

A doua axiomă - Legea asociativității

Un set de trei funcții poate fi combinat în două moduri echivalente.

 ( f >> = g ) >> = h == f >> = ( \ x -> g x >> = h )

- exprimabil cu notația do, după cum urmează
do b <- do a <- m
     f a
     g b
= faceți un <- m
     b <- f a
     g b
= faceți un <- m
     face b <- f a
        g b

Notă

^ Definiția clasei Monad în Haskell
^ (EN) Saunders Mac Lane , Categorii pentru matematicianul de lucru , 1971.
„O monadă în X este doar monoidă în categoria endofuncționarilor” .
^ Haskell a fost unul dintre primele limbaje care a implementat monadele într-un mod inteligibil și bogat în documente.
^ Funcția de identitate ( returnare ), trebuie să fie implementată în funcție de tipul constructului specific Monad.

Bibliografie

( EN ) Graham Hutton , Programare în Haskell , Cambridge University Press, 2007 , ISBN 9780521692694 .
(EN) Simon Peyton Jones , Haskell 98 Language and Libraries - The Revised Report , 1999 .
( EN ) Eugenio Moggi , Noțiuni de calcul și monade , Universitatea din Edinburgh, 1991 .

Elemente conexe

linkuri externe

Diverse

( EN ) Haskell Wiki (4 septembrie 2015), „ All About Monads ”, un tutorial plin de exemple și sfaturi despre modul de utilizare a monadelor, dar care nu explică aproape nimic la nivel formal.
( EN ) Haskell Wiki (13 iulie 2015), „Monade ”, o introducere de bază a monadelor din Haskell.
( EN ) Brian Beckman, „Don't Fear Monads” , o explicație a monadelor folosind concepte matematice de bază.

Portal IT : accesați intrările Wikipedia care se ocupă cu IT

[1] Definiția clasei Monad în Haskell

[cit-2] (EN) Saunders Mac Lane , Categorii pentru matematicianul de lucru , 1971.
„O monadă în X este doar monoidă în categoria endofuncționarilor” .

[haskell_come_linguaggio_di_monadi-3] Haskell a fost unul dintre primele limbaje care a implementat monadele într-un mod inteligibil și bogat în documente.

[return-4] Funcția de identitate ( returnare ), trebuie să fie implementată în funcție de tipul constructului specific Monad.

[1]

[2]

[3]

[4]