From gautier.difolco at gmail.com Fri Dec 20 21:48:37 2013 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Fri, 20 Dec 2013 22:48:37 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissement_sur_les_Applicative?= =?iso-8859-1?q?s?= Message-ID: Bonjour, Cela fait maintenant quelques mois que je c?toie Haskell, j'arrive presque toujours ? mes fins, mais cela ne me convient pas, je tente donc de prendre le probl?me ? sa racine : la compr?hension, ou plut?t l'assimilation des concepts. Je pense que j'ai un soucis ? ce niveau car je pense plut?t bien voir comment tout s'embo?te, mais face au code, je suis incapable de l'appliquer ! Je vous laisse juger par vous-m?me. Je vais tenter d'expliquer ma mani?re de voir les choses de mani?re aussi d?taill?e que possible via un ensemble d'assertions (not?es AN o? N est le num?ro de l'assertion). Le typeclass Applicative ? la t?te suivante : class Functor f => Applicative f where pure :: a -> f a (<*>) :: f (a -> b) -> f a -> f b (*>) :: f a -> f b -> f b (<*) :: f a -> f b -> f a A1 : Ce qui signifie que tout type impl?mentant ces fonctions doivent ?galement impl?menter les fonctions de Functor. Q1 : quelle est l'int?r?t ? Nous avons pure :: Applicative f => a -> f a A2 : 'f a' signifie de type a impl?mentant le typeclass f (Applicative dans ce cas pr?cis A3 : Il s'agit "simplement" d'un lifting, d'une encapsulation, grosso-modo de donner un param?tre ? un constructeur. Ensuite (<*>) :: Applicative f => f (a -> b) -> f a -> f b A4 : prend une fonction et un param?tre dans un "emballage" impl?mentant Applicative et applique cette valeur ? cette fonction en retournant le type dans un autre "emballage". A5 : cette fonction sert dans deux cas : ? fournir un moyen de manipuler le contenu de "bo?tes", "d?curryfier" dans le sens passer des arguments au fur et ? mesure ? une fonction. Q2 : Y a-t-il d'autres cas d'application. A6 : <* et *> ne servent qu'? appliquer un des arguments. Q3 : quels sont les cas d'applications typiques ? j'ai du mal ? voir Ensuite il y a les fonctions de lifting : liftA :: Applicative f => (a -> b) -> f a -> f b A7 : prend une fonction "normale" ? un argument et en fait une fonction maniant une structure encapsul?e. Q4 : quel est l'int?r?t ? liftA (+1) $ Just 1 n'est pas ?gale ? pure (+1) <*> Just 1 ? Q5 : ou ? la version Functor : (+1) <$> Just 1 ? Q6 : dans le cas de version Functor, quel est l'int?r?t de la passer Applicative ? liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c A8 : idem mais avec deux arguments A9 : liftA2 (+) (Just 2) (Just 1) est ?quivalent ? liftA (+) (Just 2) <*> Just 1 Q7 : Quel est l'int?r?t du coup ? liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d A10 : idem mais avec trois arguments Q8 : Quel est l'int?r?t de Control.Applicative.Lift ? Il est ?crit : "Adding a new kind of pure computation to an applicative functor" Q9 : J'ai du mal ? saisir cette notion de calcul, est-ce qu'il est possible de me l'expliquer en deux mots ? Je me rend compte que mon mail est tr?s long, ?a fait plus de deux mois que je me casse les dents dessus, j'ai ?cum? plusieurs articles/livres, pas moyen de me faire une id?e claire de tout ?a, ou de voir les applications pratiques. Je vous serait tr?s reconnaissant de prendre le temps de me r?pondre et/ou de valider/invalider mes assertions, Merci par avance. PS : Par la suite j'aurais des question sur Alternative et les Monades PPS : la longueur de la r?daction m'a donn? une id?e pour Q7 : A11 : liftA2 et liftA3 servent ? obtenir des fonctions "passables" ? des fonctions qui le demande, ex : myF :: (Maybe a -> Maybe b -> Maybe c) -> a -> b -> Maybe c myF f a b = f (Just a) (Just b) la fonction serait appelable via myF (liftA2 (+)) 1 2 -------------- next part -------------- An HTML attachment was scrubbed... URL: From valentin.robert.42 at gmail.com Fri Dec 20 22:16:38 2013 From: valentin.robert.42 at gmail.com (Valentin Robert) Date: Fri, 20 Dec 2013 23:16:38 +0100 Subject: [Haskell-fr] =?utf-8?q?=C3=89claircissement_sur_les_Applicatives?= In-Reply-To: References: Message-ID: R?ponse dans le texte : 2013/12/20 Gautier DI FOLCO > Bonjour, > > Cela fait maintenant quelques mois que je c?toie Haskell, j'arrive presque > toujours ? mes fins, mais cela ne me convient pas, je tente donc de prendre > le probl?me ? sa racine : la compr?hension, ou plut?t l'assimilation des > concepts. Je pense que j'ai un soucis ? ce niveau car je pense plut?t bien > voir comment tout s'embo?te, mais face au code, je suis incapable de > l'appliquer ! Je vous laisse juger par vous-m?me. > Je vais tenter d'expliquer ma mani?re de voir les choses de mani?re aussi > d?taill?e que possible via un ensemble d'assertions (not?es AN o? N est le > num?ro de l'assertion). > Le typeclass Applicative ? la t?te suivante : > class Functor f => Applicative f where > pure :: a -> f a > (<*>) :: f (a -> b) -> f a -> f b > (*>) :: f a -> f b -> f b > (<*) :: f a -> f b -> f a > > A1 : Ce qui signifie que tout type impl?mentant ces fonctions doivent > ?galement impl?menter les fonctions de Functor. > Q1 : quelle est l'int?r?t ? > Ce n'est pas vraiment par int?r?t plut?t qu'une cons?quence du fait qu'un foncteur applicatif a un foncteur sous-jacent. En particulier, le foncteur est utilis? dans l'impl?mentation par d?faut de (*>) et (<*), et une instance correcte doit satisfaire la loi : f <$> x = pure f <*> x On pourrait s'en passer, mais c'est probablement pratique. > Nous avons pure :: Applicative f => a -> f a > A2 : 'f a' signifie de type a impl?mentant le typeclass f (Applicative > dans ce cas pr?cis > Hmm pas vraiment. `f a` signifie de type `f a`, o? `f` est un foncteur applicatif. > A3 : Il s'agit "simplement" d'un lifting, d'une encapsulation, grosso-modo > de donner un param?tre ? un constructeur. > > Ensuite (<*>) :: Applicative f => f (a -> b) -> f a -> f b > A4 : prend une fonction et un param?tre dans un "emballage" impl?mentant > Applicative et applique cette valeur ? cette fonction en retournant le type > dans un autre "emballage". > A5 : cette fonction sert dans deux cas : ? fournir un moyen de manipuler > le contenu de "bo?tes", "d?curryfier" dans le sens passer des arguments au > fur et ? mesure ? une fonction. > Q2 : Y a-t-il d'autres cas d'application. > Pas vraiment, c'est juste un "lift" de l'application d'une fonction. Donc ? utiliser quand tu as une fonction ? appliquer... A6 : <* et *> ne servent qu'? appliquer un des arguments. > Q3 : quels sont les cas d'applications typiques ? j'ai du mal ? voir > Je ne fais pas assez de Haskell pour savoir o? c'est utilis?, mais c'est probablement pass? comme argument ? une fonction d'ordre sup?rieur dans des cas sp?ciaux o? on n'a pas trop de choix sur le format des donn?es en entr?e et on veut ignorer la moiti?... Ensuite il y a les fonctions de lifting : > > liftA :: Applicative f => (a -> b) -> f a -> f b > A7 : prend une fonction "normale" ? un argument et en fait une fonction > maniant une structure encapsul?e. > Q4 : quel est l'int?r?t ? liftA (+1) $ Just 1 n'est pas ?gale ? pure (+1) > <*> Just 1 ? > Si, mais parfois tu as besoin de `pure` et parfois de `liftA`. Encore une fois, ?a d?pend de la fa?on dont c'est utilis?. ?videmment, si tu appliques tout compl?tement ?a semble redondant, mais quand tu appliques partiellement, `liftA (+1)` et `pure (+1)` ont un type diff?rent, tous deux utiles. > Q5 : ou ? la version Functor : (+1) <$> Just 1 ? > Q6 : dans le cas de version Functor, quel est l'int?r?t de la passer > Applicative ? > Pas d'int?r?t : si tout ce dont tu as besoin c'est `fmap`, utilise `fmap`. > liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c > A8 : idem mais avec deux arguments > A9 : liftA2 (+) (Just 2) (Just 1) est ?quivalent ? liftA (+) (Just 2) <*> > Just 1 > Q7 : Quel est l'int?r?t du coup ? > M?me r?ponse. Tu sembles chercher ? ?viter toute redondance. Pourquoi ne pas ?crire tout ton code avec juste des lambdas et des applications ? :-) > liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d > A10 : idem mais avec trois arguments > > Q8 : Quel est l'int?r?t de Control.Applicative.Lift ? > Il est ?crit : "Adding a new kind of pure computation to an applicative > functor" > Q9 : J'ai du mal ? saisir cette notion de calcul, est-ce qu'il est > possible de me l'expliquer en deux mots ? > Je ne saurai expliquer ?a clairement, mais tu peux jeter un coup d'oeil ici : http://hackage.haskell.org/package/transformers-0.3.0.0/docs/src/Control-Applicative-Lift.html#unLift En particulier, l'impl?mentation de `fmap` et le commentaire du type Errors peuvent te donner une id?e de ce qu'il se passe... Je me rend compte que mon mail est tr?s long, ?a fait plus de deux mois que > je me casse les dents dessus, j'ai ?cum? plusieurs articles/livres, pas > moyen de me faire une id?e claire de tout ?a, ou de voir les applications > pratiques. > Je vous serait tr?s reconnaissant de prendre le temps de me r?pondre et/ou > de valider/invalider mes assertions, > Merci par avance. > > PS : Par la suite j'aurais des question sur Alternative et les Monades > PPS : la longueur de la r?daction m'a donn? une id?e pour Q7 : > A11 : liftA2 et liftA3 servent ? obtenir des fonctions "passables" ? des > fonctions qui le demande, ex : > myF :: (Maybe a -> Maybe b -> Maybe c) -> a -> b -> Maybe c > myF f a b = f (Just a) (Just b) > la fonction serait appelable via myF (liftA2 (+)) 1 2 > Exactement ! _______________________________________________ > 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 Dec 20 22:47:10 2013 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Fri, 20 Dec 2013 23:47:10 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissement_sur_les_Applicative?= =?iso-8859-1?q?s?= In-Reply-To: References: Message-ID: Bonsoir, Merci de la rapidit? de ta r?ponse, la suite dans le texte : Le 20 d?cembre 2013 23:16, Valentin Robert a ?crit : > R?ponse dans le texte : > > > 2013/12/20 Gautier DI FOLCO > >> Nous avons pure :: Applicative f => a -> f a >> A2 : 'f a' signifie de type a impl?mentant le typeclass f (Applicative >> dans ce cas pr?cis >> > > Hmm pas vraiment. `f a` signifie de type `f a`, o? `f` est un foncteur > applicatif. > Donc pour 'f a', 'f' est un type param?trique qui impl?mente le typeclass Applicative et qui a un param?tre 'a' ? ?a signifie donc que les types n'ayant pas ou plusieurs param?tre de type ne peuvent pas ?tre utilis? dans cette fonction ? Comme Either ? > liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c >> A8 : idem mais avec deux arguments >> A9 : liftA2 (+) (Just 2) (Just 1) est ?quivalent ? liftA (+) (Just 2) <*> >> Just 1 >> Q7 : Quel est l'int?r?t du coup ? >> > > M?me r?ponse. Tu sembles chercher ? ?viter toute redondance. Pourquoi ne > pas ?crire tout ton code avec juste des lambdas et des applications ? :-) > En fait je cherche ? savoir pourquoi il y a plusieurs formes, mais visiblement je me pose trop de questions :/ > > >> liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d >> A10 : idem mais avec trois arguments >> >> Q8 : Quel est l'int?r?t de Control.Applicative.Lift ? >> Il est ?crit : "Adding a new kind of pure computation to an applicative >> functor" >> Q9 : J'ai du mal ? saisir cette notion de calcul, est-ce qu'il est >> possible de me l'expliquer en deux mots ? >> > > Je ne saurai expliquer ?a clairement, mais tu peux jeter un coup d'oeil > ici : > > > http://hackage.haskell.org/package/transformers-0.3.0.0/docs/src/Control-Applicative-Lift.html#unLift > > En particulier, l'impl?mentation de `fmap` et le commentaire du type > Errors peuvent te donner une id?e de ce qu'il se passe... > M?me une piste m'aiderais :/ J'ai l'impression qu'il s'agit de g?rer soit une valeur soit une valeur et une fonction ? lui appliquer, mais en quoi la valeur seule serait Pure ? Qu'est-ce que pure dans ce contexte ? Merci par avance de votre r?ponse. -------------- next part -------------- An HTML attachment was scrubbed... URL: From alpmestan at gmail.com Sat Dec 21 01:57:57 2013 From: alpmestan at gmail.com (Alp Mestanogullari) Date: Sat, 21 Dec 2013 02:57:57 +0100 Subject: [Haskell-fr] =?utf-8?q?=C3=89claircissement_sur_les_Applicatives?= In-Reply-To: References: Message-ID: Salut, R?ponse dans le texte aussi. Je r?ponds ? ton dernier mail et apr?s je relirai le premier pour voir si je peux apporter un autre angle que Valentin, etc. 2013/12/20 Gautier DI FOLCO > > 2013/12/20 Gautier DI FOLCO >> >>> Nous avons pure :: Applicative f => a -> f a >>> A2 : 'f a' signifie de type a impl?mentant le typeclass f (Applicative >>> dans ce cas pr?cis >>> >> >> Hmm pas vraiment. `f a` signifie de type `f a`, o? `f` est un foncteur >> applicatif. >> > > Donc pour 'f a', 'f' est un type param?trique qui impl?mente le typeclass > Applicative et qui a un param?tre 'a' ? > Oui tout ? fait. 'f' peut ?tre IO, [ ], Maybe, Either String (sans le 2? type en param?tre - oui c'est un d?but de r?ponse ? ta seconde question) ... ?a signifie donc que les types n'ayant pas ou plusieurs param?tre de type > ne peuvent pas ?tre utilis? dans cette fonction ? Comme Either ? > Bah comme je le dis justement entre parenth?ses, pour Either, il y a un probl?me au niveau des "kinds" (grosso modo les type des types). Au vu de la gueule d'Applicative, 'f' ne doit prendre qu'un type en param?tre. Mais 'f' peut ?tre un type param?tr? ? 45 param?tres, les 44 premiers ?tant fix?s ? des types pr?cis ou pas forc?ment: data Blah a b c d = Blah instance Applicative (Blah a b c) where ... data Foo a b c = Foo instance Applicative (Foo Int String) where -- ?a n?cessite {-# LANGUAGE FlexibleInstances #-}, je peux t'expliquer pourquoi si ?a t'int?resse. ... Et donc, si tu donnes un premier param?tre ? Either et que tu laisses varier le second, tu obtiens un Applicative :-) C'est plus clair ? liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c >>> A8 : idem mais avec deux arguments >>> A9 : liftA2 (+) (Just 2) (Just 1) est ?quivalent ? liftA (+) (Just 2) >>> <*> Just 1 >>> Q7 : Quel est l'int?r?t du coup ? >>> >> >> M?me r?ponse. Tu sembles chercher ? ?viter toute redondance. Pourquoi ne >> pas ?crire tout ton code avec juste des lambdas et des applications ? :-) >> > > En fait je cherche ? savoir pourquoi il y a plusieurs formes, mais > visiblement je me pose trop de questions :/ > C'est pas commun de pouvoir ?crire quelque chose de 15 mani?res diff?rentes d?s qu'on a un peu de "structure" (savoir que tel type impl?mente telle typeclass, tout ?a). Desfois c'est du simple "sucre syntaxique", desfois c'est deux concepts qui coincident, desfois autre chose. Te prends pas trop la t?te avec ?a ? mon avis. > M?me une piste m'aiderais :/ > J'ai l'impression qu'il s'agit de g?rer soit une valeur soit une valeur et > une fonction ? lui appliquer, mais en quoi la valeur seule serait Pure ? > Qu'est-ce que pure dans ce contexte ? > En gros, il s'agit de d?corer des valeurs quelconques avec d'autres valeurs *qui sont dans un applicative". Ou vu dans l'autre sens, il s'agit de d?corer un applicative avec des valeurs pures. Par "d?corer" j'entends "mettre ensemble avec". L'exemple des erreurs dont parle Valentin est en fait assez simple si on arrive ? se focaliser sur chaque truc un ? un. D?j?, Lift: > data Lift f a = Pure a | Other (f a) On va consid?rer Lift appliqu? un 'f' donn?, par exemple Maybe. > data LiftMaybe a = Pure a | Other (Maybe a) Donc c'est comme si on avait coll? tous les 'Maybe a' avec les 'a' tout court, en disant quand m?me qu'on se rappelle d'o? chacun vient gr?ce aux constructeurs. Tu noteras que le constructeur "Pure" qui apparait par magie, il coincide *EXACTEMENT* avec la fonction "pure" de Applicative, appliqu?e pour 'f' = 'Lift': > instance Applicative (Lift f) where > -- pure :: a -> Lift f a > pure x = Pure x > ... Maintenant, pour l'histoire d'erreurs. Le foncteur "Constant" c'est : > data Constant a b = Constant { getConstant :: a } Et son instance d'Applicative est un exercise assez simple et int?ressant selon ta familiarit? avec ces derniers. Dans tous les cas, t'as bien compris que le 'b' allait pas servir ? grand chose. Autrement dit, ?a prend deux types en param?tre, ?a ignore le deuxi?me et stocke juste une valeur du premier type. Maintenant, Errors: > type Errors e = Lift (Constant e) > -- ?quivalent ? > type Errors e a = Lift (Constant e) a > -- ? son tour "moralement ?quivalent ?" : > data Errors e a = Pure a | Other (Constant e) 'e' ?tant un type repr?sentant une erreur (comme String ou une liste de String ou quoi). Maintenant, les instances pour Lift devraient t'aider ? comprendre, en te disant que Errors rajoute aux valeurs "normales" (Pure, qui peut contenir un truc de n'importe quel type!) des valeurs d'erreur. Donc si avait t'avais des fonctions qui balan?aient des erreurs ? coups de 'error' et que maintenant tu veux faire ?a plus joliement, il te suffit d'utiliser 'pure'/'Pure' pour balancer tes valeurs normales dans un 'Errors e a', et d'utiliser failure pour signaler une erreur. Essaye ensuite de voir comment tout cela se passe si tu fixes 'e' et 'a' sur des types pr?cis, [String] et Int respectivement par exemple. Une derni?re chose: un des gros gros trucs sympas avec les applicatives pour moi c'est de pouvoir ?crire des trucs comme: > data Person = Person { name :: String, age :: Int, ip :: IPV6 } > > Person <$> getNameFromNSALeak <*> getAgeFromFacebook <*> unsafeGetIp o? getNameFromNSALeak :: IO String getAgeFromFacebook :: IO Int unsafeGetIp :: IO IPV6 donc sont des trucs qui retournent des valeurs "dans un applicative" (ici IO, mais aussi parsers, Maybe, conteneurs, Async, et bien d'autres). N'h?site pas si certains passages ne sont pas clairs ? demander des ?claircissements. -- Alp Mestanogullari -------------- next part -------------- An HTML attachment was scrubbed... URL: From arnaud.oqube at gmail.com Sat Dec 21 07:13:28 2013 From: arnaud.oqube at gmail.com (Arnaud Bailly) Date: Sat, 21 Dec 2013 08:13:28 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissement_sur_les_Applicative?= =?iso-8859-1?q?s?= In-Reply-To: References: Message-ID: Bonjour Gautier, Personnellement, la lecture de ce papier http://strictlypositive.org/IdiomLite.pdf m'a aid? ? mieux comprendre les foncteurs applicatifs. Il montre tr?s bien que le principal int?r?t de ces structures c'est de pouvoir ?crire des fonctions plus g?n?riques, comme ? peu pr?s toutes les structures en Haskell d'ailleurs... Une autre chose qui m'a beaucoup aid? c'est de comprendre le syst?me de type de Haskell de mani?re plus d?taill?e. Tu peux voir du c?t? du livre de Benjamin Pierce, par exemple. Une des portes d'entr?e possible, c'est de voir que le syst?me de types est lui aussi fonctionnel : tu as des valeurs (les types) et des fonctions (les constructeurs de types), ces derniers pouvant ?tre "currifi?s". Et tu peux appliquer ces objets les uns aux autres selon leur "genre" (kind) qui est le "syst?me de types" des types :-) Du coup une signature du genre: > pure :: (Applicative f) => a -> f a se lit simplement et donne comme indication que 'f' doit ?tre un constructeur de types avec un argument (de genre '* -> * pour ?tre pr?cis. Concernant tes questions, je crois que les autres r?ponses de la liste sont claires et que l'article dont je t'ai donn? le lien t'aidera aussi. Juste une remarque sur Q1 : il n'est question d'int?r?t ici, mais d'une obligation "contractuelle" qui rend n?cessaire que 'f' soit bien un foncteur pour permettre de construire un applicatif, simplement parce qu'un foncteur est la brique de base permettant d'encapsuler des valeurs dans types "conteneurs". Cordialement, -- Arnaud Bailly FoldLabs Associate: http://foldlabs.com 2013/12/20 Gautier DI FOLCO > Bonjour, > > Cela fait maintenant quelques mois que je c?toie Haskell, j'arrive presque > toujours ? mes fins, mais cela ne me convient pas, je tente donc de prendre > le probl?me ? sa racine : la compr?hension, ou plut?t l'assimilation des > concepts. Je pense que j'ai un soucis ? ce niveau car je pense plut?t bien > voir comment tout s'embo?te, mais face au code, je suis incapable de > l'appliquer ! Je vous laisse juger par vous-m?me. > Je vais tenter d'expliquer ma mani?re de voir les choses de mani?re aussi > d?taill?e que possible via un ensemble d'assertions (not?es AN o? N est le > num?ro de l'assertion). > Le typeclass Applicative ? la t?te suivante : > class Functor f => Applicative f where > pure :: a -> f a > (<*>) :: f (a -> b) -> f a -> f b > (*>) :: f a -> f b -> f b > (<*) :: f a -> f b -> f a > > A1 : Ce qui signifie que tout type impl?mentant ces fonctions doivent > ?galement impl?menter les fonctions de Functor. > Q1 : quelle est l'int?r?t ? > > Nous avons pure :: Applicative f => a -> f a > A2 : 'f a' signifie de type a impl?mentant le typeclass f (Applicative > dans ce cas pr?cis > A3 : Il s'agit "simplement" d'un lifting, d'une encapsulation, grosso-modo > de donner un param?tre ? un constructeur. > > Ensuite (<*>) :: Applicative f => f (a -> b) -> f a -> f b > A4 : prend une fonction et un param?tre dans un "emballage" impl?mentant > Applicative et applique cette valeur ? cette fonction en retournant le type > dans un autre "emballage". > A5 : cette fonction sert dans deux cas : ? fournir un moyen de manipuler > le contenu de "bo?tes", "d?curryfier" dans le sens passer des arguments au > fur et ? mesure ? une fonction. > Q2 : Y a-t-il d'autres cas d'application. > > A6 : <* et *> ne servent qu'? appliquer un des arguments. > Q3 : quels sont les cas d'applications typiques ? j'ai du mal ? voir > > Ensuite il y a les fonctions de lifting : > > liftA :: Applicative f => (a -> b) -> f a -> f b > A7 : prend une fonction "normale" ? un argument et en fait une fonction > maniant une structure encapsul?e. > Q4 : quel est l'int?r?t ? liftA (+1) $ Just 1 n'est pas ?gale ? pure (+1) > <*> Just 1 ? > Q5 : ou ? la version Functor : (+1) <$> Just 1 ? > Q6 : dans le cas de version Functor, quel est l'int?r?t de la passer > Applicative ? > liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c > A8 : idem mais avec deux arguments > A9 : liftA2 (+) (Just 2) (Just 1) est ?quivalent ? liftA (+) (Just 2) <*> > Just 1 > Q7 : Quel est l'int?r?t du coup ? > liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d > A10 : idem mais avec trois arguments > > Q8 : Quel est l'int?r?t de Control.Applicative.Lift ? > Il est ?crit : "Adding a new kind of pure computation to an applicative > functor" > Q9 : J'ai du mal ? saisir cette notion de calcul, est-ce qu'il est > possible de me l'expliquer en deux mots ? > > Je me rend compte que mon mail est tr?s long, ?a fait plus de deux mois > que je me casse les dents dessus, j'ai ?cum? plusieurs articles/livres, pas > moyen de me faire une id?e claire de tout ?a, ou de voir les applications > pratiques. > Je vous serait tr?s reconnaissant de prendre le temps de me r?pondre et/ou > de valider/invalider mes assertions, > Merci par avance. > > PS : Par la suite j'aurais des question sur Alternative et les Monades > PPS : la longueur de la r?daction m'a donn? une id?e pour Q7 : > A11 : liftA2 et liftA3 servent ? obtenir des fonctions "passables" ? des > fonctions qui le demande, ex : > myF :: (Maybe a -> Maybe b -> Maybe c) -> a -> b -> Maybe c > myF f a b = f (Just a) (Just b) > la fonction serait appelable via myF (liftA2 (+)) 1 2 > > _______________________________________________ > 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 Dec 21 11:22:12 2013 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Sat, 21 Dec 2013 12:22:12 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissement_sur_les_Applicative?= =?iso-8859-1?q?s?= In-Reply-To: References: Message-ID: Bonjour, Merci de vos r?ponses, la suite dans le texte : Le 21 d?cembre 2013 02:57, Alp Mestanogullari a ?crit : > > ?a signifie donc que les types n'ayant pas ou plusieurs param?tre de type >> ne peuvent pas ?tre utilis? dans cette fonction ? Comme Either ? >> > > Bah comme je le dis justement entre parenth?ses, pour Either, il y a un > probl?me au niveau des "kinds" (grosso modo les type des types). Au vu de > la gueule d'Applicative, 'f' ne doit prendre qu'un type en param?tre. Mais > 'f' peut ?tre un type param?tr? ? 45 param?tres, les 44 premiers ?tant > fix?s ? des types pr?cis ou pas forc?ment: > Une sorte de fonction curryfi?e ? laquelle il manquerait un param?tre ? > data Blah a b c d = Blah > > instance Applicative (Blah a b c) where > ... > > data Foo a b c = Foo > > instance Applicative (Foo Int String) where -- ?a n?cessite {-# LANGUAGE > FlexibleInstances #-}, je peux t'expliquer pourquoi si ?a t'int?resse. > ... > Je veux bien. > Et donc, si tu donnes un premier param?tre ? Either et que tu laisses > varier le second, tu obtiens un Applicative :-) > > C'est plus clair ? > Oui > L'exemple des erreurs dont parle Valentin est en fait assez simple si on > arrive ? se focaliser sur chaque truc un ? un. > > D?j?, Lift: > > > data Lift f a = Pure a | Other (f a) > > On va consid?rer Lift appliqu? un 'f' donn?, par exemple Maybe. > > > data LiftMaybe a = Pure a | Other (Maybe a) > > Donc c'est comme si on avait coll? tous les 'Maybe a' avec les 'a' tout > court, en disant quand m?me qu'on se rappelle d'o? chacun vient gr?ce aux > constructeurs. Tu noteras que le constructeur "Pure" qui apparait par > magie, il coincide *EXACTEMENT* avec la fonction "pure" de Applicative, > appliqu?e pour 'f' = 'Lift': > > > instance Applicative (Lift f) where > > -- pure :: a -> Lift f a > > pure x = Pure x > > ... > > Maintenant, pour l'histoire d'erreurs. Le foncteur "Constant" c'est : > > > data Constant a b = Constant { getConstant :: a } > > Et son instance d'Applicative est un exercise assez simple et int?ressant > selon ta familiarit? avec ces derniers. Dans tous les cas, t'as bien > compris que le 'b' allait pas servir ? grand chose. > > Autrement dit, ?a prend deux types en param?tre, ?a ignore le deuxi?me et > stocke juste une valeur du premier type. Maintenant, Errors: > > > type Errors e = Lift (Constant e) > > -- ?quivalent ? > > type Errors e a = Lift (Constant e) a > > -- ? son tour "moralement ?quivalent ?" : > > data Errors e a = Pure a | Other (Constant e) > > 'e' ?tant un type repr?sentant une erreur (comme String ou une liste de > String ou quoi). > > Maintenant, les instances pour Lift devraient t'aider ? comprendre, en te > disant que Errors rajoute aux valeurs "normales" (Pure, qui peut contenir > un truc de n'importe quel type!) des valeurs d'erreur. Donc si avait > t'avais des fonctions qui balan?aient des erreurs ? coups de 'error' et que > maintenant tu veux faire ?a plus joliement, il te suffit d'utiliser > 'pure'/'Pure' pour balancer tes valeurs normales dans un 'Errors e a', et > d'utiliser failure pour signaler une erreur. Essaye ensuite de voir comment > tout cela se passe si tu fixes 'e' et 'a' sur des types pr?cis, [String] et > Int respectivement par exemple. > Je vois mieux, mais du coup, quel est l'avantage par rapport ? un Either ? Le 21 d?cembre 2013 08:13, Arnaud Bailly a ?crit : > Bonjour Gautier, > > Personnellement, la lecture de ce papier > http://strictlypositive.org/IdiomLite.pdf m'a aid? ? mieux comprendre les > foncteurs applicatifs. Il montre tr?s bien que le principal int?r?t de ces > structures c'est de pouvoir ?crire des fonctions plus g?n?riques, comme ? > peu pr?s toutes les structures en Haskell d'ailleurs... > En fait mon soucis c'est de trouver comment l'appliquer au-del? des structures "triviale" (IO, Maybe, List, etc.) Une autre chose qui m'a beaucoup aid? c'est de comprendre le syst?me de > type de Haskell de mani?re plus d?taill?e. Tu peux voir du c?t? du livre de > Benjamin Pierce, par exemple. Une des portes d'entr?e possible, c'est de > voir que le syst?me de types est lui aussi fonctionnel : tu as des valeurs > (les types) et des fonctions (les constructeurs de types), ces derniers > pouvant ?tre "currifi?s". Et tu peux appliquer ces objets les uns aux > autres selon leur "genre" (kind) qui est le "syst?me de types" des types :-) > Lequel de ses livres ? Quand je tombe sur quelque chose comme : > instance Applicative (Lift f) where Cela signifie-t-il "pour tout type Lift encapsulant un type quelconque 'f', je d?finis les fonction de son typeclass Applicative" ? Du coup le Alternative sont un sorte de Mono?de pour les Applicative ? Il faut qu'il y en ai un de bon sur un couple ou un ensemble, c'est ?a ? ?a sert ? d?finir une valeur par d?faut, si je comprends. Merci par avance pour vos r?ponses (on touche au but). -------------- next part -------------- An HTML attachment was scrubbed... URL: From alpmestan at gmail.com Sat Dec 21 15:56:50 2013 From: alpmestan at gmail.com (Alp Mestanogullari) Date: Sat, 21 Dec 2013 16:56:50 +0100 Subject: [Haskell-fr] =?utf-8?q?=C3=89claircissement_sur_les_Applicatives?= In-Reply-To: References: Message-ID: Bonjour, 2013/12/21 Gautier DI FOLCO > Une sorte de fonction curryfi?e ? laquelle il manquerait un param?tre ? > C'est exactement ?a, simplement ?a se passe au niveau des types oui. Le dernier param?tre n'est pas "donn?" au type, on laisse ?a en suspens en quelque sorte. > instance Applicative (Foo Int String) where -- ?a n?cessite {-# LANGUAGE >> FlexibleInstances #-}, je peux t'expliquer pourquoi si ?a t'int?resse. >> ... >> > > Je veux bien. > Alors, si on essaie d'?crire cette instance sans activer cette extension, normalement on se choppe quelque chose du genre dans la t?te: Illegal instance declaration for `Applicative (Blah Int String Char)' (All instance types must be of the form (T a1 ... an) where a1 ... an are *distinct type variables*, and each type variable appears at most once in the instance head. Use -XFlexibleInstances if you want to disable this.) Ca veut dire que par d?faut, quand tu d?finis une instance t'es pas vraiment libre, ?a doit ?tre de la forme qu'ils donnent: "T a1 ... an", i.e: > instance MaTypeClass (T a1 ... an) where o? T est le nom d'un type ("type constructor"), et les "ai" sont des type variables. Ca veut dire que tu n'as pas vraiment le droit de fixer *un* des types (encore moins plusieurs). Tu as le m?me genre de restrictions sur le contexte (dans "instance (Blah a, Foo b) => MaClasse (Either a b) where", le contexte ce sont les deux contraintes ? gauche de "=>"), qui ont donn? lieu ? l'extension "FlexibleContexts". Voil? pour la petite disgression. Je vois mieux, mais du coup, quel est l'avantage par rapport ? un Either ? > Bah Errors l?, c'est ?quivalent ? Either a (Constant e) : > type Errors e a = Pure a | Other (Constant e) > type Either a b = Left a | Right b donc on voit que ?a marche si on prend 'b = Constant e'. Donc Errors est un cas particulier de Either en fait tout simplement. Il n'y a pas ?norm?ment d'avantages ? utiliser Errors l? plutot que Either, ErrorT & compagnie, parce qu'il y a pleins de fonctions utilitaires pour les autres, et puis de toute fa?on y'a 150 fa?ons de g?rer les erreurs en haskell et chacun ? la sienne ou suit celle d'un gourou qu'il aime bien. > En fait mon soucis c'est de trouver comment l'appliquer au-del? des > structures "triviale" (IO, Maybe, List, etc.) > Essaye de googler "applicative parsers" ?a peut ?tre int?ressant. 'aeson', 'attoparsec', 'parsec' etc illustrent tous cela il me semble. Mais sinon te focalise pas trop dessus, avance, ?cris du code, continue ? apprendre des choses, ?a fera vraiment "clic" le moment venu ne t'inqui?tes pas. Il y a encore quelques trucs que apr?s 5 ans de Haskell j'ai encore du mal ? comprendre, c'est un peu ce qui fait son charme d'ailleurs mais bon. > Lequel de ses livres ? > "Types and Programming Languages" je suppose (affectueusement appel? 'TAPL"). > Quand je tombe sur quelque chose comme : > > > instance Applicative (Lift f) where > > Cela signifie-t-il "pour tout type Lift encapsulant un type quelconque > 'f', je d?finis les fonction de son typeclass Applicative" ? > Applicative repr?sente la possibilit? de pouvoir effectuer certaines op?rations, un peu comme tu pourrais avoir une "Interface" (au sens OO) en Java. Une instance se lit souvent comme "voil? comment on d?finit ces op?rations pour mon type". En l'occurence, dans ton exemple, on d?finit une infinit? d'instances, en qq sorte, puisqu'on laisse varier 'f'. Du coup le Alternative sont un sorte de Mono?de pour les Applicative ? > Il faut qu'il y en ai un de bon sur un couple ou un ensemble, c'est ?a ? > ?a sert ? d?finir une valeur par d?faut, si je comprends. > Alternative fournit d'une part une "valeur par d?faut" en effet ('empty'), et une fa?on d'exprimer une sorte de "combinaison", l'op?rateur <|>, qui souvent agit comme une sorte de "ou". Par exemple, l'exemple des Alternatives pour les parsers: si tu as un code du genre : > parseA <|> parseB typiquement il essayera de parser un "A" et si ?a ?choue, ?a essayera de parser un "B". -- Alp Mestanogullari -------------- next part -------------- An HTML attachment was scrubbed... URL: From gautier.difolco at gmail.com Sat Dec 21 17:23:17 2013 From: gautier.difolco at gmail.com (Gautier DI FOLCO) Date: Sat, 21 Dec 2013 18:23:17 +0100 Subject: [Haskell-fr] =?iso-8859-1?q?=C9claircissement_sur_les_Applicative?= =?iso-8859-1?q?s?= In-Reply-To: References: Message-ID: Le 21 d?cembre 2013 16:56, Alp Mestanogullari a ?crit : > Bonjour, > > 2013/12/21 Gautier DI FOLCO > >> Une sorte de fonction curryfi?e ? laquelle il manquerait un param?tre ? >> > > C'est exactement ?a, simplement ?a se passe au niveau des types oui. Le > dernier param?tre n'est pas "donn?" au type, on laisse ?a en suspens en > quelque sorte. > > >> instance Applicative (Foo Int String) where -- ?a n?cessite {-# >>> LANGUAGE FlexibleInstances #-}, je peux t'expliquer pourquoi si ?a >>> t'int?resse. >>> ... >>> >> >> Je veux bien. >> > > Alors, si on essaie d'?crire cette instance sans activer cette extension, > normalement on se choppe quelque chose du genre dans la t?te: > > Illegal instance declaration for `Applicative > (Blah Int String Char)' > (All instance types must be of the form (T a1 ... an) > where a1 ... an are *distinct type variables*, > and each type variable appears at most once in the instance head. > Use -XFlexibleInstances if you want to disable this.) > > Ca veut dire que par d?faut, quand tu d?finis une instance t'es pas > vraiment libre, ?a doit ?tre de la forme qu'ils donnent: "T a1 ... an", i.e: > > > instance MaTypeClass (T a1 ... an) where > > o? T est le nom d'un type ("type constructor"), et les "ai" sont des type > variables. Ca veut dire que tu n'as pas vraiment le droit de fixer *un* des > types (encore moins plusieurs). Tu as le m?me genre de restrictions sur le > contexte (dans "instance (Blah a, Foo b) => MaClasse (Either a b) where", > le contexte ce sont les deux contraintes ? gauche de "=>"), qui ont donn? > lieu ? l'extension "FlexibleContexts". > > Voil? pour la petite disgression. > > Je vois mieux, mais du coup, quel est l'avantage par rapport ? un Either ? >> > > Bah Errors l?, c'est ?quivalent ? Either a (Constant e) : > > > type Errors e a = Pure a | Other (Constant e) > > > type Either a b = Left a | Right b > > donc on voit que ?a marche si on prend 'b = Constant e'. Donc Errors est > un cas particulier de Either en fait tout simplement. Il n'y a pas > ?norm?ment d'avantages ? utiliser Errors l? plutot que Either, ErrorT & > compagnie, parce qu'il y a pleins de fonctions utilitaires pour les autres, > et puis de toute fa?on y'a 150 fa?ons de g?rer les erreurs en haskell et > chacun ? la sienne ou suit celle d'un gourou qu'il aime bien. > > >> En fait mon soucis c'est de trouver comment l'appliquer au-del? des >> structures "triviale" (IO, Maybe, List, etc.) >> > > Essaye de googler "applicative parsers" ?a peut ?tre int?ressant. 'aeson', > 'attoparsec', 'parsec' etc illustrent tous cela il me semble. Mais sinon te > focalise pas trop dessus, avance, ?cris du code, continue ? apprendre des > choses, ?a fera vraiment "clic" le moment venu ne t'inqui?tes pas. Il y a > encore quelques trucs que apr?s 5 ans de Haskell j'ai encore du mal ? > comprendre, c'est un peu ce qui fait son charme d'ailleurs mais bon. > > >> Lequel de ses livres ? >> > > "Types and Programming Languages" je suppose (affectueusement appel? > 'TAPL"). > > >> Quand je tombe sur quelque chose comme : >> >> > instance Applicative (Lift f) where >> >> Cela signifie-t-il "pour tout type Lift encapsulant un type quelconque >> 'f', je d?finis les fonction de son typeclass Applicative" ? >> > > Applicative repr?sente la possibilit? de pouvoir effectuer certaines > op?rations, un peu comme tu pourrais avoir une "Interface" (au sens OO) en > Java. Une instance se lit souvent comme "voil? comment on d?finit ces > op?rations pour mon type". En l'occurence, dans ton exemple, on d?finit une > infinit? d'instances, en qq sorte, puisqu'on laisse varier 'f'. > > Du coup le Alternative sont un sorte de Mono?de pour les Applicative ? >> Il faut qu'il y en ai un de bon sur un couple ou un ensemble, c'est ?a ? >> ?a sert ? d?finir une valeur par d?faut, si je comprends. >> > > Alternative fournit d'une part une "valeur par d?faut" en effet ('empty'), > et une fa?on d'exprimer une sorte de "combinaison", l'op?rateur <|>, qui > souvent agit comme une sorte de "ou". Par exemple, l'exemple des > Alternatives pour les parsers: si tu as un code du genre : > > > parseA <|> parseB > > typiquement il essayera de parser un "A" et si ?a ?choue, ?a essayera de > parser un "B". > > -- > Alp Mestanogullari > > _______________________________________________ > Haskell-fr mailing list > Haskell-fr at haskell.org > http://www.haskell.org/mailman/listinfo/haskell-fr > > Ok, merci c'est plus claire. -------------- next part -------------- An HTML attachment was scrubbed... URL: