[Haskell-fr] Éclaircissements sur les monades

[Gautier DI FOLCO]

Le 26 mars 2014 18:04, Sylvain Henry <hsyl20 at gmail.com> a écrit :

> Bonjour,
>
> J'avais fait un exposé pour expliquer ça entre autres, je ne sais pas si
> c'est tellement compréhensible sans les explications données à l'oral mais
> les slides sont là :
> http://www.sylvain-henry.info/home/data/uploads/talks/shenry-2013-02-05-haskell-intro.pdf(à partir du 20e slide).
>
> * Contexte
>
> Dans un langage fonctionnel, on n'utilise pas de variable globale donc
> pour qu'il y ait un contexte il faut le passer explicitement en entrée des
> fonctions et le renvoyer en sortie (en plus d'autres valeurs
> potentiellement) :
> f :: ... -> Context -> (Context, ...)
>
> pour ne pas écrire à chaque fois les types "Context", on peut faire :
> type M a = Context -> (Context, a)
> et réécrire :
> f :: ... -> M a
>

ok, déjà ça c'est plus clair.


> Il ne reste plus qu'à définir la composition pour les fonctions de ce type
> de sorte que le contexte soit passé de la sortie de la première fonction à
> l'entrée de l'autre :
> (>>=) :: M a -> (a -> M b) -> M b
> (>>=) f g = \ctx -> let (ctx2, a) = f ctx in g a ctx2
>

C'est là que je décroche, après un >>= on a bien une fonction qui attends
un paramètre ? si oui, qui lui donne ?


> Pour créer une fonction de type "M a" à partir d'un "a", on définit la
> fonction :
> return :: a -> M a
> return x = \ctx -> (ctx,x)
>

idem


> * IO
>
> Dans le cas des IO, le "contexte" est le "monde" (extérieur au programme).
> La fonction main a le type suivant :
> main :: IO ()
> soit
> main :: World -> (World, () )
>
> Donc on peut composer des fonctions qui ont des effets de bord avec (>>=)
> de sorte que ce soit correct d'un point de vue types sans jamais dire
> exactement ce que représente le type World. Les opérations s'exécutent en
> séquence puisque chaque opération "attend de récupérer le monde renvoyé par
> l'opération qui la précède" (du moins c'est l'idée). Il n'y a aucun moyen
> pour le programme de créer un objet de type World donc toutes les
> opérations s'enchainent forcément à partir de celui passé à "main".
>

ça ok, mais comment les mondes se "passent" entre les différents appel
(bien que d'après ce que j'ai pu lire, l'IO monade est un cas particulier).


> * Monades
>
> Les monades sont juste une généralisation du mécanisme décrit ci-dessus
> (en gros), c'est pourquoi ils sont adaptés. La typeclass Monad implique la
> typeclass Applicative (l'inverse n'est pas vrai) et on aurait pu utiliser
> Applicative à la place de Monad dans le cas des IOs. Ça a même été suggéré
> sur la mailing-list haskell-cafe il n'y a pas si longtemps si je me
> souviens bien.
>

Merci, du coup les Applicative permettent aussi des effets de bords et
d'enchaînements ?
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-fr/attachments/20140326/473a0617/attachment.html>