Je lis la lecture de Conor McBride et de la perle fonctionnelle de Ross Paterson: Programmation applicative avec effets: "(The Vous souhaitez créer un et comme sur p. 2 du papier, J'ai développé ceci en notation canonique à, P > la fonction spécifique à la liste Notez que sous la forme expansée, où Merci d'avance! p> Je pense que je l'ai eu pour travailler; d'abord, j'ai réécrit Mon saut de foi supposait que Espérons que c'est bien (semble être le "Solution" sur p. 18 du papier) ... Merci pour l'aide, tout le monde! p> p> nouvelle version Strike>, avec" idiomes "dans le titre). J'ai un peu de difficulté avec l'exercice 4, qui est expliqué ci-dessous. Toute astuce serait très appréciée (surtout: devrais-je commencer à écrire fmap code> et
joindre code> ou
retour code> et
>> = code> ?).
instruction problématique h3>
instance monade [] code> où P>
ap = zapp code>. p>
Fonctions de la bibliothèque standard h3>
AP code> applique une valeur de fonction monadique à une valeur monadique. P>
zapp code> ("zippy application") applique une fonction d'une liste à une valeur correspondante dans une autre, à savoir p>
mes difficultés h3>
MF :: m (a -> b) code> est une liste de fonctions < Code> [(A -> B)] code> dans notre cas. Donc, dans la première application de
>>> = code>, nous avons p>
mu = (\ f -> (MS >> = \ s -> retour (fs))) code>. Maintenant, nous pouvons appeler
fs >> = mu code> comme sous-programme, mais cela ne sait pas de supprimer le premier élément de
MS code>. (Rappelons que nous voulons que la liste résultante soit [F1 S1, F2 S2, ...]. J'ai essayé de pirater quelque chose mais ... comme prévu, cela ne fonctionnait pas ... aucune aide serait très appréciée. < / p>
Editer 1 h3>
AP code> avec
fmap code> et
rejoindre code> comme utilisateur "COMONAD" suggéré. P>
fmap = mapper code>. Si quelqu'un peut expliquer comment Pour y arriver, je l'apprécierais beaucoup. Après cela, il est clair que
rejoindre code> fonctionne dans la liste des listes "COMONAD" suggéré, et devrait être la diagonale,
\ x - > zipwith (((!!). OLL) x [0 ..] code>. Mon code complet est ceci: p>
3 Réponses :
hm. Je ne peux pas m'empêcher de penser que cet exercice est un peu injuste comme présenté. P>
Exercice 4 (Colist Monad) em> h3>
Bien que
répéter code> et
zapp code> ne sont pas le
renvoyer code> et
ap code> de l'habituel
monad [] code> instance, ils ne sont pas moins le
renvoyer code> et
ap code> d'une monade alternative, plus adaptée à L'interprétation coindante de
[] code>. Quel est le
Join :: [[[x]] → [x] code> de cette monade? P>
Commentaire sur l'efficacité relative de cette monade
AP code> et notre
zapp code>. p> blockQuote>
Premièrement, je suis assez certain que l'instance monad en question est
non valide pour [] code> en général strong>. Quand ils disent "l'interprétation coindante", je soupçonne que cela fait référence à listes infinies em>. L'instance est réellement valable pour les listes finies dans certains cas, mais pas pour les listes arbitraires en général. P>
C'est donc votre première, très générale, indice - pourquoi une instance monad ne serait-elle valable que pour certaines listes, particulièrement infinies? P>
Voici votre deuxième indice:
FMAP code> et
retour code> est trivial donné d'autres définitions plus tôt dans le document. Vous avez déjà
retour code>;
fmap code> n'est que légèrement moins évident. P>
En outre,
(>> =) code> a une implémentation facile en termes d'autres fonctions, comme avec tout
monad code>, qui laisse
rejoindre code> comme le creux de la matière. Dans la plupart des cas,
(>> =) code> est plus naturel pour la programmation avec, mais
rejoindre code> est plus fondamentalement fondamental et dans ce cas, je pense, plus simple d'analyser. Je recommande donc de travailler sur cela et d'oublier
(>> =) code> pour l'instant. Une fois que vous avez une implémentation, vous pouvez revenir en arrière et reconstruire
(>> =) code> et vérifier les lois monad pour vous assurer que tout fonctionne correctement. P>
Enfin, supposons un instant que vous avez
fmap code> disponible, mais rien d'autre. Valeurs données avec type
[A -> B] code> et
[A] code>, vous pouvez les combiner pour obtenir quelque chose de type
[[B] code> . Le type de
rejoindre code> est ici
[[[a]] -> [a] code>. Comment pourriez-vous écrire
rejoindre code> de telle sorte que vous obtenez le même résultat ici que vous iriez à partir d'utiliser
zapp code> sur les valeurs d'origine? Notez que la question sur l'efficacité relative est, ainsi qu'une question, une indice quant à la mise en œuvre. P>
@camccann: Je ne suis pas clair sur un point. Si l'interprétation de cotination fait référence à des listes infinies (je suis d'accord c'est probablement), alors ne serait pas répéter code> et
zapp code> former réellement une monade qui n'est pas nonité à ladite interprétation cofinante ? C'est le cas de
ZIPLIST code>, qui n'a pas d'instance de monad valide. Quoi qu'il en soit, je soupçonne que les auteurs ont choisi cet exemple pour indiquer que les foncteurs applicatifs sont utiles en partie parce qu'ils sont plus généraux que les monads (honte sur moi, je n'ai pas encore lu le papier).
@John L: errrh ... Vous avez raison que cela équivaut à ZIPLIST code>, mais vous avez manqué quelques autres choses, et je ne peux pas vraiment clarifier sans gâcher la réponse à l'exercice Gatorotitro travaille sur. : [
@CamCcan: J'avais peur de ça. Je vais juste lire le papier et espérer que cela remplit les détails.
@John L: Probablement pas - je ne l'ai probablement pas écoulée (après avoir lu la version plus ancienne auparavant) mais je ne pense pas que cette monade particulière est venue à l'extérieur de l'exercice, ce que j'ai cité complet. Cela dit, c'est une bonne lecture, alors aucun mal à le donner! Mais si vous préférez une explication plus directe que de travailler vous-même à travers l'exercice vous-même, n'hésitez pas à me contacter par courrier électronique.
@CamCcann: Vous avez tout à fait raison, le papier était inutile à cet effet (bien que sinon une bonne lecture!). Cependant, j'ai remarqué que j'ai mal interprété l'exercice et je pensais à une liste régulière monade, pas au colon monad. Cela a effacé bien.
@John L: Oui, c'est certainement très différent de la norme joindre code> pour les listes! La comparaison d'efficacité est également intéressante - elle concerne ce que je pouvais appeler la différence "philosophique" entre
applicatif code> et
monad code> et des différences de performance similaires peuvent exister pour d'autres fonctions-- Il semble que je me souvienne d'entendre en entendant des combinaisons d'analyseurs, par exemple.
La définition complète minimale d'une monade est soit maintenant, la mise en œuvre de dans l'exercice, la sémantique de fmap code> +
retour code> +
joindre code> ou
retour code> +
+
(>> =) code>. Vous pouvez implémenter celui avec l'autre:
AP code> peut être réécrit en termes de
joindre code> et
FMAP code>: p>
FMAP code> et
retour code> et
AP code> est donné.
Le reste sera évident, dès que vous examinerez un exemple: p>
Juste curieux, flip fmap code> a-t-il un sens catégorique? (S'il est juste d'interpréter
fmap code> en tant que foncteur de tri?)
@GatoAttiGrado: Cela a du sens dans la mesure où les endofuncteurs de la catégorie des types de haskell sont équivalents aux familles de morphismes de la catégorie. En termes catégoriques, Join :: M (MA) -> MA Code> est une transformation naturelle et
FMAP :: (A -> B) -> (FA -> FB) Code > est une cartographie des fonctions entre les flèches dans des catégories "différentes" ... mais Haskell aplatit tout ce qui est de type morphisme en juste
(->) code>.
Je pensais juste que je devrais clarifier que la version avec des exercices et des "idiomes" dans le titre est un brouillon plutôt antérieur EM> du document qui a finalement été apparu dans JFP. À ce moment-là, j'ai pensé à tort que les colis (par lesquels je veux dire peut-être des listes d'infinies, éventuellement finis) étaient une monade de manière à zapper: il existe un candidat plausible pour la jointure (alluitée dans d'autres réponses) mais Jeremy Gibbons était assez gentille de nous signaler que cela ne satisfait pas aux lois monad. Les contre-échappes impliquent des listes "déchiquetées" des listes avec des longueurs finies variables. De manière correspondante, dans l'article du JFP, nous sommes restés corrigés. (Nous étions plutôt heureux de cela, car nous aimons trouver des foncteurs applicatifs dont (<*>) n'est pas l'AP d'une monade.) P>
Les listes nécessairement infinies (c'est-à-dire flux em>), en excluant les cas en lambeaux, forment effectivement une monade dont AP se comporte comme Zapp. Pour une indice, notez que le flux X est isomorphe à NAT -> x. P>
Mes excuses pour la confusion. Il est parfois dangereux de laisser des brouillons anciens et inachevés (remplissez d'erreurs) mentent (ha ha) sur le Web. P>
Merci! Je profite de la version plus ancienne ayant des exercices, cependant :)
Oho! Cela fait plutôt plus de sens maintenant. Cela me semblait très étrange que l'exercice ne donnait aucune indication que la monade suggérée n'était valable que sur des listes de longueur égale.
@camccann qui me rappelle: tous les constructeurs de type vecteur de longueur fixe sont monadiques, par une construction similaire (y compris mon préféré, les vecteurs de la longueur zéro).
@Conor McBride: Eh bien, tout ce qui est en forme fixe peut être combiné à l'élément, qui sont toutes la même famille brute de monades qui ont souvent plus de sens comme applicatif code>. Vous pouvez "zip" arbres au lieu de substituer aux feuilles, par exemple. Interprétation
a -> b code> comme une structure de
B code> s dont la forme est donnée par
A code>, le lecteur monade est l'un d'entre eux aussi. Il y a une sorte d'abstraction bien rangée qui généraliste tout le lot ...
Concernant
FMAP code>: Les lois code> applicatifs > incluent l'identité
pure f <*> x code> =
f <$> x code>. Vous devriez être capable d'afficher
fmap code> comme étant
mappe code> en utilisant ceci. Et oui,
rejoindre code> prend la diagonale des listes imbriquées - en tant qu'exercice de suivi, vous pouvez essayer de montrer comment la diagonale étant mal définie sur des listes de longueurs différentes enfreint les lois monad.