[Haskell-fr] Éclaircissements sur les monades

[Gautier DI FOLCO]

Le 26 mars 2014 21:19, Valentin Robert <valentin.robert.42 at gmail.com> a
écrit :

> Ci-dessous une intuition guidée par les types pour identifier une
> différence entre les foncteurs applicatifs et les monades qui a été
> mentionée auparavant par Alp.
>
> La composition de foncteurs applicatif a pour type:
> c a -> c (a -> b)  -> c b
> La composition de monades a pour type:
> c a -> (a -> c b) -> c b
>
> (J'ai renommé les variables f et m en c, et réordonné les paramètres pour
> simplifier mon explication)
>
> Dans les deux cas, on souhaite applique uniformément une sorte de fonction
> (le second paramètre) sur une valeur en contexte (le premier paramètre).
>
> Cependant, le type donné à la fonction lui confère un potentiel différent
> dans chaque cas:
> - pour Applicative, la fonction qui reçoit un a n'a pas la possibilité
> d'altérer son contexte, car la fonction est dans le contexte: c (a -> b)
> - pour Monad, la fonction qui reçoit un a se charge de construire le
> contexte pour son résultat: a -> c b
>
> Du coup, dans Applicative, la valeur de a peut seulement influencer la
> valeur de b, mais pas la structure du contexte c.
> Alors que dans Monad, la valeur de a peut influencer à la fois la valeur
> de b et la structure du contexte c dans lequel b est placé.
>
> ---
>
> Dans le cas des listes :
>
> (<*>) :: [a -> b]  -> [a] -> [b]   -- j'ai remis les paramètres dans
> l'ordre d'Haskell pour la suite de mon email
> (>>=) :: [a] -> (a -> [b]) -> [b]
>
> Pour (fl <*> xl), quelles que soient les valeurs dans xl, la liste
> résultante aura autant d'éléments que le produit du nombre d'éléments de fl
> et xl. Les fonctions contenues dans fl peuvent contrôler les valeurs dans
> la liste finale, mais pas la structure de la liste finale.
>
> Pour (xl >>= fl), les fonctions peuvent également affecter la structure
> résultante.
>
> [1,2,3] >>= (\a -> if a == 1 then [] else [a+1, a+2])
>
> Ici, j'ai le droit de regarder la valeur, et de modifier la structure du
> contexte produit (par exemple, je produis une liste vide quand la valeur
> est 1, et une liste à deux éléments autrement).
>
> ---
>
> Dans la monade IO, c'est ce qui te permet de choisir quelles actions faire
> en fonction du résultat produit par les actions précédentes.
>
> (<*>) :: IO (a -> b)  -> IO a -> IO b
> (>>=) :: IO a -> (a -> IO b) -> IO b
>
> iof <*> ioa   -- quelle que soit la valeur produite par ioa, on applique
> la fonction dans iof
> ioa >>= (\a -> ....)   -- ici, dans les ... tu peux regarder a, et
> effectuer différentes actions, ce qui est impossible avec Applicative
>
> ---
>
> Corrigez-moi si je dis des bêtises... je suis malade et fatigué ! :-)
>
> - Valentin
>
>
Ça me paraît plus clair, pour être sur :
 * une Applicative me permet de réunir inconditionnellement deux expression
au sein d'un même contexte (une sorte de write only)
 * une Monade me permet de lire la valeur d'un contexte et dans recréer un
à ma guise, comme je le souhaite (une sorte de read, drop, create)

Merci.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-fr/attachments/20140326/f9476715/attachment.html>