From gautier.difolco at gmail.com Thu Mar 20 10:26:48 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Thu, 20 Mar 2014 11:26:48 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?Caract=E9risation_des_langages_foncti?= =?iso-8859-1?q?onnels?= Message-ID: Bonjour, Je vais peut-?tre poser une question tr?s g?n?rale, mais qu'est-ce qui caract?rise un langage de programmation fonctionnel ? Je m'explique : - je sais qu'un LPF se base sur des expressions - je sais en reconna?tre un quand j'en vois un mais chaque fois qu'on me pose la question, je ne suis pas foutu de donner des ?l?ments caract?ristiques clairs. Est-ce que vous auriez une "phrase toute faite" ou quelque chose qui me permette de l'expliquer simplement/clairement de mani?re juste ? Merci par avance. -------------- next part -------------- An HTML attachment was scrubbed... URL: From Laurent.Pierron at inria.fr Fri Mar 21 10:46:54 2014 From: Laurent.Pierron at inria.fr (Laurent Pierron) Date: Fri, 21 Mar 2014 11:46:54 +0100 Subject: [Haskell-fr] =?windows-1252?q?Caract=E9risation_des_langages_fonc?= =?windows-1252?q?tionnels?= In-Reply-To: References: Message-ID: Bonjour, R?cemment je me suis pos? la question avec un coll?gue pour introduire un s?minaire interne sur les langages fonctionnels, et on n?a pas r?ussi ? trouver une r?ponse satisfaisante, on s?est heurt? aux diff?rents types de langage fonctionnel (Lisp, ML famille, Haskell, etc.), qui peuvent inclure des ?l?ments de langages imp?ratifs, des objets, des types alg?briques ou uniquement des types simples et qui ont des strat?gies d??valuation diff?rentes. Personnellement, je dirais que dans un langage de fonctionnel l?ex?cution d?un programme se fait uniquement par substitution d?expression sans modification de l??tat d?une machine alors que dans un langage imp?ratif l?ex?cution se fait par ?valuation d?expression et modification de l??tat de la machine. On peut aussi dire que les langages fonctionnels sont bas?s sur le lambda-calcul de Church, alors que les langages imp?ratifs sont bas?s sur la machine de Turing, mais il faut expliquer ce qu?est le lambda-calcul. Laurent Pierron Le 20 mars 2014 ? 11:26, Gautier DI FOLCO a ?crit : Bonjour, Je vais peut-?tre poser une question tr?s g?n?rale, mais qu'est-ce qui caract?rise un langage de programmation fonctionnel ? Je m'explique : - je sais qu'un LPF se base sur des expressions - je sais en reconna?tre un quand j'en vois un mais chaque fois qu'on me pose la question, je ne suis pas foutu de donner des ?l?ments caract?ristiques clairs. Est-ce que vous auriez une "phrase toute faite" ou quelque chose qui me permette de l'expliquer simplement/clairement de mani?re juste ? Merci par avance. _______________________________________________ Haskell-fr mailing list Haskell-fr at haskell.org http://www.haskell.org/mailman/listinfo/haskell-fr From gautier.difolco at gmail.com Fri Mar 21 11:34:29 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Fri, 21 Mar 2014 12:34:29 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?Caract=E9risation_des_langages_foncti?= =?iso-8859-1?q?onnels?= In-Reply-To: References: Message-ID: Le 21 mars 2014 11:46, Laurent Pierron a ?crit : > Bonjour, > > R?cemment je me suis pos? la question avec un coll?gue pour introduire un > s?minaire interne sur les langages fonctionnels, et on n'a pas r?ussi ? > trouver une r?ponse satisfaisante, on s'est heurt? aux diff?rents types de > langage fonctionnel (Lisp, ML famille, Haskell, etc.), qui peuvent inclure > des ?l?ments de langages imp?ratifs, des objets, des types alg?briques ou > uniquement des types simples et qui ont des strat?gies d'?valuation > diff?rentes. > > Personnellement, je dirais que dans un langage de fonctionnel l'ex?cution > d'un programme se fait uniquement par substitution d'expression sans > modification de l'?tat d'une machine alors que dans un langage imp?ratif > l'ex?cution se fait par ?valuation d'expression et modification de l'?tat > de la machine. > > On peut aussi dire que les langages fonctionnels sont bas?s sur le > lambda-calcul de Church, alors que les langages imp?ratifs sont bas?s sur > la machine de Turing, mais il faut expliquer ce qu'est le lambda-calcul. > > > Laurent Pierron > > Le 20 mars 2014 ? 11:26, Gautier DI FOLCO a > ?crit : > > Bonjour, > > Je vais peut-?tre poser une question tr?s g?n?rale, mais qu'est-ce qui > caract?rise un langage de programmation fonctionnel ? > Je m'explique : > - je sais qu'un LPF se base sur des expressions > - je sais en reconna?tre un quand j'en vois un > > mais chaque fois qu'on me pose la question, je ne suis pas foutu de donner > des ?l?ments caract?ristiques clairs. > > Est-ce que vous auriez une "phrase toute faite" ou quelque chose qui me > permette de l'expliquer simplement/clairement de mani?re juste ? > > Merci par avance. > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > Bonjour, Si je rajoute "conceptuellement" la d?finition me convient. Merci. -------------- next part -------------- An HTML attachment was scrubbed... URL: From cognominal at gmail.com Fri Mar 21 12:15:22 2014 From: cognominal at gmail.com (=?ISO-8859-1?Q?St=E9phane_Payrard?=) Date: Fri, 21 Mar 2014 13:15:22 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?Caract=E9risation_des_langages_foncti?= =?iso-8859-1?q?onnels?= In-Reply-To: References: Message-ID: Etant autodidacte, je n'ai pas d'autorit? particuli?re pour parler d'un sujet d'origine acad?mique. :) De plus ma r?ponse est biais?e par mon int?r?t pour les langages elm et idris . La programmation fonctionnelle moderne tourne autour de deux th?mes, celui de la r?f?rence transparentielle et celui de type. Le premier est d?j? mentionn? implicitement sans indiquer le b?n?fice esp?r? : l'absence d'?tats permettrait aux compilateur de parall?liser et d'utiliser au mieux les architectures multiprocesseurs. En pratique, sauf dans des cas sp?cialis?s (grosses matrices, rendu graphique), ce b?n?fice ne s'est gu?re mat?rialis?. Pourtant, c'est cette perspective qui a motiv? le d?veloppement des langages fonctionnels pour r?soudre le goulot d'?tranglement de l'architecture de Von Neumann. Voir le papier de Backus en 1977 : https://www.cs.ucf.edu/~dcm/Teaching/COT4810-Fall%202012/Literature/Backus.pdf La notion de type permet pour les langages les moins "riches" (polymorphiques de niveau 1) d'offrir l'inf?rence de type. Tandis des langages langages comme idris proposent des types param?tr?s par des valeurs ce qui permet un syst?me plus riche mais oblige ? beaucoup d'annotations de type. C'est pourquoi ces langages ?taient jusqu'? maintenant sp?cialis?s dans des domaines comme la cr?ation de prevues formels. Le domaine est encore revitalis? par la d?couverte des similarit?s entre un champ de la topologie et la th?orie des types. Mais je ne sais pas si (ou quand) cela aura un impact en dehors des milieux acad?miques. Voir http://homotopytypetheory.org/ Il est int?ressant de noter que la syntaxe de beaucoup de langages fonctionnels est h?rit?e d'ISWIM, un langage hypoth?tique pr?sent? par Landin dans un papier de 1966. http://www.cs.cmu.edu/~crary/819-f09/Landin66.pdf Finalement, un sujet connexe est la programmation r?active fonctionnelle. Un des int?r?ts est de permettre le type de programmation interactive pr?n?e par Bret Victor mais probablement impossible dans tout autre contexte. Bret Victor semble d?lib?r?ment ignorer cette contrainte en proposant des d?mos qui la cachent. Dans ce domaine un langage est particuli?rement prometteur : elm. La soci?t? Prezi entend utiliser elm pour les prochaines versions de son produit et a embauch? le cr?ateur du langage, ce qui pourrait garantir sa p?rennit?. M?me si la programmation r?active fonctionnelle est un sous champ de la programmation fonctionnelle, un programme g?n?r? par elm a le m?rite de tourner dans un browser et de permettre des d?mos interactives ce qui rend le sujet moins aride. http://elm-lang.org/blog/Interactive-Programming.elm http://worrydream.com/LearnableProgramming/ On 3/21/14, Laurent Pierron wrote: > Bonjour, > > R?cemment je me suis pos? la question avec un coll?gue pour introduire un > s?minaire interne sur les langages fonctionnels, et on n'a pas r?ussi ? > trouver une r?ponse satisfaisante, on s'est heurt? aux diff?rents types de > langage fonctionnel (Lisp, ML famille, Haskell, etc.), qui peuvent inclure > des ?l?ments de langages imp?ratifs, des objets, des types alg?briques ou > uniquement des types simples et qui ont des strat?gies d'?valuation > diff?rentes. > > Personnellement, je dirais que dans un langage de fonctionnel l'ex?cution > d'un programme se fait uniquement par substitution d'expression sans > modification de l'?tat d'une machine alors que dans un langage imp?ratif > l'ex?cution se fait par ?valuation d'expression et modification de l'?tat de > la machine. > > On peut aussi dire que les langages fonctionnels sont bas?s sur le > lambda-calcul de Church, alors que les langages imp?ratifs sont bas?s sur la > machine de Turing, mais il faut expliquer ce qu'est le lambda-calcul. > > > Laurent Pierron > > Le 20 mars 2014 ? 11:26, Gautier DI FOLCO a > ?crit : > > Bonjour, > > Je vais peut-?tre poser une question tr?s g?n?rale, mais qu'est-ce qui > caract?rise un langage de programmation fonctionnel ? > Je m'explique : > - je sais qu'un LPF se base sur des expressions > - je sais en reconna?tre un quand j'en vois un > > mais chaque fois qu'on me pose la question, je ne suis pas foutu de donner > des ?l?ments caract?ristiques clairs. > > Est-ce que vous auriez une "phrase toute faite" ou quelque chose qui me > permette de l'expliquer simplement/clairement de mani?re juste ? > > Merci par avance. > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > -- cognominal stef From gautier.difolco at gmail.com Fri Mar 21 14:06:42 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Fri, 21 Mar 2014 15:06:42 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?Caract=E9risation_des_langages_foncti?= =?iso-8859-1?q?onnels?= In-Reply-To: References: Message-ID: Le 21 mars 2014 13:15, St?phane Payrard a ?crit : > Etant autodidacte, je n'ai pas d'autorit? particuli?re pour parler > d'un sujet d'origine acad?mique. :) > De plus ma r?ponse est biais?e par mon int?r?t pour les langages elm et > idris . > > La programmation fonctionnelle moderne tourne autour de deux th?mes, celui > de la > r?f?rence transparentielle et celui de type. > > Le premier est d?j? mentionn? implicitement sans indiquer le b?n?fice > esp?r? : l'absence d'?tats permettrait aux compilateur de parall?liser > et d'utiliser au mieux les architectures multiprocesseurs. > En pratique, sauf dans des cas sp?cialis?s (grosses matrices, rendu > graphique), ce b?n?fice ne s'est gu?re mat?rialis?. > Pourtant, c'est cette perspective qui a motiv? le d?veloppement des > langages fonctionnels pour r?soudre le goulot d'?tranglement de > l'architecture de Von Neumann. Voir le papier de Backus en 1977 : > > https://www.cs.ucf.edu/~dcm/Teaching/COT4810-Fall%202012/Literature/Backus.pdf > > > La notion de type permet pour les langages les moins "riches" > (polymorphiques de niveau > 1) d'offrir l'inf?rence de type. Tandis des langages langages comme > idris proposent des types param?tr?s par des valeurs ce qui permet un > syst?me plus riche mais oblige ? beaucoup d'annotations de type. C'est > pourquoi ces langages ?taient jusqu'? maintenant sp?cialis?s dans des > domaines comme la cr?ation de prevues formels. > Le domaine est encore revitalis? par la d?couverte des similarit?s > entre un champ de la topologie et la th?orie des types. Mais je ne > sais pas si (ou quand) cela aura un impact en dehors des milieux > acad?miques. Voir http://homotopytypetheory.org/ > > Il est int?ressant de noter que la syntaxe de beaucoup de langages > fonctionnels est h?rit?e d'ISWIM, un langage hypoth?tique pr?sent? par > Landin dans un papier de 1966. > http://www.cs.cmu.edu/~crary/819-f09/Landin66.pdf > > Finalement, un sujet connexe est la programmation r?active > fonctionnelle. Un des int?r?ts est de permettre > le type de programmation interactive pr?n?e par Bret Victor mais > probablement impossible dans tout autre contexte. Bret Victor semble > d?lib?r?ment ignorer cette contrainte en proposant des d?mos qui la > cachent. > Dans ce domaine un langage est particuli?rement prometteur : elm. > La soci?t? Prezi entend utiliser elm pour les prochaines versions de > son produit et a embauch? le cr?ateur > du langage, ce qui pourrait garantir sa p?rennit?. M?me si la > programmation r?active fonctionnelle est un sous champ de la > programmation fonctionnelle, un programme g?n?r? par elm a le m?rite > de tourner dans un browser et de permettre des d?mos interactives ce > qui rend le sujet moins aride. > > http://elm-lang.org/blog/Interactive-Programming.elm > http://worrydream.com/LearnableProgramming/ > > > > > > On 3/21/14, Laurent Pierron wrote: > > Bonjour, > > > > R?cemment je me suis pos? la question avec un coll?gue pour introduire un > > s?minaire interne sur les langages fonctionnels, et on n'a pas r?ussi ? > > trouver une r?ponse satisfaisante, on s'est heurt? aux diff?rents types > de > > langage fonctionnel (Lisp, ML famille, Haskell, etc.), qui peuvent > inclure > > des ?l?ments de langages imp?ratifs, des objets, des types alg?briques ou > > uniquement des types simples et qui ont des strat?gies d'?valuation > > diff?rentes. > > > > Personnellement, je dirais que dans un langage de fonctionnel l'ex?cution > > d'un programme se fait uniquement par substitution d'expression sans > > modification de l'?tat d'une machine alors que dans un langage imp?ratif > > l'ex?cution se fait par ?valuation d'expression et modification de > l'?tat de > > la machine. > > > > On peut aussi dire que les langages fonctionnels sont bas?s sur le > > lambda-calcul de Church, alors que les langages imp?ratifs sont bas?s > sur la > > machine de Turing, mais il faut expliquer ce qu'est le lambda-calcul. > > > > > > Laurent Pierron > > > > Le 20 mars 2014 ? 11:26, Gautier DI FOLCO a > > ?crit : > > > > Bonjour, > > > > Je vais peut-?tre poser une question tr?s g?n?rale, mais qu'est-ce qui > > caract?rise un langage de programmation fonctionnel ? > > Je m'explique : > > - je sais qu'un LPF se base sur des expressions > > - je sais en reconna?tre un quand j'en vois un > > > > mais chaque fois qu'on me pose la question, je ne suis pas foutu de > donner > > des ?l?ments caract?ristiques clairs. > > > > Est-ce que vous auriez une "phrase toute faite" ou quelque chose qui me > > permette de l'expliquer simplement/clairement de mani?re juste ? > > > > Merci par avance. > > _______________________________________________ > > Haskell-fr mailing list > > Haskell-fr at haskell.org > > http://www.haskell.org/mailman/listinfo/haskell-fr > > > > _______________________________________________ > > Haskell-fr mailing list > > Haskell-fr at haskell.org > > http://www.haskell.org/mailman/listinfo/haskell-fr > > > > > -- > cognominal stef > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > Je suis un peu dans le m?me cas, mais comme dans mes cercles je suis "le plus cal? en FP" et qu'en plus je tente "d'?vang?liser", j'ai de gros efforts p?dagogiques ? fournir (ce qui n'est pas mon point fort). Le soucis avec ces crit?res, transparence r?f?rentielle et typage fort/statique, c'est que du coup tu sors Scala et Clojure par exemple. PS : je suis sur du Data-flow en ce moment du coup je connais un peu le FRP, mais j'avoue ne pas avoir fait le lien avec Bret Victor. -------------- next part -------------- An HTML attachment was scrubbed... URL: From ns.schoe at gmail.com Fri Mar 21 14:39:08 2014 From: ns.schoe at gmail.com (Nicolas SCHOEMAEKER) Date: Fri, 21 Mar 2014 15:39:08 +0100 Subject: [Haskell-fr] Haskell-fr Digest, Vol 23, Issue 2 In-Reply-To: References: Message-ID: Regards, Nicolas SCHOEMAEKER Web Developer Haskell Programer Artificial Intelligence & Robotics enthusiast 2014-03-21 13:00 GMT+01:00 : > Send Haskell-fr mailing list submissions to > haskell-fr at haskell.org > > To subscribe or unsubscribe via the World Wide Web, visit > http://www.haskell.org/mailman/listinfo/haskell-fr > or, via email, send a message with subject or body 'help' to > haskell-fr-request at haskell.org > > You can reach the person managing the list at > haskell-fr-owner at haskell.org > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Haskell-fr digest..." > > > Today's Topics: > > 1. Re: Caract?risation des langages fonctionnels (Laurent Pierron) > 2. Re: Caract?risation des langages fonctionnels (Gautier DI FOLCO) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Fri, 21 Mar 2014 11:46:54 +0100 > From: Laurent Pierron > To: La liste Haskell Francophone > Subject: Re: [Haskell-fr] Caract?risation des langages fonctionnels > Message-ID: > Content-Type: text/plain; charset=windows-1252 > > Bonjour, > > R?cemment je me suis pos? la question avec un coll?gue pour introduire un > s?minaire interne sur les langages fonctionnels, et on n?a pas r?ussi ? > trouver une r?ponse satisfaisante, on s?est heurt? aux diff?rents types de > langage fonctionnel (Lisp, ML famille, Haskell, etc.), qui peuvent inclure > des ?l?ments de langages imp?ratifs, des objets, des types alg?briques ou > uniquement des types simples et qui ont des strat?gies d??valuation > diff?rentes. > > Personnellement, je dirais que dans un langage de fonctionnel l?ex?cution > d?un programme se fait uniquement par substitution d?expression sans > modification de l??tat d?une machine alors que dans un langage imp?ratif > l?ex?cution se fait par ?valuation d?expression et modification de l??tat > de la machine. > > On peut aussi dire que les langages fonctionnels sont bas?s sur le > lambda-calcul de Church, alors que les langages imp?ratifs sont bas?s sur > la machine de Turing, mais il faut expliquer ce qu?est le lambda-calcul. > > > Laurent Pierron > > Le 20 mars 2014 ? 11:26, Gautier DI FOLCO a > ?crit : > > Bonjour, > > Je vais peut-?tre poser une question tr?s g?n?rale, mais qu'est-ce qui > caract?rise un langage de programmation fonctionnel ? > Je m'explique : > - je sais qu'un LPF se base sur des expressions > - je sais en reconna?tre un quand j'en vois un > > mais chaque fois qu'on me pose la question, je ne suis pas foutu de donner > des ?l?ments caract?ristiques clairs. > > Est-ce que vous auriez une "phrase toute faite" ou quelque chose qui me > permette de l'expliquer simplement/clairement de mani?re juste ? > Une "phrase toute faite" que j'aime utiliser pour pr?senter Haskell (mais je pense que ?a peut s'appliquer ? tous les langages fonctionnels) est la suivante : "Dans un langage imp?ratif (type C/C++) un programme est une suite d'instructions ? effectuer (le programmeur dit *quoi faire??* ? l'ordinateur) ; en Haskell, un programme est une suite de *d?finitions* : le programmeur dit ? l'ordinateur *ce que sont les choses*". Je donne ensuite les deux exemples suivants : - la fonction 'head' qui renvoie le premier ?l?ment d'une liste. En C, on prend la liste, on "parcourt" les ?l?ments en s'arr?tant au premier, et on le renvoie : c'est comment renvoyer le premier ?l?ment. En Haskell, on *dit* qu'une liste *c'est* une t?te et une queue, et pour renvoyer le premier ?l?ment de la liste, et bien on... renvoie le premier ?l?ment de la liste : le pattern-matching "head (x:_) = x" signifie exactement ceci. - la fonction "length" qui renvoie le nombre d'?l?ments d'une liste. En C, on prend la liste, on parcourt ses ?l?ments et on incr?mente un compteur ? chaque fois qu'on parcourt un ?l?ment. En Haskell, la longueur d'une liste, *c'est* : la longueur de la t?te (1) + la longueur de la queue. En Haskell, on explique vraiment ? l'ordinateur *comment* sont les choses, comment elles sont construites. Bref, c'est g?n?ralement comme ?a que je captive mon public lorsque je pr?sente Haskell. Bon courage. Nicolas SCHOEMAEKER. > Merci par avance. > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > > > ------------------------------ > > Message: 2 > Date: Fri, 21 Mar 2014 12:34:29 +0100 > From: Gautier DI FOLCO > To: La liste Haskell Francophone > Subject: Re: [Haskell-fr] Caract?risation des langages fonctionnels > Message-ID: > < > CAH_3vcSBLtyu1oJsVCbLii7OaKuN7SiWryqinKuOzq54ytjsWg at mail.gmail.com> > Content-Type: text/plain; charset="iso-8859-1" > > Le 21 mars 2014 11:46, Laurent Pierron a ?crit > : > > > Bonjour, > > > > R?cemment je me suis pos? la question avec un coll?gue pour introduire un > > s?minaire interne sur les langages fonctionnels, et on n'a pas r?ussi ? > > trouver une r?ponse satisfaisante, on s'est heurt? aux diff?rents types > de > > langage fonctionnel (Lisp, ML famille, Haskell, etc.), qui peuvent > inclure > > des ?l?ments de langages imp?ratifs, des objets, des types alg?briques ou > > uniquement des types simples et qui ont des strat?gies d'?valuation > > diff?rentes. > > > > Personnellement, je dirais que dans un langage de fonctionnel l'ex?cution > > d'un programme se fait uniquement par substitution d'expression sans > > modification de l'?tat d'une machine alors que dans un langage imp?ratif > > l'ex?cution se fait par ?valuation d'expression et modification de l'?tat > > de la machine. > > > > On peut aussi dire que les langages fonctionnels sont bas?s sur le > > lambda-calcul de Church, alors que les langages imp?ratifs sont bas?s sur > > la machine de Turing, mais il faut expliquer ce qu'est le lambda-calcul. > > > > > > Laurent Pierron > > > > Le 20 mars 2014 ? 11:26, Gautier DI FOLCO a > > ?crit : > > > > Bonjour, > > > > Je vais peut-?tre poser une question tr?s g?n?rale, mais qu'est-ce qui > > caract?rise un langage de programmation fonctionnel ? > > Je m'explique : > > - je sais qu'un LPF se base sur des expressions > > - je sais en reconna?tre un quand j'en vois un > > > > mais chaque fois qu'on me pose la question, je ne suis pas foutu de > donner > > des ?l?ments caract?ristiques clairs. > > > > Est-ce que vous auriez une "phrase toute faite" ou quelque chose qui me > > permette de l'expliquer simplement/clairement de mani?re juste ? > > > > Merci par avance. > > _______________________________________________ > > Haskell-fr mailing list > > Haskell-fr at haskell.org > > http://www.haskell.org/mailman/listinfo/haskell-fr > > > > _______________________________________________ > > Haskell-fr mailing list > > Haskell-fr at haskell.org > > http://www.haskell.org/mailman/listinfo/haskell-fr > > > > Bonjour, > > Si je rajoute "conceptuellement" la d?finition me convient. > > Merci. > -------------- next part -------------- > An HTML attachment was scrubbed... > URL: < > http://www.haskell.org/pipermail/haskell-fr/attachments/20140321/f9bb2ad9/attachment-0001.html > > > > ------------------------------ > > Subject: Digest Footer > > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > > ------------------------------ > > End of Haskell-fr Digest, Vol 23, Issue 2 > ***************************************** > -------------- next part -------------- An HTML attachment was scrubbed... URL: From valentin.robert.42 at gmail.com Fri Mar 21 14:51:55 2014 From: valentin.robert.42 at gmail.com (Valentin Robert) Date: Fri, 21 Mar 2014 07:51:55 -0700 Subject: [Haskell-fr] =?utf-8?q?Caract=C3=A9risation_des_langages_fonction?= =?utf-8?q?nels?= In-Reply-To: References: Message-ID: Je serais plut?t de l'avis de Gautier et pense que la caract?risation de St?phane est un peu r?ductrice. En pratique je trouve qu'un langage semble fonctionnel d?s qu'il inclut des m?canismes pour manipuler des fonctions comme citoyens de premi?re classe (valeurs fonctionelles, cr?ation de fonctions anonymes, fonctions d'ordre sup?rieur). C'est tr?s g?n?ral mais en premi?re approximation, cela capture ce que j'attends de tout langage qui se dit fonctionnel. Il y a beaucoup de fonctionnalit?s qui sont souvent attach?es aux langages fonctionnels, mais que je ne consid?re pas n?cessairement cl?s (types de donn?es alg?briques, puret?, typage statique/dynamique ou non-typage, port?e statique/dynamique, ...). - Valentin 2014-03-21 7:06 GMT-07:00 Gautier DI FOLCO : > Le 21 mars 2014 13:15, St?phane Payrard a ?crit : > > Etant autodidacte, je n'ai pas d'autorit? particuli?re pour parler >> d'un sujet d'origine acad?mique. :) >> De plus ma r?ponse est biais?e par mon int?r?t pour les langages elm et >> idris . >> >> La programmation fonctionnelle moderne tourne autour de deux th?mes, >> celui de la >> r?f?rence transparentielle et celui de type. >> >> Le premier est d?j? mentionn? implicitement sans indiquer le b?n?fice >> esp?r? : l'absence d'?tats permettrait aux compilateur de parall?liser >> et d'utiliser au mieux les architectures multiprocesseurs. >> En pratique, sauf dans des cas sp?cialis?s (grosses matrices, rendu >> graphique), ce b?n?fice ne s'est gu?re mat?rialis?. >> Pourtant, c'est cette perspective qui a motiv? le d?veloppement des >> langages fonctionnels pour r?soudre le goulot d'?tranglement de >> l'architecture de Von Neumann. Voir le papier de Backus en 1977 : >> >> https://www.cs.ucf.edu/~dcm/Teaching/COT4810-Fall%202012/Literature/Backus.pdf >> >> >> La notion de type permet pour les langages les moins "riches" >> (polymorphiques de niveau >> 1) d'offrir l'inf?rence de type. Tandis des langages langages comme >> idris proposent des types param?tr?s par des valeurs ce qui permet un >> syst?me plus riche mais oblige ? beaucoup d'annotations de type. C'est >> pourquoi ces langages ?taient jusqu'? maintenant sp?cialis?s dans des >> domaines comme la cr?ation de prevues formels. >> Le domaine est encore revitalis? par la d?couverte des similarit?s >> entre un champ de la topologie et la th?orie des types. Mais je ne >> sais pas si (ou quand) cela aura un impact en dehors des milieux >> acad?miques. Voir http://homotopytypetheory.org/ >> >> Il est int?ressant de noter que la syntaxe de beaucoup de langages >> fonctionnels est h?rit?e d'ISWIM, un langage hypoth?tique pr?sent? par >> Landin dans un papier de 1966. >> http://www.cs.cmu.edu/~crary/819-f09/Landin66.pdf >> >> Finalement, un sujet connexe est la programmation r?active >> fonctionnelle. Un des int?r?ts est de permettre >> le type de programmation interactive pr?n?e par Bret Victor mais >> probablement impossible dans tout autre contexte. Bret Victor semble >> d?lib?r?ment ignorer cette contrainte en proposant des d?mos qui la >> cachent. >> Dans ce domaine un langage est particuli?rement prometteur : elm. >> La soci?t? Prezi entend utiliser elm pour les prochaines versions de >> son produit et a embauch? le cr?ateur >> du langage, ce qui pourrait garantir sa p?rennit?. M?me si la >> programmation r?active fonctionnelle est un sous champ de la >> programmation fonctionnelle, un programme g?n?r? par elm a le m?rite >> de tourner dans un browser et de permettre des d?mos interactives ce >> qui rend le sujet moins aride. >> >> http://elm-lang.org/blog/Interactive-Programming.elm >> http://worrydream.com/LearnableProgramming/ >> >> >> >> >> >> On 3/21/14, Laurent Pierron wrote: >> > Bonjour, >> > >> > R?cemment je me suis pos? la question avec un coll?gue pour introduire >> un >> > s?minaire interne sur les langages fonctionnels, et on n'a pas r?ussi ? >> > trouver une r?ponse satisfaisante, on s'est heurt? aux diff?rents types >> de >> > langage fonctionnel (Lisp, ML famille, Haskell, etc.), qui peuvent >> inclure >> > des ?l?ments de langages imp?ratifs, des objets, des types alg?briques >> ou >> > uniquement des types simples et qui ont des strat?gies d'?valuation >> > diff?rentes. >> > >> > Personnellement, je dirais que dans un langage de fonctionnel >> l'ex?cution >> > d'un programme se fait uniquement par substitution d'expression sans >> > modification de l'?tat d'une machine alors que dans un langage imp?ratif >> > l'ex?cution se fait par ?valuation d'expression et modification de >> l'?tat de >> > la machine. >> > >> > On peut aussi dire que les langages fonctionnels sont bas?s sur le >> > lambda-calcul de Church, alors que les langages imp?ratifs sont bas?s >> sur la >> > machine de Turing, mais il faut expliquer ce qu'est le lambda-calcul. >> > >> > >> > Laurent Pierron >> > >> > Le 20 mars 2014 ? 11:26, Gautier DI FOLCO a >> > ?crit : >> > >> > Bonjour, >> > >> > Je vais peut-?tre poser une question tr?s g?n?rale, mais qu'est-ce qui >> > caract?rise un langage de programmation fonctionnel ? >> > Je m'explique : >> > - je sais qu'un LPF se base sur des expressions >> > - je sais en reconna?tre un quand j'en vois un >> > >> > mais chaque fois qu'on me pose la question, je ne suis pas foutu de >> donner >> > des ?l?ments caract?ristiques clairs. >> > >> > Est-ce que vous auriez une "phrase toute faite" ou quelque chose qui me >> > permette de l'expliquer simplement/clairement de mani?re juste ? >> > >> > Merci par avance. >> > _______________________________________________ >> > Haskell-fr mailing list >> > Haskell-fr at haskell.org >> > http://www.haskell.org/mailman/listinfo/haskell-fr >> > >> > _______________________________________________ >> > Haskell-fr mailing list >> > Haskell-fr at haskell.org >> > http://www.haskell.org/mailman/listinfo/haskell-fr >> > >> >> >> -- >> cognominal stef >> _______________________________________________ >> Haskell-fr mailing list >> Haskell-fr at haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-fr >> > > Je suis un peu dans le m?me cas, mais comme dans mes cercles je suis "le > plus cal? en FP" et qu'en plus je tente "d??vang?liser", j'ai de gros > efforts p?dagogiques ? fournir (ce qui n'est pas mon point fort). > Le soucis avec ces crit?res, transparence r?f?rentielle et typage > fort/statique, c'est que du coup tu sors Scala et Clojure par exemple. > > PS : je suis sur du Data-flow en ce moment du coup je connais un peu le > FRP, mais j'avoue ne pas avoir fait le lien avec Bret Victor. > > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > -------------- next part -------------- An HTML attachment was scrubbed... URL: From arnaud.oqube at gmail.com Fri Mar 21 15:21:08 2014 From: arnaud.oqube at gmail.com (Arnaud Bailly) Date: Fri, 21 Mar 2014 16:21:08 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?Caract=E9risation_des_langages_foncti?= =?iso-8859-1?q?onnels?= In-Reply-To: References: Message-ID: Bonjour Gautier, Pourquoi as-tu besoin de caract?riser "un langage de programmation fonctionnel" ? -- Arnaud Bailly FoldLabs Associate: http://foldlabs.com 2014-03-20 11:26 GMT+01:00 Gautier DI FOLCO : > Bonjour, > > Je vais peut-?tre poser une question tr?s g?n?rale, mais qu'est-ce qui > caract?rise un langage de programmation fonctionnel ? > Je m'explique : > - je sais qu'un LPF se base sur des expressions > - je sais en reconna?tre un quand j'en vois un > > mais chaque fois qu'on me pose la question, je ne suis pas foutu de donner > des ?l?ments caract?ristiques clairs. > > Est-ce que vous auriez une "phrase toute faite" ou quelque chose qui me > permette de l'expliquer simplement/clairement de mani?re juste ? > > Merci par avance. > > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > -------------- next part -------------- An HTML attachment was scrubbed... URL: From gautier.difolco at gmail.com Fri Mar 21 17:39:12 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Fri, 21 Mar 2014 18:39:12 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?Caract=E9risation_des_langages_foncti?= =?iso-8859-1?q?onnels?= In-Reply-To: References: Message-ID: Le 21 mars 2014 16:21, Arnaud Bailly a ?crit : > Bonjour Gautier, > > Pourquoi as-tu besoin de caract?riser "un langage de programmation > fonctionnel" ? > Comme je l'ai dit : "pour pouvoir r?pondre quand on me pose la question". -------------- next part -------------- An HTML attachment was scrubbed... URL: From gautier.difolco at gmail.com Sat Mar 22 11:08:49 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Sat, 22 Mar 2014 12:08:49 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?Caract=E9risation_des_langages_foncti?= =?iso-8859-1?q?onnels?= In-Reply-To: References: Message-ID: Question subsidiaire : Il me semblait qu'en FP tout ?tait fonctions, hors ?a fait d?j? 2-3 fois que j'entends que tout est valeurs, qu'en est-il vraiment ? -------------- next part -------------- An HTML attachment was scrubbed... URL: From valentin.robert.42 at gmail.com Sat Mar 22 16:13:30 2014 From: valentin.robert.42 at gmail.com (Valentin Robert) Date: Sat, 22 Mar 2014 09:13:30 -0700 Subject: [Haskell-fr] =?utf-8?q?Caract=C3=A9risation_des_langages_fonction?= =?utf-8?q?nels?= In-Reply-To: References: Message-ID: Puisque les fonctions sont manipulables comme toute valeur, les fonctions sont consid?r?es des valeurs. Pour ce qui est du "tout est fonction", je dirais que c'est plut?t une caract?ristique du lambda-calcul dans sa forme la plus ?pur?e, quand tout est encod? ? la Church. Mais ce n'est qu'un mod?le de langage fonctionnel. - Valentin 2014-03-22 4:08 GMT-07:00 Gautier DI FOLCO : > > Question subsidiaire : Il me semblait qu'en FP tout ?tait fonctions, hors > ?a fait d?j? 2-3 fois que j'entends que tout est valeurs, qu'en est-il > vraiment ? > > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > -------------- next part -------------- An HTML attachment was scrubbed... URL: From gautier.difolco at gmail.com Sat Mar 22 16:30:49 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Sat, 22 Mar 2014 17:30:49 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?Caract=E9risation_des_langages_foncti?= =?iso-8859-1?q?onnels?= In-Reply-To: References: Message-ID: Le 22 mars 2014 17:13, Valentin Robert a ?crit : > Puisque les fonctions sont manipulables comme toute valeur, les fonctions > sont consid?r?es des valeurs. > > Pour ce qui est du "tout est fonction", je dirais que c'est plut?t une > caract?ristique du lambda-calcul dans sa forme la plus ?pur?e, quand tout > est encod? ? la Church. > Mais ce n'est qu'un mod?le de langage fonctionnel. > > - Valentin > ok, merci. -------------- next part -------------- An HTML attachment was scrubbed... URL: From cognominal at gmail.com Sat Mar 22 17:22:38 2014 From: cognominal at gmail.com (=?ISO-8859-1?Q?St=E9phane_Payrard?=) Date: Sat, 22 Mar 2014 18:22:38 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?Caract=E9risation_des_langages_foncti?= =?iso-8859-1?q?onnels?= In-Reply-To: References: Message-ID: Pour certains langages, outre les fonctions, les types et les types de types (kinds en anglais) sont aussi des valeurs. C'est le cas pour les langages fonctionnels ? typage d?pendant comme idris. C'est aussi n?cessaire pour des langages qui supportent la r?flexion : http://fr.wikipedia.org/wiki/R%C3%A9flexion_(informatique) Les types comme valeur sont notamment n?cessaires pour les langages qui incluent un m?tamod?le. Cela permet d'impl?menter diff?rents mod?les objet, de d?crire le format des valeurs en m?moire selon leur type, de s?rialiser les donn?es et d'interragir avec des biblioth?ques externes. Ainsi une fonction est d?crite en partie par sa signature qui d?crit le type des param?tres et de celui de la valeur de retour. Via la r?flexion, la signature est accessible comme une valeur de type Signature. C'est un des points forts de Perl 6 et plus particuli?rement d'un des VM backend de son compilateur rakudo : moarvm. http://perl6advent.wordpress.com/2011/12/14/meta-programming-what-why-and-how/ http://www.jnthn.net/papers/2013-yapceu-moarvm.pdf https://github.com/jnthn/zavolaj/blob/master/README.markdown Mais on sort du fonctionnel et on entre dans la caract?risation des langages modernes en g?n?ral. Il est n?anmoins int?ressant de constater qu'avec Scala ou Perl 6 le fonctionnel devient un paradigme parmi d'autres dans des langages g?n?riques et de comprendre comment il s'y int?gre. On Saturday, March 22, 2014, Valentin Robert wrote: > Puisque les fonctions sont manipulables comme toute valeur, les fonctions > sont consid?r?es des valeurs. > > Pour ce qui est du "tout est fonction", je dirais que c'est plut?t une > caract?ristique du lambda-calcul dans sa forme la plus ?pur?e, quand tout > est encod? ? la Church. > Mais ce n'est qu'un mod?le de langage fonctionnel. > > - Valentin > > > 2014-03-22 4:08 GMT-07:00 Gautier DI FOLCO > >: > >> >> Question subsidiaire : Il me semblait qu'en FP tout ?tait fonctions, hors >> ?a fait d?j? 2-3 fois que j'entends que tout est valeurs, qu'en est-il >> vraiment ? >> >> _______________________________________________ >> Haskell-fr mailing list >> Haskell-fr at haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-fr >> >> > -- cognominal stef -------------- next part -------------- An HTML attachment was scrubbed... URL: From gautier.difolco at gmail.com Sat Mar 22 18:14:59 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Sat, 22 Mar 2014 19:14:59 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?Caract=E9risation_des_langages_foncti?= =?iso-8859-1?q?onnels?= In-Reply-To: References: Message-ID: Le 22 mars 2014 18:22, St?phane Payrard a ?crit : > Pour certains langages, outre les fonctions, les types et les types de > types (kinds en anglais) sont aussi des valeurs. > C'est le cas pour les langages fonctionnels ? typage d?pendant comme idris. > C'est aussi n?cessaire pour des langages qui supportent la r?flexion : > http://fr.wikipedia.org/wiki/R%C3%A9flexion_(informatique) > Les types comme valeur sont notamment n?cessaires pour les langages > qui incluent un m?tamod?le. Cela permet d'impl?menter diff?rents mod?les > objet, de d?crire le format des valeurs en m?moire selon leur type, de > s?rialiser les donn?es et d'interragir avec des biblioth?ques externes. > Ainsi une fonction est d?crite en partie par sa signature qui d?crit le > type des param?tres et de celui de la valeur de retour. Via la > r?flexion, la signature est accessible comme une valeur de type Signature. > C'est un des points forts de Perl 6 et plus particuli?rement d'un des > VM backend de son compilateur rakudo : moarvm. > > > http://perl6advent.wordpress.com/2011/12/14/meta-programming-what-why-and-how/ > http://www.jnthn.net/papers/2013-yapceu-moarvm.pdf > https://github.com/jnthn/zavolaj/blob/master/README.markdown > > Mais on sort du fonctionnel et on entre dans la caract?risation des > langages modernes en g?n?ral. > Il est n?anmoins int?ressant de constater qu'avec Scala ou Perl 6 le > fonctionnel devient un paradigme parmi d'autres dans des langages > g?n?riques et de comprendre comment il s'y int?gre. > Int?ressant. Je vais peut-?tre dire une b?tise, mais il me semble que la seule mani?re de manipuler Haskell depuis Haskell (faire de la r?flexion) est d'utiliser les templates. Est-ce qu'il y a une explication sur le fait que ?a ne soit pas plus int?grer ? (on me vante beaucoup la grande simplicit? des macro de lisp par exemple) PS : j'ai conscience du faire que ce soit extr?mement provocateur, mais ce n'est pas mon but, je cherche juste ? avoir une meilleure vue d'ensemble, toutes corrections/explications/?claircissements(/insultes, mais pas trop) sont les bienvenues. -------------- next part -------------- An HTML attachment was scrubbed... URL: From gautier.difolco at gmail.com Wed Mar 26 10:10:59 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Wed, 26 Mar 2014 11:10:59 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissements_sur_les_monades?= Message-ID: Bonjour, Vaste sujet en perspective : les monades. Je pense avoir compris le principe des monades (?tre en mesure d'effectuer des actions sur une valeur au sein d'un contexte), en revanche il y a deux choses que je ne comprends pas : * La notion de contexte (ou de cadre de calcul) est un peu floue * Pourquoi est-ce que les monades sont aptes ? contenir les effets de bords (j'ai lu effectful computations) et pas d'autres typeclass (comme Applicative). Merci par avance pour vos r?ponses. -------------- next part -------------- An HTML attachment was scrubbed... URL: From arnaud.oqube at gmail.com Wed Mar 26 16:31:22 2014 From: arnaud.oqube at gmail.com (Arnaud Bailly) Date: Thu, 27 Mar 2014 00:31:22 +0800 Subject: [Haskell-fr] =?windows-1252?q?=C9claircissements_sur_les_monades?= In-Reply-To: References: Message-ID: <0CBC8926-35E6-4FF1-AEA7-B62FC057F212@gmail.com> Qu?est ce qui est un peu flou dans la notion de contexte ? A part le fait que ce soit justement un mot flou? qui peut d?signer n?importe quoi (une liste, une valeur optionnelle, le monde). Sur le fait que les monade soient plus aptes ? contenir les effets de bord, il me semble que c?est parce que le concept d?effet de bord implique la s?quentialit?, un avant et un apr?s : l?ordre dans lequel les effets de bord op?rent est important. Et c?est justement la propri?t? essentielle des monades qui n?est pas celle des foncteurs applicatifs que de s?quencer des ?op?rations?. Je trouve l?article de Wikipedia tr?s clair : https://en.wikipedia.org/wiki/Monads_in_functional_programming Arnaud On 26 Mar 2014, at 18:10, Gautier DI FOLCO wrote: > Bonjour, > > Vaste sujet en perspective : les monades. > Je pense avoir compris le principe des monades (?tre en mesure d'effectuer des actions sur une valeur au sein d'un contexte), en revanche il y a deux choses que je ne comprends pas : > * La notion de contexte (ou de cadre de calcul) est un peu floue > * Pourquoi est-ce que les monades sont aptes ? contenir les effets de bords (j'ai lu effectful computations) et pas d'autres typeclass (comme Applicative). > > Merci par avance pour vos r?ponses. > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr From gautier.difolco at gmail.com Wed Mar 26 16:47:15 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Wed, 26 Mar 2014 17:47:15 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissements_sur_les_monades?= In-Reply-To: <0CBC8926-35E6-4FF1-AEA7-B62FC057F212@gmail.com> References: <0CBC8926-35E6-4FF1-AEA7-B62FC057F212@gmail.com> Message-ID: Le 26 mars 2014 17:31, Arnaud Bailly a ?crit : > Qu'est ce qui est un peu flou dans la notion de contexte ? A part le fait > que ce soit justement un mot flou... qui peut d?signer n'importe quoi (une > liste, une valeur optionnelle, le monde). > Par exemple que repr?sente le fait d'avoir comme contexte/cadre de calcul une liste ? que je ne peux utiliser que les fonctions propres aux listes ? > Sur le fait que les monade soient plus aptes ? contenir les effets de > bord, il me semble que c'est parce que le concept d'effet de bord implique > la s?quentialit?, un avant et un apr?s : l'ordre dans lequel les effets de > bord op?rent est important. Et c'est justement la propri?t? essentielle des > monades qui n'est pas celle des foncteurs applicatifs que de s?quencer des > "op?rations". > > Je trouve l'article de Wikipedia tr?s clair : > https://en.wikipedia.org/wiki/Monads_in_functional_programming > > Arnaud > Ma question est l?, qu'est-ce qui d?fini cette notion de s?quence ? en quoi les 4-5 fonctions du typeclass font qu'il y a une notion de s?quence ? -------------- next part -------------- An HTML attachment was scrubbed... URL: From arnaud.oqube at gmail.com Wed Mar 26 16:52:13 2014 From: arnaud.oqube at gmail.com (Arnaud Bailly) Date: Thu, 27 Mar 2014 00:52:13 +0800 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissements_sur_les_monades?= In-Reply-To: References: <0CBC8926-35E6-4FF1-AEA7-B62FC057F212@gmail.com> Message-ID: Que tu effectue un calcul qui produit plusieurs r?sultats. Mois ?a m?aide de comprendre les monades vraiment comme des objets que tu construis. On 27 Mar 2014, at 00:47, Gautier DI FOLCO wrote: > Le 26 mars 2014 17:31, Arnaud Bailly a ?crit : > Qu?est ce qui est un peu flou dans la notion de contexte ? A part le fait que ce soit justement un mot flou? qui peut d?signer n?importe quoi (une liste, une valeur optionnelle, le monde). > > Par exemple que repr?sente le fait d'avoir comme contexte/cadre de calcul une liste ? que je ne peux utiliser que les fonctions propres aux listes ? > > Sur le fait que les monade soient plus aptes ? contenir les effets de bord, il me semble que c?est parce que le concept d?effet de bord implique la s?quentialit?, un avant et un apr?s : l?ordre dans lequel les effets de bord op?rent est important. Et c?est justement la propri?t? essentielle des monades qui n?est pas celle des foncteurs applicatifs que de s?quencer des ?op?rations?. > > Je trouve l?article de Wikipedia tr?s clair : https://en.wikipedia.org/wiki/Monads_in_functional_programming > > Arnaud > > Ma question est l?, qu'est-ce qui d?fini cette notion de s?quence ? en quoi les 4-5 fonctions du typeclass font qu'il y a une notion de s?quence ? > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr -------------- next part -------------- An HTML attachment was scrubbed... URL: -------------- next part -------------- A non-text attachment was scrubbed... Name: signature.asc Type: application/pgp-signature Size: 496 bytes Desc: Message signed with OpenPGP using GPGMail URL: From alpmestan at gmail.com Wed Mar 26 16:55:35 2014 From: alpmestan at gmail.com (Alp Mestanogullari) Date: Wed, 26 Mar 2014 17:55:35 +0100 Subject: [Haskell-fr] =?utf-8?q?=C3=89claircissements_sur_les_monades?= In-Reply-To: References: <0CBC8926-35E6-4FF1-AEA7-B62FC057F212@gmail.com> Message-ID: Le truc du contexte, je pense qu'ya une bonne image pour le repr?senter. Ce qui est propre au monade et que n'ont pas les applicatives, c'est que la suite d'une fonction d?pende de ce qui se passe ? un moment donn?. Exemple: foo :: IO () foo = do s <- getLine case s of "hello" -> putStrLn " world!" _ -> foo ici, on fait quelque chose dans IO, et selon le r?sultat, il peut se passer deux choses compl?tement diff?rentes. On se sert beucoup de ce genre de "contexte" dans les parsers par exemple, c'est litt?ralement explicit, les parsers ont une forte analogie avec la monade State. Alors qu'avec Applicative, tu peux avoir des "effets", des computations avec un petit truc en plus (parseurs qui retournent une valeur mais qui entre temps ont consum? une partie de l'input pour produire ces valeurs), etc, mais t'es oblig? de garder la m?me "structure" pour ton code, ex: data Person = Person { age :: Int, name :: String } blah :: Parser Person blah = Parser <$> parseInt <*> parseString T'auras beau faire ce que tu veux, taper dans tes mains, danser la salsa, etc, tu pourras pas changer le comportement de ce parseur de "personnes" selon la valeur de l'Int ou de la chaine de caract?res. Enfin, pour terminer, c'est cet article que j'ai trouv? le plus profond sur les monades: http://blog.sigfpe.com/2006/08/you-could-have-invented-monads-and.html En esp?rant que ?a t'aide ? comprendre! 2014-03-26 17:47 GMT+01:00 Gautier DI FOLCO : > Le 26 mars 2014 17:31, Arnaud Bailly a ?crit : > > Qu?est ce qui est un peu flou dans la notion de contexte ? A part le fait >> que ce soit justement un mot flou? qui peut d?signer n?importe quoi (une >> liste, une valeur optionnelle, le monde). >> > > Par exemple que repr?sente le fait d'avoir comme contexte/cadre de calcul > une liste ? que je ne peux utiliser que les fonctions propres aux listes ? > > >> Sur le fait que les monade soient plus aptes ? contenir les effets de >> bord, il me semble que c?est parce que le concept d?effet de bord implique >> la s?quentialit?, un avant et un apr?s : l?ordre dans lequel les effets de >> bord op?rent est important. Et c?est justement la propri?t? essentielle des >> monades qui n?est pas celle des foncteurs applicatifs que de s?quencer des >> ?op?rations?. >> >> Je trouve l?article de Wikipedia tr?s clair : >> https://en.wikipedia.org/wiki/Monads_in_functional_programming >> >> Arnaud >> > > Ma question est l?, qu'est-ce qui d?fini cette notion de s?quence ? en > quoi les 4-5 fonctions du typeclass font qu'il y a une notion de s?quence ? > > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > -- Alp Mestanogullari -------------- next part -------------- An HTML attachment was scrubbed... URL: From hsyl20 at gmail.com Wed Mar 26 17:04:27 2014 From: hsyl20 at gmail.com (Sylvain Henry) Date: Wed, 26 Mar 2014 18:04:27 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissements_sur_les_monades?= In-Reply-To: References: Message-ID: 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 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 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) * 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". * 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. @+ Sylvain Le 26 mars 2014 11:10, Gautier DI FOLCO a ?crit : > Bonjour, > > Vaste sujet en perspective : les monades. > Je pense avoir compris le principe des monades (?tre en mesure d'effectuer > des actions sur une valeur au sein d'un contexte), en revanche il y a deux > choses que je ne comprends pas : > * La notion de contexte (ou de cadre de calcul) est un peu floue > * Pourquoi est-ce que les monades sont aptes ? contenir les effets de > bords (j'ai lu effectful computations) et pas d'autres typeclass (comme > Applicative). > > Merci par avance pour vos r?ponses. > > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > -------------- next part -------------- An HTML attachment was scrubbed... URL: From gautier.difolco at gmail.com Wed Mar 26 18:32:11 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Wed, 26 Mar 2014 19:32:11 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissements_sur_les_monades?= In-Reply-To: References: <0CBC8926-35E6-4FF1-AEA7-B62FC057F212@gmail.com> Message-ID: Le 26 mars 2014 17:55, Alp Mestanogullari a ?crit : > Le truc du contexte, je pense qu'ya une bonne image pour le repr?senter. > > Ce qui est propre au monade et que n'ont pas les applicatives, c'est que > la suite d'une fonction d?pende de ce qui se passe ? un moment donn?. > Exemple: > > foo :: IO () > foo = do > s <- getLine > case s of > "hello" -> putStrLn " world!" > _ -> foo > > ici, on fait quelque chose dans IO, et selon le r?sultat, il peut se > passer deux choses compl?tement diff?rentes. On se sert beucoup de ce genre > de "contexte" dans les parsers par exemple, c'est litt?ralement explicit, > les parsers ont une forte analogie avec la monade State. > En gros tu cr?e une d?pendance qui force ton ex?cution dans un certain ordre en lui passant le pr?c?dent monde ? > Alors qu'avec Applicative, tu peux avoir des "effets", des computations > avec un petit truc en plus (parseurs qui retournent une valeur mais qui > entre temps ont consum? une partie de l'input pour produire ces valeurs), > etc, mais t'es oblig? de garder la m?me "structure" pour ton code, ex: > Tu entends quoi par "computation" (d?sol?, je bloque sur ce terme, ?a ne rentre pas :/) Tu veux dire truc en moins ou Monade ? si non, je sur largu?. Je ne comprends pas la derni?re partie de la phrase. > data Person = Person { age :: Int, name :: String } > > blah :: Parser Person > blah = Parser > <$> parseInt > <*> parseString > > T'auras beau faire ce que tu veux, taper dans tes mains, danser la salsa, > etc, tu pourras pas changer le comportement de ce parseur de "personnes" > selon la valeur de l'Int ou de la chaine de caract?res. > Perdu :/ Quelle est la "d?claration" (je ne sais pas comment ?a se dit : data/type/newtype) de Parser ? Comment le monde est "pass?" aux parse* ? Comment il sait quel type de Parser il doit produire ? (le premi?re ligne du corps de blah appel le Constructeur du type Parser, comment sait-il qu'il va "retourner" une valeur de type Parser Person ? vu que Person n'est indiqu? nul part dans le corps). > Enfin, pour terminer, c'est cet article que j'ai trouv? le plus profond > sur les monades: > http://blog.sigfpe.com/2006/08/you-could-have-invented-monads-and.html > > Je vais le rererelire, ? chaque fois je comprends un truc de nouveau. -------------- next part -------------- An HTML attachment was scrubbed... URL: From gautier.difolco at gmail.com Wed Mar 26 18:41:35 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Wed, 26 Mar 2014 19:41:35 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissements_sur_les_monades?= In-Reply-To: References: Message-ID: Le 26 mars 2014 18:04, Sylvain Henry 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: From alpmestan at gmail.com Wed Mar 26 18:58:12 2014 From: alpmestan at gmail.com (Alp Mestanogullari) Date: Wed, 26 Mar 2014 19:58:12 +0100 Subject: [Haskell-fr] =?utf-8?q?=C3=89claircissements_sur_les_monades?= In-Reply-To: References: <0CBC8926-35E6-4FF1-AEA7-B62FC057F212@gmail.com> Message-ID: Ok, je vais essayer de reprendre plus tranquillou ce que j'ai dit en r?pondant point par point. 2014-03-26 19:32 GMT+01:00 Gautier DI FOLCO : > Le 26 mars 2014 17:55, Alp Mestanogullari a ?crit : > > Le truc du contexte, je pense qu'ya une bonne image pour le repr?senter. >> >> Ce qui est propre au monade et que n'ont pas les applicatives, c'est que >> la suite d'une fonction d?pende de ce qui se passe ? un moment donn?. >> Exemple: >> >> foo :: IO () >> foo = do >> s <- getLine >> case s of >> "hello" -> putStrLn " world!" >> _ -> foo >> >> ici, on fait quelque chose dans IO, et selon le r?sultat, il peut se >> passer deux choses compl?tement diff?rentes. On se sert beucoup de ce genre >> de "contexte" dans les parsers par exemple, c'est litt?ralement explicit, >> les parsers ont une forte analogie avec la monade State. >> > > En gros tu cr?e une d?pendance qui force ton ex?cution dans un certain > ordre en lui passant le pr?c?dent monde ? > Bah, tu as tout simplement le moyen de faire ?a avec ce que te donne IO. Mais tu pourrais faire pareil dans une autre monade. L'id?e c'est que l?, 'getLine' c'est de type IO String, donc 's' est une String, on est d'accord? H? bien on peut gr?ce ? la do-notation (c'est gr?ce ? la fa?on dont la do-notation est traduite en avalanche de >>= et return & compagnie en fait). Comment? Tr?s simple: f :: IO () f = do s <- getLine putStrLn s se traduit en f' :: IO f' = getLine >>= \s -> putStrLn s -- ou plus simple: f' = getLine >>= putStrLn Re-regardons le type de >>= pour IO: (>>=) :: IO a -> (a -> IO b) -> IO b En gros t'as qqch qui va te produire un 'a' ? travers des effets (lecture de fichiers, depuis une DB, depuis stdin, ...) - (c'est ?a la signification de 'IO a') - et tu vois que le deuxi?me argument de >>= prend un 'a', donc en gros >>= donne ? son deuxi?me argument la valeur g?n?r?e par le premier argument. C'est cette "inspection" qui te permet en gros de faire un peu ce que tu veux avec ce 'a' tant que tu produis un 'IO b' pour un certain type 'b'. > Alors qu'avec Applicative, tu peux avoir des "effets", des computations >> avec un petit truc en plus (parseurs qui retournent une valeur mais qui >> entre temps ont consum? une partie de l'input pour produire ces valeurs), >> etc, mais t'es oblig? de garder la m?me "structure" pour ton code, ex: >> > > Tu entends quoi par "computation" (d?sol?, je bloque sur ce terme, ?a ne > rentre pas :/) > l'?valuation d'une expression, de qqch. > Tu veux dire truc en moins ou Monade ? si non, je sur largu?. > Non non, je veux dire que Monad permet ?a aussi, mais Applicative ne permet *QUE* ?a, alors que Monad, comme montr? juste au-dessus, permet d'inspecter ce que t'as produit et r?agir en cons?quence. Applicative te permet juste d'appliquer des fonctions pures, par ex de type 'a -> b -> c', ? des arguments qui viennent "d'ailleurs", par ex 'IO a' et 'IO b'. Exemple: data ProgrammingLanguage = ProgrammingLanguage { name :: String, fileExtension :: String } getProgrammingLanguageFromStdin :: IO ProgrammingLanguage getProgrammingLanguageFromStdin = ProgrammingLanguage <$> getLine <*> getLine Ca va te permettre d'entrer le nom d'un langage, , l'extension des fichiers associ?e ? ce langage (".hs" pour Haskell par exemple, quoi), et ?a te retournera une valeur de type ProgrammingLanguage. Si tu utilisais les fonctions de Monad pour faire ?a: getProgrammingLanguageFromStdin :: IO ProgrammingLanguage getProgrammingLanguageFromStdin = do name <- getLine fileExt <- getLine return $ ProgrammingLanguage name fileExt Tu noteras que contrairement ? mon exemple ? la con de 'case s of "hello" -> ...', ici on cherche pas ? agir diff?remment selon la valeur qu'on obtient gr?ce ? getLine, que ce soit pour le nom o? l'extension, et c'est exactement ce qui fait qu'on peut ?crire cette fonction tout ? fait utile aussi bien avec les fonctions d'Applicative ( <*> combin?e ? <$> = fmap de Functor ) qu'avec la do-notation. Histoire d'?tre complet, si tu veux ?crire ?a sans le do mais quand m?me avec les fonctions de Monad: getProgrammingLanguageFromStdin :: IO ProgrammingLanguage getProgrammingLanguageFromStdin = getLine >>= \name -> getLine >>= \fileExt -> return (ProgrammingLanguage name fileExt) > Perdu :/ > Quelle est la "d?claration" (je ne sais pas comment ?a se dit : > data/type/newtype) de Parser ? > Peu importe, mais il est ?tabli que les parseurs sont Monad/Applicative. "Parser Int" c'est qqch qui va essayer de parser un int quand tu lui donneras une String sur laquelle essayer. Parser Person c'est un truc qui va essayer de parser une "Person" quand tu lui donneras une entr?e sur laquelle essayer. Comment? Il va essayer de parser un Int, puis une String, et si les deux r?ussissent, il passe tout ?a au constructeur 'Person'. Comment le monde est "pass?" aux parse* ? > Ca fait partie du fonctionnement interne. G?n?ralement un parseur c'est une fonction du genre 'String -> (a, String)'. Donc un truc qui attend une String en entr?e et qui va tenter de produire un 'a' (Person par exemple dans notre exemple) gr?ce ? ce qu'il trouvera dans cette String et retournera ? c?t? de la valeur "ce qui n'a pas encore ?t? consomm?". Dans la vraie vie, ils sont plus compliqu?s, mais ?a te donne peut-?tre une id?e. > Comment il sait quel type de Parser il doit produire ? (le premi?re ligne > du corps de blah appel le Constructeur du type Parser, comment sait-il > qu'il va "retourner" une valeur de type Parser Person ? vu que Person n'est > indiqu? nul part dans le corps). > Il le sait parce que il connait le type des attributs de Person (age de type Int, name de type String) et il connait le type de parseInt et parseString. Et si, justement, Person est indiqu? dans le corps. La version Monad t'aidera peut-?tre: parsePerson :: Parser Person parsePerson = do age <- parseInt name <- parseString return (Person age name) La version applicative fait *EXACTEMENT* ?a. Ne t'inqui?tes pas, on est tous pass?s par l?, faut changer sa fa?on de penser pour bien piger tout ?a. Faut oublier toutes les merdes qu'on a appris ailleurs, repenser la programmation. Ca va prendre un peu de temps mais tu vas y arriver. En attendant, h?site pas ? signaler ce qui n'est toujours pas clair apr?s ce message. -- Alp Mestanogullari -------------- next part -------------- An HTML attachment was scrubbed... URL: From valentin.robert.42 at gmail.com Wed Mar 26 20:19:19 2014 From: valentin.robert.42 at gmail.com (Valentin Robert) Date: Wed, 26 Mar 2014 13:19:19 -0700 Subject: [Haskell-fr] =?utf-8?q?=C3=89claircissements_sur_les_monades?= In-Reply-To: References: Message-ID: 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 2014-03-26 11:41 GMT-07:00 Gautier DI FOLCO : > Le 26 mars 2014 18:04, Sylvain Henry 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 ? > > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > -------------- next part -------------- An HTML attachment was scrubbed... URL: From gautier.difolco at gmail.com Wed Mar 26 21:59:15 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Wed, 26 Mar 2014 22:59:15 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissements_sur_les_monades?= In-Reply-To: References: <0CBC8926-35E6-4FF1-AEA7-B62FC057F212@gmail.com> Message-ID: Le 26 mars 2014 19:58, Alp Mestanogullari a ?crit : > Ok, je vais essayer de reprendre plus tranquillou ce que j'ai dit en > r?pondant point par point. > > 2014-03-26 19:32 GMT+01:00 Gautier DI FOLCO : > > Le 26 mars 2014 17:55, Alp Mestanogullari a ?crit : >> >> Le truc du contexte, je pense qu'ya une bonne image pour le repr?senter. >>> >>> Ce qui est propre au monade et que n'ont pas les applicatives, c'est que >>> la suite d'une fonction d?pende de ce qui se passe ? un moment donn?. >>> Exemple: >>> >>> foo :: IO () >>> foo = do >>> s <- getLine >>> case s of >>> "hello" -> putStrLn " world!" >>> _ -> foo >>> >>> ici, on fait quelque chose dans IO, et selon le r?sultat, il peut se >>> passer deux choses compl?tement diff?rentes. On se sert beucoup de ce genre >>> de "contexte" dans les parsers par exemple, c'est litt?ralement explicit, >>> les parsers ont une forte analogie avec la monade State. >>> >> >> En gros tu cr?e une d?pendance qui force ton ex?cution dans un certain >> ordre en lui passant le pr?c?dent monde ? >> > > Bah, tu as tout simplement le moyen de faire ?a avec ce que te donne IO. > Mais tu pourrais faire pareil dans une autre monade. > L'id?e c'est que l?, 'getLine' c'est de type IO String, donc 's' est une > String, on est d'accord? H? bien on peut gr?ce ? la do-notation (c'est > gr?ce ? la fa?on dont la do-notation est traduite en avalanche de >>= et > return & compagnie en fait). Comment? > > Tr?s simple: > > f :: IO () > f = do > s <- getLine > putStrLn s > > se traduit en > > f' :: IO > f' = getLine >>= \s -> putStrLn s > > -- ou plus simple: f' = getLine >>= putStrLn > Je viens de piger je crois. En fait je me m?langeais dans le s?sucrage, c'est plus claire d?j?. > Re-regardons le type de >>= pour IO: > > (>>=) :: IO a -> (a -> IO b) -> IO b > > En gros t'as qqch qui va te produire un 'a' ? travers des effets (lecture > de fichiers, depuis une DB, depuis stdin, ...) - (c'est ?a la signification > de 'IO a') - et tu vois que le deuxi?me argument de >>= prend un 'a', donc > en gros >>= donne ? son deuxi?me argument la valeur g?n?r?e par le premier > argument. C'est cette "inspection" qui te permet en gros de faire un peu ce > que tu veux avec ce 'a' tant que tu produis un 'IO b' pour un certain type > 'b'. > ?a c'?tait bon (je suis fier de moi alors que c'est "tout b?te") > Alors qu'avec Applicative, tu peux avoir des "effets", des computations >>> avec un petit truc en plus (parseurs qui retournent une valeur mais qui >>> entre temps ont consum? une partie de l'input pour produire ces valeurs), >>> etc, mais t'es oblig? de garder la m?me "structure" pour ton code, ex: >>> >> >> Tu entends quoi par "computation" (d?sol?, je bloque sur ce terme, ?a ne >> rentre pas :/) >> > > l'?valuation d'une expression, de qqch. > pas mieux, ?a correspond ? quoi ? Tu veux dire truc en moins ou Monade ? si non, je sur largu?. >> > > Non non, je veux dire que Monad permet ?a aussi, mais Applicative ne > permet *QUE* ?a, alors que Monad, comme montr? juste au-dessus, permet > d'inspecter ce que t'as produit et r?agir en cons?quence. Applicative te > permet juste d'appliquer des fonctions pures, par ex de type 'a -> b -> c', > ? des arguments qui viennent "d'ailleurs", par ex 'IO a' et 'IO b'. > > Exemple: > > data ProgrammingLanguage = ProgrammingLanguage { name :: String, > fileExtension :: String } > > getProgrammingLanguageFromStdin :: IO ProgrammingLanguage > getProgrammingLanguageFromStdin = > ProgrammingLanguage <$> getLine > <*> getLine > > Ca va te permettre d'entrer le nom d'un langage, , l'extension des > fichiers associ?e ? ce langage (".hs" pour Haskell par exemple, quoi), et > ?a te retournera une valeur de type ProgrammingLanguage. > > Si tu utilisais les fonctions de Monad pour faire ?a: > > getProgrammingLanguageFromStdin :: IO ProgrammingLanguage > getProgrammingLanguageFromStdin = do > name <- getLine > fileExt <- getLine > return $ ProgrammingLanguage name fileExt > > Tu noteras que contrairement ? mon exemple ? la con de 'case s of "hello" > -> ...', ici on cherche pas ? agir diff?remment selon la valeur qu'on > obtient gr?ce ? getLine, que ce soit pour le nom o? l'extension, et c'est > exactement ce qui fait qu'on peut ?crire cette fonction tout ? fait utile > aussi bien avec les fonctions d'Applicative ( <*> combin?e ? <$> = fmap de > Functor ) qu'avec la do-notation. > ok pig?, je ne voyais pas o? tu voulais en venir avant (je pensais que tu parlais de faire des IO via des Applicatives). > Histoire d'?tre complet, si tu veux ?crire ?a sans le do mais quand m?me > avec les fonctions de Monad: > > getProgrammingLanguageFromStdin :: IO ProgrammingLanguage > getProgrammingLanguageFromStdin = > getLine >>= \name -> getLine >>= \fileExt -> return > (ProgrammingLanguage name fileExt) > > >> Perdu :/ >> Quelle est la "d?claration" (je ne sais pas comment ?a se dit : >> data/type/newtype) de Parser ? >> > > Peu importe, mais il est ?tabli que les parseurs sont Monad/Applicative. > "Parser Int" c'est qqch qui va essayer de parser un int quand tu lui > donneras une String sur laquelle essayer. > > Parser Person c'est un truc qui va essayer de parser une "Person" quand tu > lui donneras une entr?e sur laquelle essayer. Comment? Il va essayer de > parser un Int, puis une String, et si les deux r?ussissent, il passe tout > ?a au constructeur 'Person'. > > Comment le monde est "pass?" aux parse* ? >> > > Ca fait partie du fonctionnement interne. G?n?ralement un parseur c'est > une fonction du genre 'String -> (a, String)'. Donc un truc qui attend une > String en entr?e et qui va tenter de produire un 'a' (Person par exemple > dans notre exemple) gr?ce ? ce qu'il trouvera dans cette String et > retournera ? c?t? de la valeur "ce qui n'a pas encore ?t? consomm?". Dans > la vraie vie, ils sont plus compliqu?s, mais ?a te donne peut-?tre une id?e. > ok, compris. > Comment il sait quel type de Parser il doit produire ? (le premi?re >> ligne du corps de blah appel le Constructeur du type Parser, comment >> sait-il qu'il va "retourner" une valeur de type Parser Person ? vu que >> Person n'est indiqu? nul part dans le corps). >> > > Il le sait parce que il connait le type des attributs de Person (age de > type Int, name de type String) et il connait le type de parseInt et > parseString. > Et si, justement, Person est indiqu? dans le corps. La version Monad > t'aidera peut-?tre: > > parsePerson :: Parser Person > parsePerson = do > age <- parseInt > name <- parseString > return (Person age name) > > La version applicative fait *EXACTEMENT* ?a. > ok, je comprends. > Ne t'inqui?tes pas, on est tous pass?s par l?, faut changer sa fa?on de > penser pour bien piger tout ?a. Faut oublier toutes les merdes qu'on a > appris ailleurs, repenser la programmation. Ca va prendre un peu de temps > mais tu vas y arriver. > > En attendant, h?site pas ? signaler ce qui n'est toujours pas clair apr?s > ce message. > Merci, merci encore, c'est ?a que j'aime bien en Haskell, d?s que tu as compris c'est limpide mais tu as toujours des choses ? apprendre. -------------- next part -------------- An HTML attachment was scrubbed... URL: From gautier.difolco at gmail.com Wed Mar 26 22:12:20 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Wed, 26 Mar 2014 23:12:20 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissements_sur_les_monades?= In-Reply-To: References: Message-ID: Le 26 mars 2014 21:19, Valentin Robert 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: From valentin.robert.42 at gmail.com Thu Mar 27 00:37:03 2014 From: valentin.robert.42 at gmail.com (Valentin Robert) Date: Wed, 26 Mar 2014 17:37:03 -0700 Subject: [Haskell-fr] =?utf-8?q?=C3=89claircissements_sur_les_monades?= In-Reply-To: References: Message-ID: Non je ne dirais pas ?a. L'id?e g?n?rale est "comment peut-on appliquer fonctions en tenant compte d'un certain contexte ?". Une solution (fournie par Functor) est d'appliquer une fonction pure de tout contexte (a -> b) directement sur un contexte en entr?e (c a) : c a -> (a -> b) -> c b Dans ce cas, la structure du contexte de sortie est uniquement d?pendante de la structure du contexte de l'entr?e, jamais de la fonction. Une solution (fournie par Applicative) est d'appliquer une fonction pure plac?e dans un contexte (c (a -> b)) sur l'entr?e : c a -> c (a -> b) -> c b Dans ce cas, la structure du contexte de sortie est d?termin?e par le contexte de l'entr?e et le contexte de la fonction, mais toujours pas par la fonction. Une solution (fournie par Monad) est d'appliquer une fonciton (a -> c b) qui produit, pour la valeur plac?e dans le contexte de l'entr?e (le a), une autre valeur dans un autre contexte (le (c b)) : c a -> (a -> c b) -> c b Dans ce cas, la structure du contexte de sortie peut ?tre influenc? par la fonction, qui peut d?pendre de la valeur dans le contexte d'entr?e. Je n'utiliserai pas le vocabulaire read/write/drop/create car je ne pense pas que ?a aidera ? ?claircir les id?es. Tout comme je n'utiliserai pas d'analogie, car elles marchent souvent bien pour un exemple et tr?s mal pour un autre. Parler de contexte est d?j? ? la limite du douteux pour certaines monades... Si cela n'est pas tr?s clair, ne te tracasse pas trop, et essaie de lire ou ?crire quelques programmes applicatifs et monadiques pour certaines monades, puis de lire ou ?crire quelques programmes pour des monades g?n?riques, et tu finiras par discerner les motifs sous-jacents. - Valentin 2014-03-26 15:12 GMT-07:00 Gautier DI FOLCO : > Le 26 mars 2014 21:19, Valentin Robert 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. > > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > -------------- next part -------------- An HTML attachment was scrubbed... URL: From popavdan at yahoo.com Thu Mar 27 05:07:45 2014 From: popavdan at yahoo.com (Dan Popa) Date: Wed, 26 Mar 2014 22:07:45 -0700 (PDT) Subject: [Haskell-fr] =?iso-8859-1?q?Fw=3A__=C9claircissements_sur_les_mon?= =?iso-8859-1?q?ades?= In-Reply-To: References: Message-ID: <1395896865.54526.YahooMailNeo@web162402.mail.bf1.yahoo.com> Hi, Sorry for writing in english, I am not from France. Take a look here, please: http://www.haskell.org/haskellwiki/Modular_Monadic_Compilers_for_Programming_Languages The source? at? #3) on the above page is a code generator written using the State monad. The state monad is necessary because here it provides a sort of context, like a set of the global variables in imperative programming. And that is why we are using The State Monad, to simulate the use of a set of global (or local) variables, used to store values. Especially in this example, the lenghts of the pieces of generated code are stored in order to compute the length of the biggers codes, when they are catenated, (glued together). Other monads have specific use. Parser monad is used for glueing parsers, the list monad can simulate paralel computations and even backtracking (there is a backtracking monad too), the Maybe monad is used to make computations including Nothing in the set of values, etc. Basically monadic capsules can be seen like Christmas Giftts containing compuations. And monadic operators have two kind of use: - return is a package maker, it creates a capsule, a package, like wrapping a gift - bind is something like:? how to combine a function with a package. Open the package, compose functions, take care to produce an other package (or capsule). Hoping it helps, Sincerely yours, Dan Popa ----- Forwarded Message ----- From: Gautier DI FOLCO To: La liste Haskell Francophone Sent: Wednesday, March 26, 2014 12:10 PM Subject: [Haskell-fr] ?claircissements sur les monades Bonjour, Vaste sujet en perspective : les monades. Je pense avoir compris le principe des monades (?tre en mesure d'effectuer des actions sur une valeur au sein d'un contexte), en revanche il y a deux choses que je ne comprends pas : ?* La notion de contexte (ou de cadre de calcul) est un peu floue ?* Pourquoi est-ce que les monades sont aptes ? contenir les effets de bords (j'ai lu effectful computations) et pas d'autres typeclass (comme Applicative). Merci par avance pour vos r?ponses. _______________________________________________ Haskell-fr mailing list Haskell-fr at haskell.org http://www.haskell.org/mailman/listinfo/haskell-fr -------------- next part -------------- An HTML attachment was scrubbed... URL: From gautier.difolco at gmail.com Thu Mar 27 09:08:56 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Thu, 27 Mar 2014 10:08:56 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissements_sur_les_monades?= In-Reply-To: References: Message-ID: Le 27 mars 2014 01:37, Valentin Robert a ?crit : > Non je ne dirais pas ?a. > > L'id?e g?n?rale est "comment peut-on appliquer fonctions en tenant compte > d'un certain contexte ?". > > Une solution (fournie par Functor) est d'appliquer une fonction pure de > tout contexte (a -> b) directement sur un contexte en entr?e (c a) : > c a -> (a -> b) -> c b > Dans ce cas, la structure du contexte de sortie est uniquement d?pendante > de la structure du contexte de l'entr?e, jamais de la fonction. > > Une solution (fournie par Applicative) est d'appliquer une fonction pure > plac?e dans un contexte (c (a -> b)) sur l'entr?e : > c a -> c (a -> b) -> c b > Dans ce cas, la structure du contexte de sortie est d?termin?e par le > contexte de l'entr?e et le contexte de la fonction, mais toujours pas par > la fonction. > > Une solution (fournie par Monad) est d'appliquer une fonciton (a -> c b) > qui produit, pour la valeur plac?e dans le contexte de l'entr?e (le a), une > autre valeur dans un autre contexte (le (c b)) : > c a -> (a -> c b) -> c b > Dans ce cas, la structure du contexte de sortie peut ?tre influenc? par la > fonction, qui peut d?pendre de la valeur dans le contexte d'entr?e. > > > > Je n'utiliserai pas le vocabulaire read/write/drop/create car je ne pense > pas que ?a aidera ? ?claircir les id?es. Tout comme je n'utiliserai pas > d'analogie, car elles marchent souvent bien pour un exemple et tr?s mal > pour un autre. Parler de contexte est d?j? ? la limite du douteux pour > certaines monades... > > Si cela n'est pas tr?s clair, ne te tracasse pas trop, et essaie de lire > ou ?crire quelques programmes applicatifs et monadiques pour certaines > monades, puis de lire ou ?crire quelques programmes pour des monades > g?n?riques, et tu finiras par discerner les motifs sous-jacents. > > - Valentin > > C'est un peu plus claire, merci. -------------- next part -------------- An HTML attachment was scrubbed... URL: From gautier.difolco at gmail.com Thu Mar 27 09:11:26 2014 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Thu, 27 Mar 2014 10:11:26 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?Fw=3A_=C9claircissements_sur_les_mona?= =?iso-8859-1?q?des?= In-Reply-To: <1395896865.54526.YahooMailNeo@web162402.mail.bf1.yahoo.com> References: <1395896865.54526.YahooMailNeo@web162402.mail.bf1.yahoo.com> Message-ID: 2014-03-27 6:07 GMT+01:00 Dan Popa : > Hi, > > Sorry for writing in english, I am not from France. > Take a look here, please: > > http://www.haskell.org/haskellwiki/Modular_Monadic_Compilers_for_Programming_Languages > > The source at #3) on the above page is a code generator written using > the State monad. > The state monad is necessary because here it provides a sort of context, > like a set of the global variables > in imperative programming. > And that is why we are using The State Monad, to simulate the > use of a set of global (or local) variables, used to store values. > > Especially in this example, the lenghts of the pieces of generated code > are stored in order to compute the length of the biggers codes, when they > are catenated, (glued together). > > Other monads have specific use. Parser monad is used for glueing parsers, > the list monad can simulate paralel computations and even backtracking > (there is a backtracking monad too), the Maybe monad is used to make > computations including Nothing in the set of values, etc. > > Basically monadic capsules can be seen like Christmas Giftts containing > compuations. And monadic operators have two kind of use: > - return is a package maker, it creates a capsule, a package, like > wrapping a gift > - bind is something like: how to combine a function with a package. Open > the package, compose functions, take care to produce an other package (or > capsule). > > Hoping it helps, > Sincerely yours, > Dan Popa > > ----- Forwarded Message ----- > *From:* Gautier DI FOLCO > *To:* La liste Haskell Francophone > *Sent:* Wednesday, March 26, 2014 12:10 PM > *Subject:* [Haskell-fr] ?claircissements sur les monades > > Bonjour, > > Vaste sujet en perspective : les monades. > Je pense avoir compris le principe des monades (?tre en mesure d'effectuer > des actions sur une valeur au sein d'un contexte), en revanche il y a deux > choses que je ne comprends pas : > * La notion de contexte (ou de cadre de calcul) est un peu floue > * Pourquoi est-ce que les monades sont aptes ? contenir les effets de > bords (j'ai lu effectful computations) et pas d'autres typeclass (comme > Applicative). > > Merci par avance pour vos r?ponses. > > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > > > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > State Monads are clearer to me, thanks. -------------- next part -------------- An HTML attachment was scrubbed... URL: