Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2016-06-13T21:23:08+02:00Les derniers messages parus sur le forum de Zeste de Savoir.Besoin d'explication sur le fonctionnement des parseurs, message #1139622016-06-13T21:23:08+02:00LudoBike/@LudoBikehttps://zestedesavoir.com/forums/sujet/6302/besoin-dexplication-sur-le-fonctionnement-des-parseurs/?page=1#p113962<p>Ok, c'est bon j'ai enfin compris, du coup merci. Je met le sujet en résolu car pour moi il l'ai.</p>Besoin d'explication sur le fonctionnement des parseurs, message #1139422016-06-13T19:40:17+02:00Berdes/@Berdeshttps://zestedesavoir.com/forums/sujet/6302/besoin-dexplication-sur-le-fonctionnement-des-parseurs/?page=1#p113942<p>Sauf si tu définis un type (comme <code>Parser</code>) qui ne ressemble pas à une fonction mais qui en est une quand même.</p>
<p>Si tu regardes l'implémentation de <code>Parser</code> (qui est un <code>ParsecT</code>), tu te rends compte que c'est une fonction : <a href="https://hackage.haskell.org/package/parsec-3.1.9/docs/src/Text-Parsec-Prim.html#ParsecT">https://hackage.haskell.org/package/parsec-3.1.9/docs/src/Text-Parsec-Prim.html#ParsecT</a></p>Besoin d'explication sur le fonctionnement des parseurs, message #1139392016-06-13T19:19:06+02:00LudoBike/@LudoBikehttps://zestedesavoir.com/forums/sujet/6302/besoin-dexplication-sur-le-fonctionnement-des-parseurs/?page=1#p113939<p>Oui j'ai assez bien compris ce principe mais du coup en y réfléchissant je pense que c'est surtout le type <code>Parser</code> qui me pose un problème puisque normalement même si la déclaration de la fonction est implicite la déclaration de type devrait l'expliciter puisque j'ai beau écrire <code>deuxXPlusUn</code> comme tu l'as fait ou ainsi <code>deuxXPlusUn x = x*2 + 1</code> la déclaration de type sera toujours <code>deuxXPlusUn :: (Num a) => a -> a</code> </p>Besoin d'explication sur le fonctionnement des parseurs, message #1139172016-06-13T17:49:52+02:00Eusèbe/@Eus%C3%A8behttps://zestedesavoir.com/forums/sujet/6302/besoin-dexplication-sur-le-fonctionnement-des-parseurs/?page=1#p113917<blockquote>
<p>En fait je ne comprends pas comment la fonction parse fait pour parser avec parseExpr alors que parseExpr ne prend pas d'arguments et du coup tout me parait flou et je bloque.</p>
</blockquote>
<p>Indépendamment du fait qu'on donne une interface monadique ou pas à ton parser, ce n'est pas parce que <code>parseExpr</code> n'est pas syntaxiquement explicitement écrit comme une fonction que ce n'en est pas une. L'opérateur <code><|></code> prend deux fonctions en paramètre et renvoie une troisième fonction.</p>
<p>Tu peux observer le même comportement sur un exemple plus simple :</p>
<table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3
4
5
6</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="nf">plusUn</span> <span class="n">x</span> <span class="ow">=</span> <span class="n">x</span> <span class="o">+</span> <span class="mi">1</span>
<span class="nf">double</span> <span class="n">x</span> <span class="ow">=</span> <span class="mi">2</span> <span class="o">*</span> <span class="n">x</span>
<span class="nf">compose</span> <span class="n">f</span> <span class="n">g</span> <span class="ow">=</span> <span class="nf">\</span><span class="n">x</span> <span class="ow">-></span> <span class="n">f</span> <span class="p">(</span><span class="n">g</span> <span class="n">x</span><span class="p">)</span>
<span class="nf">deuxXPlusUn</span> <span class="ow">=</span> <span class="n">compose</span> <span class="n">plusUn</span> <span class="n">double</span>
</pre></div>
</td></tr></table>
<p>Syntaxiquement, la fonction <code>deuxXPlusUn</code> n'est pas écrite comme une fonction qui prend un paramètre <code>x</code> et renvoie <code>plusUn (double x)</code>, mais on utilise <code>compose</code> pour composer ces deux fonctions. Dans ton cas, c'est la même chose, mais c'est <code><|></code> au lieu de <code>compose</code> (pour que ce soit clair : ce n'est pas la même fonction).</p>Besoin d'explication sur le fonctionnement des parseurs, message #1137972016-06-12T18:02:54+02:00LudoBike/@LudoBikehttps://zestedesavoir.com/forums/sujet/6302/besoin-dexplication-sur-le-fonctionnement-des-parseurs/?page=1#p113797<p>Ok merci, c'est un peu plus clair. <img alt=":)" src="/static/smileys/smile.png"></p>Besoin d'explication sur le fonctionnement des parseurs, message #1137932016-06-12T16:50:22+02:00blo yhg/@blo%20yhghttps://zestedesavoir.com/forums/sujet/6302/besoin-dexplication-sur-le-fonctionnement-des-parseurs/?page=1#p113793<p>Pour donner un exemple similaire, on peut très bien faire une structure de donnée pour stocker des polynômes, les manipuler comme tels, et avec la possibilité de prendre la fonction d'évaluation correspondante.</p>
<p><strong>edit</strong></p>
<p>@Berdes : chaque monade peut se voir avec des « fonctions », oui, on peut regarder du côté des <em>arrows</em> et des catégories de Kleisli.</p>Besoin d'explication sur le fonctionnement des parseurs, message #1137812016-06-12T14:43:51+02:00Berdes/@Berdeshttps://zestedesavoir.com/forums/sujet/6302/besoin-dexplication-sur-le-fonctionnement-des-parseurs/?page=1#p113781<p>J'ai pas mal utilisé Parsec, mais ça fait un petit bout de temps que je n'ai pas touché au Haskell, donc j'espère que je ne suis pas trop à côté de la plaque.</p>
<p>L'idée principale, c'est que <code>Parser</code> est une monade. C'est-à-dire qu'à partir d'un état, <code>Parser</code> te donne une valeur et modifie (ou non) cet état. On peut facilement faire le parallel avec la monade <code>IO</code> : <code>getLine</code> ne prends aucun paramètre et pourtant <code>getLine</code> te retourne une valeur (et modifie l'état de l'entrée standard). La monade <code>IO</code> est un peu différente, parce que c'est le runtime Haskell qui l'exécute alors que dans le cas de <code>Parser</code>, c'est la fonction parse qui s'en occupe.</p>
<p>Si tu veux comprendre un peu plus le fonctionnement, il faut regarder un peu plus comment ce genre de monade fonctionne. La monade <code>Parser</code> comme la majorité (toute?) des monades peut se voir comme une fonction. Les opérateurs que tu utilises vont ensuite te permettre de combiner ces fonctions de manière à former un programme (ici, le parser, mais avec <code>IO</code>, c'est un "vrai" programme) qu'il te faudra ensuite exécuter et c'est le rôle de <code>parse</code>.</p>Besoin d'explication sur le fonctionnement des parseurs, message #1137772016-06-12T14:28:12+02:00LudoBike/@LudoBikehttps://zestedesavoir.com/forums/sujet/6302/besoin-dexplication-sur-le-fonctionnement-des-parseurs/?page=1#p113777<p>Salut à tous,</p>
<p>j'ai commencé ce matin le tuto <a href="https://en.wikibooks.org/wiki/Write_Yourself_a_Scheme_in_48_Hours/Parsing">Write Yourself a Scheme in 48 Hours</a>, j'en suis actuellement au chapitre 2 et je ne comprends pas le fonctionnement des parsers. Avant tout voici le code :</p>
<div class="spoiler">
<p><table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="kr">module</span> <span class="nn">Main</span> <span class="kr">where</span>
<span class="kr">import</span> <span class="nn">Text.ParserCombinators.Parsec</span> <span class="k">hiding</span> <span class="p">(</span><span class="nf">spaces</span><span class="p">)</span>
<span class="kr">import</span> <span class="nn">System.Environment</span>
<span class="kr">import</span> <span class="nn">Control.Monad</span>
<span class="kr">data</span> <span class="kt">LispVal</span> <span class="ow">=</span> <span class="kt">Atom</span> <span class="kt">String</span>
<span class="o">|</span> <span class="kt">List</span> <span class="p">[</span><span class="kt">LispVal</span><span class="p">]</span>
<span class="o">|</span> <span class="kt">DottedList</span> <span class="p">[</span><span class="kt">LispVal</span><span class="p">]</span> <span class="kt">LispVal</span>
<span class="o">|</span> <span class="kt">Number</span> <span class="kt">Integer</span>
<span class="o">|</span> <span class="kt">String</span> <span class="kt">String</span>
<span class="o">|</span> <span class="kt">Bool</span> <span class="kt">Bool</span>
<span class="nf">main</span> <span class="ow">::</span> <span class="kt">IO</span> <span class="nb">()</span>
<span class="nf">main</span> <span class="ow">=</span> <span class="kr">do</span>
<span class="p">(</span><span class="n">expr</span><span class="kt">:</span><span class="kr">_</span><span class="p">)</span> <span class="ow"><-</span> <span class="n">getArgs</span>
<span class="n">putStrLn</span> <span class="p">(</span><span class="n">readExpr</span> <span class="n">expr</span><span class="p">)</span>
<span class="nf">readExpr</span> <span class="ow">::</span> <span class="kt">String</span> <span class="ow">-></span> <span class="kt">String</span>
<span class="nf">readExpr</span> <span class="n">input</span> <span class="ow">=</span> <span class="kr">case</span> <span class="n">parse</span> <span class="n">parseExpr</span> <span class="s">"lisp"</span> <span class="n">input</span> <span class="kr">of</span>
<span class="kt">Left</span> <span class="n">err</span> <span class="ow">-></span> <span class="s">"No match: "</span> <span class="o">++</span> <span class="n">show</span> <span class="n">err</span>
<span class="kt">Right</span> <span class="n">val</span> <span class="ow">-></span> <span class="s">"Found value"</span>
<span class="nf">parseExpr</span> <span class="ow">::</span> <span class="kt">Parser</span> <span class="kt">LispVal</span>
<span class="nf">parseExpr</span> <span class="ow">=</span> <span class="n">parseAtom</span> <span class="o"><|></span> <span class="n">parseString</span> <span class="o"><|></span> <span class="n">parseNumber</span>
<span class="nf">parseString</span> <span class="ow">::</span> <span class="kt">Parser</span> <span class="kt">LispVal</span>
<span class="nf">parseString</span> <span class="ow">=</span> <span class="kr">do</span>
<span class="n">char</span> <span class="sc">'"'</span>
<span class="n">x</span> <span class="ow"><-</span> <span class="n">many</span> <span class="p">(</span><span class="n">noneOf</span> <span class="s">"</span><span class="se">\"</span><span class="s">"</span><span class="p">)</span>
<span class="n">char</span> <span class="sc">'"'</span>
<span class="n">return</span> <span class="o">$</span> <span class="kt">String</span> <span class="n">x</span>
<span class="nf">parseAtom</span> <span class="ow">::</span> <span class="kt">Parser</span> <span class="kt">LispVal</span>
<span class="nf">parseAtom</span> <span class="ow">=</span> <span class="kr">do</span>
<span class="n">first</span> <span class="ow"><-</span> <span class="n">letter</span> <span class="o"><|></span> <span class="n">symbol</span>
<span class="n">rest</span> <span class="ow"><-</span> <span class="n">many</span> <span class="p">(</span><span class="n">letter</span> <span class="o"><|></span> <span class="n">digit</span> <span class="o"><|></span> <span class="n">symbol</span><span class="p">)</span>
<span class="kr">let</span> <span class="n">atom</span> <span class="ow">=</span> <span class="n">first</span><span class="kt">:</span><span class="n">rest</span>
<span class="n">return</span> <span class="o">$</span> <span class="kr">case</span> <span class="n">atom</span> <span class="kr">of</span>
<span class="s">"#t"</span> <span class="ow">-></span> <span class="kt">Bool</span> <span class="kt">True</span>
<span class="s">"#f"</span> <span class="ow">-></span> <span class="kt">Bool</span> <span class="kt">False</span>
<span class="kr">_</span> <span class="ow">-></span> <span class="kt">Atom</span> <span class="n">atom</span>
<span class="nf">parseNumber</span> <span class="ow">::</span> <span class="kt">Parser</span> <span class="kt">LispVal</span>
<span class="nf">parseNumber</span> <span class="ow">=</span> <span class="n">liftM</span> <span class="p">(</span><span class="kt">Number</span> <span class="o">.</span> <span class="n">read</span><span class="p">)</span> <span class="o">$</span> <span class="n">many1</span> <span class="n">digit</span>
</pre></div>
</td></tr></table>
</p>
</div>
<p>En fait je ne comprends pas comment la fonction <code>parse</code> fait pour parser avec <code>parseExpr</code> alors que <code>parseExpr</code> ne prend pas d'arguments et du coup tout me parait flou et je bloque.</p>
<p>Merci d'avance de votre aide. <img alt=":)" src="/static/smileys/smile.png"></p>