<li><ahref="https://sillybytes.net">Daniel Campoverde</a> pour la version Espagnole : <ahref="https://sillybytes.net/2016/06/aprende-haskell-rapido-y-dificil_29.html">Aprende Haskell rápido y difícil</a> ;</li>
<li><ahref="http://github.com/joom">Joomy Korkut</a> pour sa traduction en Turc: <ahref="https://github.com/joom/zor-yoldan-haskell">Zor Yoldan Haskell</a></li>
<li><ahref="https://github.com/lepereceval">lepereceval</a> pour sa traduction française que je n’ai pas eu le courage de faire !</li>
<li><ahref="https://github.com/youqad">Younesse Kaddar</a> et <ahref="https://github.com/mmenestret">Menestret Martin</a> pour les corrections de styles et d’orthographes.</li>
<li><ahref="#more-on-infinite-tree">Revenons sur les arbres infinis</a></li>
</ul></li>
</ul>
</div>
</blockquote>
</div>
<divclass="intro">
<p>Je pense vraiment que tous les développeurs devraient apprendre Haskell. Peut-être pas devenir des ninjas d’Haskell, mais au moins savoir ce que ce langage a de particulier. Son apprentissage ouvre énormément l’esprit.</p>
<p>La plupart des langages partagent les mêmes fondements :</p>
<li>les structures de données, les objets et les classes</li>
</ul>
<p>Haskell est très différent. Ce langage utilise des concepts dont je n’avais jamais entendu parler avant. Beaucoup de ces concepts pourront vous aider à devenir un meilleur développeur.</p>
<p>Plier son esprit à Haskell peut être difficile. Ce le fut pour moi. Dans cet article, j’essaye de fournir les informations qui m’ont manquées lors de mon apprentissage.</p>
<p>Cet article sera certainement difficile à suivre. Mais c’est voulu. Il n’y a pas de raccourci pour apprendre Haskell. C’est difficile. Mais je pense que c’est une bonne chose. C’est entre autres parce qu’Haskell est difficile qu’il est intéressant.</p>
<p>La manière conventionnelle d’apprendre Haskell est de lire deux livres. D’abord <ahref="http://haskell.fr/lyah/">“Learn You a Haskell”</a> et ensuite <ahref="http://www.realworldhaskell.org">“Real World Haskell”</a>. Je pense aussi que c’est la bonne manière de s’y prendre. Mais apprendre même un tout petit peu d’Haskell est presque impossible sans se plonger réellement dans ces livres.</p>
<p>Cet article fait un résumé très dense et rapide des aspects majeurs d’Haskell. J’y ai aussi rajouté des informations qui m’ont manqué pendant l’apprentissage de ce langage.</p>
<p>Pour les francophones : je suis désolé. Je n’ai pas eu le courage de tout retraduire en français. Sachez cependant que si vous êtes plusieurs à insister, je ferai certainement l’effort de traduire l’article en entier. Et si vous vous sentez d’avoir une bonne âme je ne suis pas contre un peu d’aide. Les sources de cet article sont sur <ahref="http://github.com/yogsototh/learn_haskell.git">github</a>.</p>
<p>Cet article contient cinq parties :</p>
<ul>
<li>Introduction : un exemple rapide pour montrer qu’Haskell peut être facile.</li>
<li>Les bases d’Haskell : La syntaxe et des notions essentielles</li>
<li>Partie difficile :
<ul>
<li>Style fonctionnel : un exemple progressif, du style impératif au style fonctionnel ;</li>
<li>Types : la syntaxe et un exemple d’arbre binaire ;</li>
<li>Structure infinie : manipulons un arbre infini !</li>
</ul></li>
<li>Partie de difficulté infernale :
<ul>
<li>Utiliser les IO : un exemple très minimal ;</li>
<li>Le truc des IO révélé : les détails cachés d’IO qui m’ont manqués</li>
<li>Les monades : incroyable à quel point on peut généraliser</li>
</ul></li>
<li>Appendice :
<ul>
<li>Revenons sur les arbres infinis : une discussion plus mathématique sur la manipulation d’arbres infinis.</li>
</ul></li>
</ul>
<blockquote>
Note: Chaque fois que vous voyez un séparateur avec un nom de fichier se terminant par <code>lhs</code>, vous pouvez cliquer sur le nom de fichier et télécharger le fichier. Si vous sauvegardez le fichier sour le nom <code>filename.lhs</code>, vous pouvez l’exécuter avec :
<pre>
runhaskell filename.lhs
</pre>
<p>Certains ne marcheront pas, mais la majorité vous donneront un résultat. Vous devriez voir un lien juste en dessous.</p>
<p>Aujourd’huil je considère que la manière la plus aisée d’installer Haskell est d’utiliser <ahref="https://haskellstack.org"><code>stack</code></a>.</p>
<p>Il y a d’autres manières d’installer Haskell sur votre système, vous pouvez en savoir plus en visitant <ahref="https://haskell.org">haskell.org</a> ou <ahref="https://haskell-lang.org">haskell-lang.org</a></p>
<p>Outils:</p>
<ul>
<li><code>ghc</code>: Compilateur similaire à gcc pour le langage <code>C</code>.</li>
<p>Beaucoup de livres/articles sur Haskell commencent par présenter des formules ésotériques (Algorithmes de tri rapide, suite de Fibonacci, etc…). Je ferai l’exact opposé En premier lieu je ne vous montrerai pas les super-pouvoirs d’Haskell. Je vais commencer par les similarités avec les autres langages de programmation. Commençons par l’indispensable “Hello World!”.</p>
<p>Vous pouvez également télécharger la source Haskell littérale. Vous devriez voir un lien juste au dessus du titre de l’introduction. Téléchargez ce fichier en tant que <code>00_hello_world.lhs</code> et:</p>
<aclass="sourceLine"id="cb5-2"title="2"><spanclass="fu">print</span><spanclass="st">"What is your name?"</span></a>
<aclass="sourceLine"id="cb5-3"title="3"> name <spanclass="ot"><-</span><spanclass="fu">getLine</span></a>
<aclass="sourceLine"id="cb5-4"title="4"><spanclass="fu">print</span> (<spanclass="st">"Hello "</span><spanclass="op">++</span> name <spanclass="op">++</span><spanclass="st">"!"</span>)</a></code></pre></div>
</div>
<p>Premièrement, comparons ce code avec ceux de quelques langages de programmation impératif:</p>
<divclass="sourceCode"id="cb8"><preclass="sourceCode c"><codeclass="sourceCode c"><aclass="sourceLine"id="cb8-1"title="1"><spanclass="co">// In C</span></a>
<aclass="sourceLine"id="cb8-3"title="3"><spanclass="dt">int</span> main (<spanclass="dt">int</span> argc, <spanclass="dt">char</span> **argv) {</a>
<aclass="sourceLine"id="cb8-4"title="4"><spanclass="dt">char</span> name[<spanclass="dv">666</span>]; <spanclass="co">// <- An Evil Number!</span></a>
<aclass="sourceLine"id="cb8-5"title="5"><spanclass="co">// What if my name is more than 665 character long?</span></a>
<aclass="sourceLine"id="cb8-6"title="6"> printf(<spanclass="st">"What is your name?</span><spanclass="sc">\n</span><spanclass="st">"</span>);</a>
<p>La structure est la même, mais il y a quelques différences de syntaxe. La partie principale de ce tutoriel sera consacrée à expliquer cela.</p>
<p>En Haskell il y a une fonction <code>main</code> tous les objets ont un type. Le type de <code>main</code> est <code>IO ()</code>. Cela veut dire que <code>main</code> causera des effets secondaires.</p>
<p>Rappelez-vous just que Haskell peut ressembler énormément aux principaux langages impératifs.</p>
<p>Avant de continuer, vous devez êtres avertis à propos de propriétés essentielles de Haskell.</p>
<p><em>Fonctionnel</em></p>
<p>Haskell est un langage fonctionnel Si vous avez déjà travaillé avec un langage impératif, vous devrez apprendre beaucoup de nouvelles choses. Heureusement beaucoup de ces nouveaux concepts vous aidera à programmer même dans un langage impératif.</p>
<p><em>Typage Statique Intelligent</em></p>
<p>Au lieu de bloquer votre chemin comme en <code>C</code>, <code>C++</code> ou <code>Java</code>, le système de typage est ici pour vous aider.</p>
<p><em>Pureté</em></p>
<p>Généralement vos fonctions ne modifieront rien du le monde extérieur. Cela veut dire qu’elles ne peuvent pas modifier la valeur d’une variable, lire du texte entré par un utilisateur, écrire sur l’écran, lancer un missile. D’un autre coté, avoir un code parallèle devient très facile. Haskell rend très clair où les effets apparaissent et où le code est pur. De plus, il devient beaucoup plus aisé de raisonner sur son programme. La majorité des bugs seront évités dans les parties pures de votre programme.</p>
<p>En outre, les fonctions pures suivent une loi fondamentale en Haskell:</p>
<blockquote>
<p>Appliquer une fonction avec les mêmes paramètres retourne toujours la même valeur.</p>
</blockquote>
<p><em>Paresse</em></p>
<p>La paresse par défaut est un choix de conception de langage très rare. Par défaut, Haskell évalue quelque chose seulement lorsque cela est nécessaire. En conséquence, cela fournit un moyen très élégant de manipuler des structures infinies, par exemple.</p>
<p>Un dernier avertissement sur comment vous devriez lire le code Haskell. Pour moi, c’est comme lire des papiers scientifiques. Quelques parties sont très claires, mais quand vous voyez une formule, concentrez-vous dessus et lisez plus lentement. De plus, lorsque vous apprenez Haskell, cela n’importe <em>vraiment</em> pas si vous ne comprenez pas les détails syntaxiques. Si vous voyez un <code>>>=</code>, <code><$></code>, <code><-</code> ou n’importe quel symbole bizarre, ignorez-les et suivez le déroulement du code.</p>
<h4id="function-declaration">
Déclaration de fonctions
</h4>
<p>Vous avez déjà dû déclarer des fonctions comme cela:</p>
<divclass="sourceCode"id="cb13"><preclass="sourceCode scheme"><codeclass="sourceCode scheme"><aclass="sourceLine"id="cb13-1"title="1">(<spanclass="ex">define</span><spanclass="fu"></span>(f x y)</a>
<aclass="sourceLine"id="cb13-2"title="2"> (<spanclass="op">+</span> (* x x) (* y y)))</a></code></pre></div>
<p>Finalement, la manière de faire de Haskell est:</p>
<divclass="sourceCode"id="cb14"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb14-1"title="1">f x y <spanclass="ot">=</span> x<spanclass="op">*</span>x <spanclass="op">+</span> y<spanclass="op">*</span>y</a></code></pre></div>
<p>N’oubliez pas, Haskell utilise beaucoup les fonctions et les types. C’est très facile de les définir. La syntaxe a été particulièrement réfléchie pour ces objets.</p>
<h4id="a-type-example">
Un exemple de type
</h4>
<p>Même si ce n’est pas obligatoire, les informations de type pour les fonctions sont habituellement déclarées explicitement. Ce n’est pas indispensable car le compilateur est suffisamment intelligent pour le déduire à votre place. Cependant, c’est une bonne idée car cela montre bien l’intention du développeur et facilite la compréhension.</p>
<p>Jouons un peu. On déclare le type en utilisant <code>::</code></p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb15"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb15-1"title="1"><spanclass="ot"> f ::</span><spanclass="dt">Int</span><spanclass="ot">-></span><spanclass="dt">Int</span><spanclass="ot">-></span><spanclass="dt">Int</span></a>
<aclass="sourceLine"id="cb15-2"title="2"> f x y <spanclass="ot">=</span> x<spanclass="op">*</span>x <spanclass="op">+</span> y<spanclass="op">*</span>y</a>
<aclass="sourceLine"id="cb15-3"title="3"></a>
<aclass="sourceLine"id="cb15-4"title="4"> main <spanclass="ot">=</span><spanclass="fu">print</span> (f <spanclass="dv">2</span><spanclass="dv">3</span>)</a></code></pre></div>
<aclass="sourceLine"id="cb17-2"title="2">f x y <spanclass="ot">=</span> x<spanclass="op">*</span>x <spanclass="op">+</span> y<spanclass="op">*</span>y</a>
<p>La soulution: ne déclarez pas de type pour <code>f</code> pour le moment et laissez Haskell inférer le type le plus général pour nous:</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb19"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb19-1"title="1">f x y <spanclass="ot">=</span> x<spanclass="op">*</span>x <spanclass="op">+</span> y<spanclass="op">*</span>y</a>
<p>Maintenant, ça marche! Heureursement, nous n’avons pas à déclarer un nouvelle fonction pour chaque type différent. Par exemple, en <code>C</code>, vous auriez dû déclarer un fonction pour <code>int</code>, pour <code>float</code>, pour <code>long</code>, pour <code>double</code>, etc…</p>
<p>Mais quel type devons nous déclarer? Pour découvrir le type que Haskell a trouvé pour nous, lançons ghci:</p>
<pre><spanclass="low">
%</span> ghci<spanclass="low"><code>
GHCi, version 7.0.4: http://www.haskell.org/ghc/ :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Loading package ffi-1.0 ... linking ... done.
Prelude></code></span> let f x y = x*x + y*y
<spanclass="low"><code>Prelude></code></span> :type f
<code>f :: Num a => a -> a -> a</code>
</pre>
<p>Hein? Quel ce type étrange?</p>
<pre><code>Num a => a -> a -> a</code></pre>
<p>Premièrement, concentrons-nous sur la partie de droite: <code>a -> a -> a</code>. Pour le comprendre, regardez cette liste d’exemples progressifs:</p>
<tdstyle="text-align: left;">Le type de la fonction qui prend n’importe quel type <code>a</code> et retourne une variable du même type <code>a</code></td>
</tr>
<trclass="even">
<tdstyle="text-align: left;"><code>a -> a -> a</code></td>
<tdstyle="text-align: left;">Le type de la fonction qui prend deux arguments de n’importe quel type<code>a</code> et retourne une variable de type <code>a</code></td>
</tr>
</tbody>
</table>
<p>Dans le type <code>a -> a -> a</code>, la lettre <code>a</code> est une <em>variable de type</em>. Cela signifie que <code>f</code> est une fonction avec deux arguments et que les deux arguments et le résultat ont le même type. La variable de type <code>a</code> peut prendre de nombreuses valeurs différentes Par exemple <code>Int</code>, <code>Integer</code>, <code>Float</code>…</p>
<p>Donc à la place d’avoir un type forcé comme en <code>C</code> et de devoir déclarer une fonction pour <code>int</code>, <code>long</code>, <code>float</code>, <code>double</code>, etc., nous déclarons une seule fonction comme dans un langage typé de façon dynamique.</p>
<p>C’est parfois appelé le polymorphisme paramétrique. C’est aussi appelé avoir un gâteau et le manger.</p>
<p>Généralement <code>a</code> peut être de n’importe quel type, par exemple un <code>String</code> ou un <code>Int</code>, mais aussi des types plus complexes comme <code>Trees</code>, d’autres fonctions, etc. Mais ici notre type est préfixé par <code>Num a =></code>.</p>
<p><code>Num</code> est une <em>classe de type</em>. Une classe de type peut être comprise comme un ensemble de types <code>Num</code> contient seulement les types qui se comportent comme des nombres. Plus précisement, <code>Num</code> est une classe qui contient des types qui implémentent une liste spécifique de fonctions, en particulier <code>(+)</code> et <code>(*)</code>.</p>
<p>Les classes de types sont une structure de langage très puissante. Nous pouvons faire des trucs incroyablement puissants avec. Nous verrons cela plus tard.</p>
<p>Finalement, <code>Num a => a -> a -> a</code> signifie:</p>
<p>soit <code>a</code> un type qui appartient à la classe <code>Num</code>. C’est une fonction qui prend une variable de type <code>a</code> et retourne une fonction de type <code>(a -> a)</code></p>
<p>Oui, c’est étrange. En fait, en Haskell aucune fonction ne prend réellement deux arguments. Au lieu de cela toutes les fonctions n’ont qu’un argument unique. Mais nous retiendrons que prendre deux arguments est équivalent à n’en prendre qu’un et à retourner une fonction qui prend le second argument en paramètre.</p>
<p>Plus précisement <code>f 3 4</code> est équivalent à <code>(f 3) 4</code>. Remarque: <code>f 3</code> est une fonction:</p>
<pre><code>f :: Num a => a -> a -> a
g :: Num a => a -> a
g = f 3
g y ⇔ 3*3 + y*y</code></pre>
<p>Une autre notation existe pour les fonctions. La notation lambda nous autorise à créer des fonctions sans leur assigner un nom. On les appelle des fonctions anonymes. nous aurions donc pu écrire:</p>
<pre><code>g = \y -> 3*3 + y*y</code></pre>
<p>Le <code>\</code> esst utilisé car il ressemble à un <code>λ</code> et est un caractère ASCII.</p>
<p>Si vous n’êtes pas habitué à la programmation fonctionnelle, votre cerveau devrait commencer à chauffer Il est temps de faire une vraie application.</p>
<p>Mais juste avant cela, nous devrions vérifier que le système de type marche comme nous le supposons:</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb23"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb23-1"title="1"><spanclass="ot">f ::</span><spanclass="dt">Num</span> a <spanclass="ot">=></span> a <spanclass="ot">-></span> a <spanclass="ot">-></span> a</a>
<aclass="sourceLine"id="cb23-2"title="2">f x y <spanclass="ot">=</span> x<spanclass="op">*</span>x <spanclass="op">+</span> y<spanclass="op">*</span>y</a>
<p>Cela fonctionne, car <code>3</code> est une représentation valide autant pour les nombres fractionnaires comme Float que pour les entiers. Comme <code>2.4</code> est un nombre fractionnaire, <code>3</code> est interprété comme une autre nombre fractionnaire</p>
<p>Si nous forçons notre fonction à travailler avec des types différents, le test échouera:</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb24"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb24-1"title="1"><spanclass="ot">f ::</span><spanclass="dt">Num</span> a <spanclass="ot">=></span> a <spanclass="ot">-></span> a <spanclass="ot">-></span> a</a>
<aclass="sourceLine"id="cb24-2"title="2">f x y <spanclass="ot">=</span> x<spanclass="op">*</span>x <spanclass="op">+</span> y<spanclass="op">*</span>y</a>
<aclass="sourceLine"id="cb24-8"title="8"><spanclass="co">-- won't work because type x ≠ type y</span></a>
<aclass="sourceLine"id="cb24-9"title="9">main <spanclass="ot">=</span><spanclass="fu">print</span> (f x y)</a></code></pre></div>
</div>
<p>Le compilateur se plaint. Les deux paramètres doivent avoir le même type.</p>
<p>Si vous pensez que c’est une mauvaise idée et que le compilateur devrait faire la transformation depuis un type à un autre pour vous, vous devriez vraiment regarder cette vidéo géniale (et amusante): <ahref="https://www.destroyallsoftware.com/talks/wat">WAT</a> (<em>NDT: En Anglais</em>)</p>
<p>Je vous suggère de seulement survoler cette partie Pensez-y seulement comme à une référence. Haskell a beaucoup de caractèristiques Il manque beaucoup d’informations ici. Revenz ici si la notation vous semble étrange.</p>
<p>J’utilise le symbole <code>⇔</code> pour signifier que deux expressions sont équivalentes. C’est une notation extérieure, <code>⇔</code> n’existe pas en Haskell. Je vais aussi utiliser le symoble <code>⇒</code> quelle est la valeur que retourne une fonction.</p>
<p><em>Remarque</em>: Dans un vrai code vous n’utiliserez pas des listes de char pour représenter du texte. Vous utiliserez plus souvent <code>Data.Text</code> à la place. Si vous voulez représenter un chapelet de caractères ASCII, vous utiliserez <code>Data.ByteString</code>.</p>
</blockquote>
<h5id="tuples">
Tuples
</h5>
<p>Le type d’un couple est <code>(a,b)</code>. Les éléments d’un tuple peuvent avoir des types différents.</p>
x :: Num a => a ⇔ x peut être de n'importe quel type a
tant qu' a appartient à la classe de type Num
f :: a -> b ⇔ f est une fonction qui prend un a et retourne un b
f :: a -> b -> c ⇔ f est une fonction qui prend un a et retourne un (b→c)
f :: (a -> b) -> c ⇔ f est une fonction qui prend un (a→b) et retourne un c</code></pre>
<p>Rappelez-vous que définir le type d’une fonction avant sa déclaration n’est pas obligatoire. Haskell infère le type le plus général pour vous. Mais c’est considéré comme une bonne pratique.</p>
<p><em>Notation Infixée</em></p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb35"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb35-1"title="1"><spanclass="ot">square ::</span><spanclass="dt">Num</span> a <spanclass="ot">=></span> a <spanclass="ot">-></span> a</a>
<aclass="sourceLine"id="cb35-2"title="2">square x <spanclass="ot">=</span> x<spanclass="op">^</span><spanclass="dv">2</span></a></code></pre></div>
</div>
<p>Remarquez que <code>^</code> utilise une notation infixée. Pour chaque opérateur infixe il y a une notation préfixée associée. Vous devez juste l’écrire entre parenthèses.</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb36"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb36-1"title="1">square' x <spanclass="ot">=</span> (<spanclass="op">^</span>) x <spanclass="dv">2</span></a>
<aclass="sourceLine"id="cb36-2"title="2"></a>
<aclass="sourceLine"id="cb36-3"title="3">square'' x <spanclass="ot">=</span> (<spanclass="op">^</span><spanclass="dv">2</span>) x</a></code></pre></div>
</div>
<p>Nous pouvons enlever le <code>x</code> dans les parties de gauche et de droite! On appelle cela la η-réduction</p>
<divclass="sourceCode"id="cb38"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb38-1"title="1"><spanclass="ot">absolute ::</span> (<spanclass="dt">Ord</span> a, <spanclass="dt">Num</span> a) <spanclass="ot">=></span> a <spanclass="ot">-></span> a</a>
<aclass="sourceLine"id="cb38-2"title="2">absolute x <spanclass="ot">=</span><spanclass="kw">if</span> x <spanclass="op">>=</span><spanclass="dv">0</span><spanclass="kw">then</span> x <spanclass="kw">else</span><spanclass="op">-</span>x</a></code></pre></div>
</div>
<p>Remarque: la notation de Haskell pour le <code>if .. then .. else</code> ressemble plus à l’opérateur <code>¤?¤:¤</code> en C. Le <code>else</code> est obligatoire.</p>
<p>La partie difficile peut maintenant commencer.</p>
<h3id="functional-style">
Le style fonctionnel
</h3>
<div>
<imgsrc="../../../../Scratch/img/blog/Haskell-the-Hard-Way/hr_giger_biomechanicallandscape_500.jpg"alt="Biomechanical Landscape by H.R. Giger"/>
</div>
<p>Dans cette section, je vais vous donner un court exemple de l’impressionante capacité de remaniement de Haskell. Nous allons sélectionner un problème et le résoudre à la manière d’un langage impératif standard. Ensuite, je ferais évoluer le code. Le résultat final sera plus élégant et plus facile à adapter.</p>
<p>résolvons les problèmes suivants:</p>
<blockquote>
<p>Soit une liste d’entiers, retourner la somme des nombres pairs de cette liste.</p>
<p>Pour montrer les différences entre les approches fonctionnelle et impérative, je vais commencer par donner la solution impérative (en JavaScript):</p>
<aclass="sourceLine"id="cb41-2"title="2"><spanclass="kw">var</span> result <spanclass="op">=</span><spanclass="dv">0</span><spanclass="op">;</span></a>
<p>En Haskell, en revanche, nous n’avons pas de variables ou un boucle <code>for</code>. Une des solutions pour parvenir au même résultat sans boucles est d’utiliser la récursion.</p>
<blockquote>
<p><em>Remarque</em>: La récursion est souvent perçue comme lente dans les langages impératifs. Mais ce n’est généralement pas le cas en programmation fonctionnelle. La plupart du temps Haskell gérera les fonctions récursives efficacement.</p>
</blockquote>
<p>Voici la version <code>C</code> de la fonction récursive. Remarquez que je suppose que la liste d’int fini avec la première valeur <code>0</code>.</p>
<aclass="sourceLine"id="cb42-8"title="8"><spanclass="cf">if</span> (*list == <spanclass="dv">0</span>) { <spanclass="co">// if the list is empty</span></a>
<aclass="sourceLine"id="cb42-11"title="11"> x = list[<spanclass="dv">0</span>]; <spanclass="co">// let x be the first element of the list</span></a>
<aclass="sourceLine"id="cb42-12"title="12"> xs = list+<spanclass="dv">1</span>; <spanclass="co">// let xs be the list without x</span></a>
<aclass="sourceLine"id="cb42-13"title="13"><spanclass="cf">if</span> ( <spanclass="dv">0</span> == (x%<spanclass="dv">2</span>) ) { <spanclass="co">// if x is even</span></a>
<p>Gardez ce code à l’esprit. Nous allons le traduire en Haskell. Premièrement,</p>
<divclass="sourceCode"id="cb43"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb43-1"title="1"><spanclass="fu">even</span><spanclass="ot"> ::</span><spanclass="dt">Integral</span> a <spanclass="ot">=></span> a <spanclass="ot">-></span><spanclass="dt">Bool</span></a>
<p><code>even</code> vérifie si un nombre est pair.</p>
<divclass="sourceCode"id="cb44"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb44-1"title="1"><spanclass="fu">even</span><spanclass="ot"> ::</span><spanclass="dt">Integral</span> a <spanclass="ot">=></span> a <spanclass="ot">-></span><spanclass="dt">Bool</span></a>
<p>La première solution en Haskell. La fonction <code>evenSum</code> retourne la somme de tous les nombres pairs d’une liste:</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb47"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb47-1"title="1"><spanclass="co">-- Version 1</span></a>
<aclass="sourceLine"id="cb47-8"title="8"><spanclass="kw">else</span><spanclass="kw">let</span> x <spanclass="ot">=</span><spanclass="fu">head</span> l</a>
<aclass="sourceLine"id="cb47-12"title="12"><spanclass="kw">else</span> accumSum n xs</a></code></pre></div>
</div>
<p>Pour tester une fonction nous pouvons utiliser <code>ghci</code>:</p>
<pre>
% ghci
<spanclass="low">GHCi, version 7.0.3: http://www.haskell.org/ghc/ :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude></span> :load 11_Functions.lhs
<spanclass="low">[1 of 1] Compiling Main ( 11_Functions.lhs, interpreted )
Ok, modules loaded: Main.
*Main></span> evenSum [1..5]
6
</pre>
<p>Voici un exemple d’exécution<ahref="#fn2"class="footnote-ref"id="fnref2"><sup>2</sup></a>:</p>
<pre>
*Main> evenSum [1..5]
accumSum 0 [1,2,3,4,5]
<spanclass="yellow">1 est impair</span>
accumSum 0 [2,3,4,5]
<spanclass="yellow">2 est pair</span>
accumSum (0+2) [3,4,5]
<spanclass="yellow">3 est impair</span>
accumSum (0+2) [4,5]
<spanclass="yellow">4 est pair</span>
accumSum (0+2+4) [5]
<spanclass="yellow">5 est impair</span>
accumSum (0+2+4) []
<spanclass="yellow">l == []</span>
0+2+4
0+6
6
</pre>
<p>En venant d’un langage impératif, tout devrait vous sembler juste. En fait, beaucoup de choses peuvent être améliorées ici. Tout d’abord, nous pouvons généraliser le type.</p>
<divclass="sourceCode"id="cb48"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb48-1"title="1"><spanclass="ot">evenSum ::</span><spanclass="dt">Integral</span> a <spanclass="ot">=></span> [a] <spanclass="ot">-></span> a</a></code></pre></div>
<p>Ensuite, nous pouvons utiliser des sous-fonctions grâce à <code>where</code> et <code>let</code>. Ansi, notre fonction <code>accumSum</code> ne polluera pas le <em>namespace</em> de notre module</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb50"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb50-1"title="1"><spanclass="co">-- Version 2</span></a>
<aclass="sourceLine"id="cb50-2"title="2"><spanclass="ot">evenSum ::</span><spanclass="dt">Integral</span> a <spanclass="ot">=></span> [a] <spanclass="ot">-></span> a</a>
<aclass="sourceLine"id="cb50-3"title="3"></a>
<aclass="sourceLine"id="cb50-4"title="4">evenSum l <spanclass="ot">=</span> accumSum <spanclass="dv">0</span> l</a>
<aclass="sourceLine"id="cb50-5"title="5"><spanclass="kw">where</span> accumSum n l <spanclass="ot">=</span></a>
<aclass="sourceLine"id="cb50-6"title="6"><spanclass="kw">if</span> l <spanclass="op">==</span> []</a>
<aclass="sourceLine"id="cb50-8"title="8"><spanclass="kw">else</span><spanclass="kw">let</span> x <spanclass="ot">=</span><spanclass="fu">head</span> l</a>
<p>Puis on utilise le <em>pattern matching</em></p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb52"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb52-1"title="1"><spanclass="co">-- Version 3</span></a>
<aclass="sourceLine"id="cb52-2"title="2">evenSum l <spanclass="ot">=</span> accumSum <spanclass="dv">0</span> l</a>
<aclass="sourceLine"id="cb53-2"title="2">foo l <spanclass="ot">=</span><spanclass="op"><</span>y<spanclass="op">></span></a></code></pre></div>
<p>Mais le <em>pattern matching</em> peut aller encore plus loin. Il est également capable d’inspecter les données internes d’un valeur complexe. Nous pouvons ainsi remplacer</p>
<divclass="sourceCode"id="cb54"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb54-1"title="1">foo l <spanclass="ot">=</span><spanclass="kw">let</span> x <spanclass="ot">=</span><spanclass="fu">head</span> l</a>
<p>Utilisons cette méthode pour retirer le <code>l</code>:</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb59"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb59-1"title="1"><spanclass="co">-- Version 4</span></a>
<aclass="sourceLine"id="cb59-2"title="2"><spanclass="ot">evenSum ::</span><spanclass="dt">Integral</span> a <spanclass="ot">=></span> [a] <spanclass="ot">-></span> a</a>
<p>Pour rendre les choses plus faciles, nous devrions utiliser des fonctions d’ordre supérieur. Ce sont des fonctions qui prennent des fonctions en paramètres</p>
<p>Voici quelques exemples:</p>
<divclass="sourceCode"id="cb61"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb61-1"title="1"><spanclass="fu">filter</span><spanclass="ot"> ::</span> (a <spanclass="ot">-></span><spanclass="dt">Bool</span>) <spanclass="ot">-></span> [a] <spanclass="ot">-></span> [a]</a>
<aclass="sourceLine"id="cb61-2"title="2"><spanclass="fu">map</span><spanclass="ot"> ::</span> (a <spanclass="ot">-></span> b) <spanclass="ot">-></span> [a] <spanclass="ot">-></span> [b]</a>
<aclass="sourceLine"id="cb61-3"title="3"><spanclass="fu">foldl</span><spanclass="ot"> ::</span> (a <spanclass="ot">-></span> b <spanclass="ot">-></span> a) <spanclass="ot">-></span> a <spanclass="ot">-></span> [b] <spanclass="ot">-></span> a</a></code></pre></div>
<p>Procédons par étapes.</p>
<divclass="sourceCode"id="cb62"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb62-1"title="1"><spanclass="co">-- Version 5</span></a>
<aclass="sourceLine"id="cb62-2"title="2">evenSum l <spanclass="ot">=</span> mysum <spanclass="dv">0</span> (<spanclass="fu">filter</span><spanclass="fu">even</span> l)</a>
<p>La fonction <code>filter</code> prend une fonction du type (<code>a -> Bool</code>) et une liste de type <code>[a]</code>. Elle retourne une liste qui contient seulement les élements pour qui la fonction a retourné <code>True</code>.</p>
<p>La prochaine étape est d’utiliser une autre technique pour accomplir la même chose qu’une boucle. Nous allons utiliser la fonction <code>foldl</code> pour accumuler une valeur au fur et à mesure que l’on parcoure la liste. La fonction <code>foldl</code> capture un modèle de code général:</p>
<pre>
myfunc list = foo <spanclass="blue">initialValue</span><spanclass="green">list</span>
myfunc list = foldl <spanclass="yellow">bar</span><spanclass="blue">initialValue</span><spanclass="green">list</span>
</pre>
<p>Si vous souhaitez vraiment savoir comment la magie se produit, voici la définition de <code>foldl</code>:</p>
<divclass="sourceCode"id="cb64"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb64-1"title="1"><spanclass="fu">foldl</span> f z [] <spanclass="ot">=</span> z</a>
<aclass="sourceLine"id="cb64-2"title="2"><spanclass="fu">foldl</span> f z (x<spanclass="op">:</span>xs) <spanclass="ot">=</span><spanclass="fu">foldl</span> f (f z x) xs</a></code></pre></div>
<divclass="sourceCode"id="cb65"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb65-1"title="1"><spanclass="fu">foldl</span> f z [x1,<spanclass="op">...</span>xn]</a>
<aclass="sourceLine"id="cb65-2"title="2">⇔ f (<spanclass="op">...</span> (f (f z x1) x2) <spanclass="op">...</span>) xn</a></code></pre></div>
<p>Mais comme Haskell est paresseux, il n’évalue pas <code>(f z x)</code> et le met simplement dans la pile. C’est pourquoi on utilise généralement <code>foldl'</code>, une version <em>stricte</em> de <code>foldl</code>, Si vous ne comprenez pas encore ce que <em>paresseux</em> ou <em>strict</em> signifie, ne vous inquiétez pas, suivez le code comme si <code>foldl'</code> et <code>foldl</code> étaient identiques</p>
<p>Maintenant notre version de <code>evenSum</code> devient:</p>
<divclass="sourceCode"id="cb66"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb66-1"title="1"><spanclass="co">-- Version 6</span></a>
<aclass="sourceLine"id="cb66-2"title="2"><spanclass="co">-- foldl' n'est pas accessible par défaut</span></a>
<aclass="sourceLine"id="cb66-3"title="3"><spanclass="co">-- nous devons l'importer depuis le module Data.List</span></a>
<aclass="sourceLine"id="cb66-5"title="5">evenSum l <spanclass="ot">=</span> foldl' mysum <spanclass="dv">0</span> (<spanclass="fu">filter</span><spanclass="fu">even</span> l)</a>
<aclass="sourceLine"id="cb66-6"title="6"><spanclass="kw">where</span> mysum acc value <spanclass="ot">=</span> acc <spanclass="op">+</span> value</a></code></pre></div>
<p>Nous pouvons aussi simplifier cela en utilisant une <em>lambda-notation</em>. Ainsi nous n’avons pas besoin de créer le nom temporaire <code>mySum</code>.</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb67"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb67-1"title="1"><spanclass="co">-- Version 7</span></a>
<aclass="sourceLine"id="cb67-2"title="2"><spanclass="co">-- Generally it is considered a good practice</span></a>
<aclass="sourceLine"id="cb67-3"title="3"><spanclass="co">-- to import only the necessary function(s)</span></a>
<divclass="sourceCode"id="cb70"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb70-1"title="1"><spanclass="co">-- Version 8</span></a>
<p>Une autre fonction d’ordre supérieur utile est <code>(.)</code>. Elle correspond à une composition en mathématiques.</p>
<divclass="sourceCode"id="cb71"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb71-1"title="1">(f <spanclass="op">.</span> g <spanclass="op">.</span> h) x ⇔ f ( g (h x))</a></code></pre></div>
<p>Nous pouvons profiter de cet opérateur pour η-réduire notre fonction:</p>
<divclass="sourceCode"id="cb72"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb72-1"title="1"><spanclass="co">-- Version 9</span></a>
<p>Nous pouvons maintenant renommer certaines parties pour rendre le tout plus clair:</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb73"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb73-1"title="1"><spanclass="co">-- Version 10</span></a>
<p>Il est temps de discuter de la direction qu’a pris notre code depuis que nous avons introduit plus d’idiomes fonctionnels. Que gagnons-nous à utiliser des fonctions d’ordre supérieur?</p>
<p>D’abord, vous pourriez penser que la principale différence est la brièveté. Mais en réalité, il s’agit d’une meilleure façon de penser. Supposons que nous voulons modifier légèrement notre fonction, par exemple, pour qu’elle renvoie la somme de tous les carrés pairs des éléments de la liste.</p>
<p>La fonction <code>map</code> applique simplementune fonction à tous les élements d’une liste.</p>
<p>Nous n’avons rien modifié <em>à l’intérieur</em> de notre définition de fonction. Cela rend le code plus modulaire. En plus de cela, vous pouvez penser à votre fonction plus mathématiquement. Vous pouvez aussi utilier votre fonction avec d’autres, au besoin: vous pouvez utiliser <code>compose</code>, <code>map</code>, <code>fold</code> ou <code>filter</code> sur notre nouvelle fonction.</p>
<p>Modifier la version 1 est laissé comme un exercice pour le lecteur ☺.</p>
<p>Si vous croyez avoir atteint le bout de la généralisation, vous avez tout faux. Par example, il y a un moyen d’utiliser cette fonction non seulement sur les listes mais aussi sur n’importe quel type récursif. Si vous voulez savoir comment, je vous suggère de lire cet article: <ahref="http://eprints.eemcs.utwente.nl/7281/01/db-utwente-40501F46.pdf">Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire by Meijer, Fokkinga and Paterson</a> (<em>NDT: en anglais, mais là vous vous en seriez douté je pense ☺</em>)</p>
<p>Cet exemple montre à quel point la programmation fonctionnelle pure est géniale. Malheureusement, utiliser cet outil n’est pas adapté à tous les besoins. Ou alors un langage qui le premettrait n’a pas encore été trouvé.</p>
<p>Une des grands pouvoirs de Haskell est sa capacité à créer des DSLs (<em>Domain Specific Language</em>, en français : <em>langage spécifique à un domaine</em>) Il est ainsi facile de changer le pardigme de programmation</p>
<p>En fait, Haskell peut très bien vous permettre d’écrire des programmes impératifs. Comprendre cela a été très difficile pour moi lorsque j’apprenais Haskell. Beaucoup d’efforts tendent à expliquer la supériorité de l’approche fonctionnele. Puis lorsque vous commencez à utliser le style impératif en Haskell, Il peut être difficile de comprendre quand et où l’utliser.</p>
<p>Mais avant de parler de ce super-pouvoir de Haskell, nous devons parler d’un autre aspet essentiel: les <em>Types</em>.</p>
<li><code>type Name = AnotherType</code> n’est qu’un alias de type, le compilateur ne fera pas la différence entre les deux.</li>
<li><code>data Name = NameConstructor AnotherType</code> le compilateur fera la différence.</li>
<li><code>data</code> permet de construire de nouvelles structures qui peuvent être récursives.</li>
<li><code>deriving</code> est magique et créé automatiquement des fonctions pour vous.</li>
</ul>
</blockquote>
<p>En Haskell, les types sont forts et statiques.</p>
<p>Pourquoi est-ce important? Cela vous aidera a éviter <em>beaucoup</em> d’erreurs. En Haskell, la majorité des bugs est repérée durant la compilation de votre programme. Et la raison principale de cela est l’inférence de type durant la compilation. L’inférence de type permet de détecter plus facilement lorsque vous utilisez le mauvais paramètre au mauvais endroit, par exemple.</p>
<h4id="type-inference">
Inférence de type
</h4>
<p>Le typage statique est généralement essentiel pour une exécution rapide. Mais la plupart des langages typés statiquement ont du mal à généraliser des concepts. La “grâce salvatrice” de Haskell est qu’il peut <em>inférer</em> des types.</p>
<p>Voici un exemple simple, la fonction <code>square</code> en Haskell:</p>
<divclass="sourceCode"id="cb78"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb78-1"title="1">square x <spanclass="ot">=</span> x <spanclass="op">*</span> x</a></code></pre></div>
<p>Cette fonction peut mettre au carré n’importe quel type <code>Numeral</code>. Vous pouvez l’utilser avec un <code>Int</code>, un <code>Integer</code>, un <code>Float</code>, un <code>Fractional</code> ou même un <code>Complex</code>. Preuve par l’exemple:</p>
<pre><code>% ghci
GHCi, version 7.0.4:
...
Prelude> let square x = x*x
Prelude> square 2
4
Prelude> square 2.1
4.41
Prelude> -- charge le module Data.Complex
Prelude> :m Data.Complex
Prelude Data.Complex> square (2 :+ 1)
3.0 :+ 4.0</code></pre>
<p><code>x :+ y</code> est la notation pour le complexe (<i>x + iy</i>)</p>
<p>Comparons maintenant avec la quantité de code nécessaire pour le faire en C:</p>
<p>Pour chaque type, vous avez besoin d’écrire une nouvelle fonction. Le seul moyen de se débarrasser de ce problème est d’utiliser des astuces de méta-programmation, par exemple en utilisant le pré-processeur. en C++ il y a un meilleur moyen, les <em>templates</em>:</p>
<p>C++ fait un bien meilleur travail que C ici. Mais pour des fonctions plus complexes, la syntaxe sera difficile à suivre. Voyez <ahref="http://bartoszmilewski.com/2009/10/21/what-does-haskell-have-to-do-with-c/">cet article</a> pour quelques exemples. (_NDT: toujours en anglais)</p>
<p>En C++ vous devez déclarer qu’une fonction peut marcher avec différents types. En Haskell, c’est le contraire. La fonction sera aussi générale que possible par défaut.</p>
<p>L’inférence de type donne à Haskell le sentiment de liberté que les langages dynamiquement typés proposent. Mais contrairement aux langages dynamiquement typés, la majorité des erreurs est détectée avant de lancer le programme. Généralement, en Haskell:</p>
<blockquote>
<p>“Si ça compile, ça fait certainement ce que vous attendiez.”</p>
<aclass="sourceLine"id="cb82-5"title="5">showInfos name color <spanclass="ot">=</span><spanclass="st">"Name: "</span><spanclass="op">++</span> name</a>
<aclass="sourceLine"id="cb82-11"title="11">main <spanclass="ot">=</span><spanclass="fu">putStrLn</span><spanclass="op">$</span> showInfos name color</a></code></pre></div>
<p>Mais cela ne vous protège pas tellement. Essayez d’inverser les deux paramètres de <code>showInfos</code> et lancez le programme:</p>
<divclass="sourceCode"id="cb83"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb83-1"title="1"><spanclass="fu">putStrLn</span><spanclass="op">$</span> showInfos color name</a></code></pre></div>
<p>Le code sera compilé et exécuté. En fait vous pouvez remplace Name, Color et String n’importe où. Le compilateur les traitera comme si ils était complétement identiques.</p>
<p>Une autre méthode est de créer vos propres type avec le mot-clé <code>data</code>.</p>
<aclass="sourceLine"id="cb84-10"title="10">main <spanclass="ot">=</span><spanclass="fu">putStrLn</span><spanclass="op">$</span> showInfos name color</a></code></pre></div>
</div>
<p>Maintenant, si vous échangez les paramètres de <code>showInfos</code>, le compilateur se plaint! Au seul prix d’être plus verbeux, vous écartez définitivement cette erreur potentielle.</p>
<p>Remarquez aussi que les constructeurs sont des fonctions :</p>
<p>Généralement on utilise le même nom pour le DatatTypeName et le DataTypeConstructor.</p>
<p>Exemple :</p>
<divclass="sourceCode"id="cb87"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb87-1"title="1"><spanclass="kw">data</span><spanclass="dt">Complex</span> a <spanclass="ot">=</span><spanclass="dt">Num</span> a <spanclass="ot">=></span><spanclass="dt">Complex</span> a a</a></code></pre></div>
<p>Vous pouvez également utiliser cette syntaxe :</p>
<p>Et de nombreux accesseurs sont définis pour vous. En outre, vous pouvez utiliser une autre ordre lorsque vous définissez des valeurs.</p>
<p>Exemple :</p>
<divclass="sourceCode"id="cb89"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb89-1"title="1"><spanclass="kw">data</span><spanclass="dt">Complex</span> a <spanclass="ot">=</span><spanclass="dt">Num</span> a <spanclass="ot">=></span><spanclass="dt">Complex</span> {<spanclass="ot"> real ::</span> a,<spanclass="ot"> img ::</span> a}</a>
<p>Nous avons déjà rencontré un type récursif : les listes. Nous pourrions re-créer les listes, avec une syntaxe plus bavarde:</p>
<divclass="sourceCode"id="cb90"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb90-1"title="1"><spanclass="kw">data</span><spanclass="dt">List</span> a <spanclass="ot">=</span><spanclass="dt">Empty</span><spanclass="op">|</span><spanclass="dt">Cons</span> a (<spanclass="dt">List</span> a)</a></code></pre></div>
<p>Si vous voulez réellement utiliser une syntxe plus simple, utilisez un nom infixe pour les constructeurs.</p>
<aclass="sourceLine"id="cb91-2"title="2"><spanclass="kw">data</span><spanclass="dt">List</span> a <spanclass="ot">=</span><spanclass="dt">Nil</span><spanclass="op">|</span> a <spanclass="op">:::</span> (<spanclass="dt">List</span> a)</a></code></pre></div>
<p>Le nombre après <code>infixr</code> donne la priorité.</p>
<p>Si vous voulez pouvoir écrire (<code>Show</code>), lire (<code>Read</code>), tester l’égalité (<code>Eq</code>) et comparer (<code>Ord</code>) votre nouvelle structure, vous pouvez demander à Haskell de dériver les fonctions appropriées pour vous.</p>
<aclass="sourceLine"id="cb92-2"title="2"><spanclass="kw">data</span><spanclass="dt">List</span> a <spanclass="ot">=</span><spanclass="dt">Nil</span><spanclass="op">|</span> a <spanclass="op">:::</span> (<spanclass="dt">List</span> a)</a>
<p>Quand vous ajoutez <code>deriving (Show)</code> à votre déclaration, Haskell crée une fonction <code>show</code> pour vous. Nous verrons bientôt comment utiliser sa propre fonction <code>show</code>.</p>
<aclass="sourceLine"id="cb96-3"title="3"><spanclass="kw">data</span><spanclass="dt">BinTree</span> a <spanclass="ot">=</span><spanclass="dt">Empty</span></a>
<aclass="sourceLine"id="cb96-4"title="4"><spanclass="op">|</span><spanclass="dt">Node</span> a (<spanclass="dt">BinTree</span> a) (<spanclass="dt">BinTree</span> a)</a>
<p>Juste pour le plaisir, codons un meilleur affichage pour nos arbres. Je me suis simplement amusé à faire une belle fonction pour afficher les arbres de façon générale. Vous pouvez passer cette partie si vous la trouvez difficile à suivre.</p>
<p>Nous avons quelques changements à faire. Enlevons le <code>deriving (Show)</code> de la déclaration de notre type <code>BinTree</code>. Il serait aussi utile de faire de BinTree une instance de (<code>Eq</code> et <code>Ord</code>), nous serons ainsi capable de tester l’égalité et de comparer des arbres.</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb100"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb100-1"title="1"><spanclass="kw">data</span><spanclass="dt">BinTree</span> a <spanclass="ot">=</span><spanclass="dt">Empty</span></a>
<aclass="sourceLine"id="cb100-2"title="2"><spanclass="op">|</span><spanclass="dt">Node</span> a (<spanclass="dt">BinTree</span> a) (<spanclass="dt">BinTree</span> a)</a>
<p>Sans le <code>deriving (Show)</code>, Haskell ne crée pas de méthode <code>show</code> pour nous. Nous allons créer notre propre version. Pour accomplir cela, nous devons déclarer que notre type <code>BinTree a</code> est une instance de la classe de type <code>Show</code>. La syntaxe générale est :</p>
<divclass="sourceCode"id="cb101"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb101-1"title="1"><spanclass="kw">instance</span><spanclass="dt">Show</span> (<spanclass="dt">BinTree</span> a) <spanclass="kw">where</span></a>
<aclass="sourceLine"id="cb101-2"title="2"><spanclass="fu">show</span> t <spanclass="ot">=</span><spanclass="op">...</span><spanclass="co">-- Déclarez votre fonction ici</span></a></code></pre></div>
<p>Voici ma version pour afficher un arbre binaire. Ne vous inquiétez pas de sa complexité apparente. J’ai fait beaucoup d’améliorations pour afficher même les objets les plus étranges.</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb102"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb102-1"title="1"><spanclass="co">-- declare BinTree a to be an instance of Show</span></a>
<aclass="sourceLine"id="cb102-2"title="2"><spanclass="kw">instance</span> (<spanclass="dt">Show</span> a) <spanclass="ot">=></span><spanclass="dt">Show</span> (<spanclass="dt">BinTree</span> a) <spanclass="kw">where</span></a>
<aclass="sourceLine"id="cb102-3"title="3"><spanclass="co">-- will start by a '<' before the root</span></a>
<aclass="sourceLine"id="cb102-4"title="4"><spanclass="co">-- and put a : a begining of line</span></a>
<aclass="sourceLine"id="cb102-5"title="5"><spanclass="fu">show</span> t <spanclass="ot">=</span><spanclass="st">"<"</span><spanclass="op">++</span> replace <spanclass="ch">'\n'</span><spanclass="st">"\n: "</span> (treeshow <spanclass="st">""</span> t)</a>
<aclass="sourceLine"id="cb102-15"title="15"><spanclass="co">-- Right branch is empty</span></a>
<aclass="sourceLine"id="cb102-16"title="16"> treeshow pref (<spanclass="dt">Node</span> x left <spanclass="dt">Empty</span>) <spanclass="ot">=</span></a>
<p>Maintenant c’est beaucoup mieux ! La racine est montrée en commençant la ligne avec le caractère <code><</code>. Et chaque ligne suivante est commence par <code>:</code>. Mais nous pourrions aussi utiliser un autre type.</p>
<p>Commme nous pouvons tester l’égalité et ordonner des arbres, nous pouvons aussi faire des arbres d’arbres!</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb108"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb108-1"title="1"><spanclass="fu">putStrLn</span><spanclass="st">"\nBinary tree of Char binary trees:"</span></a>
<divclass="sourceCode"id="cb110"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb110-1"title="1"><spanclass="fu">putStrLn</span><spanclass="st">"\nTree of Binary trees of Char binary trees:"</span></a>
<p>Remarquez que les arbres en double ne sont pas insérés. Il n’y a qu’un seul arbre correspondant à <code>"I","HEARD"</code>. Nous avons ceci presque gratuitement, car nous avons déclaré Tree comme instance de <code>Eq</code>.</p>
<p>Voyez à quel point cette structure est formidable : Nous pouvons faire des arbres contenant seulement des entiers, des chaînes de caractères, mais aussi d’autres arbres. Et nous pouvons même faire un arbre contenant un arbre d’arbres!</p>
<p>On dit souvent que Haskell est <em>paresseux</em>.</p>
<p>En fait, si vous êtes un petit peu pédant, vous devriez dire que <ahref="http://www.haskell.org/haskellwiki/Lazy_vs._non-strict">Haskell est <em>non-strict</em></a> (<em>NDT: En anglais, pour changer</em>). La paresse est juste une implémentation commune aux langages non-stricts.</p>
<p>Alors que signifie “non-strict”? D’après le wiki de Haskell :</p>
<blockquote>
<p>La réduction (terme mathématique pour “évaluation”) procède depuis l’extérieur.</p>
<p>Donc si vous avez <code>(a+(b*c))</code>, alors vous réduisez <code>+</code> d’abord, puis vous réduisez <code>(b*c)</code></p>
</blockquote>
<p>Par exemple en Haskell vous pouvez faire :</p>
<p>Au lieu d’essayer d’évaluer <code>numbers</code> entièrement, Haskell évalue les éléments seulement lorsque c’est nécessaire.</p>
<p>Remarquez aussi qu’en Haskell, il y a une notation pour les listes infinies</p>
<pre><code>[1..] ⇔ [1,2,3,4...]
[1,3..] ⇔ [1,3,5,7,9,11...]</code></pre>
<p>et que la majorité des fonctions fonctionnera avec ces listes. Il y a aussi une fonction <code>take</code> équivalente à notre <code>take'</code>.</p>
<aclass="sourceLine"id="cb115-3"title="3"><spanclass="kw">data</span><spanclass="dt">BinTree</span> a <spanclass="ot">=</span><spanclass="dt">Empty</span></a>
<aclass="sourceLine"id="cb115-4"title="4"><spanclass="op">|</span><spanclass="dt">Node</span> a (<spanclass="dt">BinTree</span> a) (<spanclass="dt">BinTree</span> a)</a>
<divclass="sourceCode"id="cb116"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb116-1"title="1"><spanclass="co">-- declare BinTree a to be an instance of Show</span></a>
<aclass="sourceLine"id="cb116-2"title="2"><spanclass="kw">instance</span> (<spanclass="dt">Show</span> a) <spanclass="ot">=></span><spanclass="dt">Show</span> (<spanclass="dt">BinTree</span> a) <spanclass="kw">where</span></a>
<aclass="sourceLine"id="cb116-3"title="3"><spanclass="co">-- will start by a '<' before the root</span></a>
<aclass="sourceLine"id="cb116-4"title="4"><spanclass="co">-- and put a : a begining of line</span></a>
<aclass="sourceLine"id="cb116-5"title="5"><spanclass="fu">show</span> t <spanclass="ot">=</span><spanclass="st">"<"</span><spanclass="op">++</span> replace <spanclass="ch">'\n'</span><spanclass="st">"\n: "</span> (treeshow <spanclass="st">""</span> t)</a>
<aclass="sourceLine"id="cb116-11"title="11"> treeshow pref (<spanclass="dt">Node</span> x left <spanclass="dt">Empty</span>) <spanclass="ot">=</span></a>
<p>Un arbre complet où chaque noeud est égal à 0. Maintenant je vais vous prouver que nous pouvons manipuler cet arbre avec la fonction suivante :</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb118"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb118-1"title="1"><spanclass="co">-- take all element of a BinTree</span></a>
<aclass="sourceLine"id="cb118-2"title="2"><spanclass="co">-- up to some depth</span></a>
<aclass="sourceLine"id="cb118-5"title="5">treeTakeDepth n (<spanclass="dt">Node</span> x left right) <spanclass="ot">=</span><spanclass="kw">let</span></a>
<aclass="sourceLine"id="cb121-3"title="3"> dec (<spanclass="dt">Node</span> x l r) <spanclass="ot">=</span><spanclass="dt">Node</span> (x<spanclass="op">-</span><spanclass="dv">1</span>) (dec l) (dec r)</a>
<aclass="sourceLine"id="cb121-4"title="4"> inc (<spanclass="dt">Node</span> x l r) <spanclass="ot">=</span><spanclass="dt">Node</span> (x<spanclass="op">+</span><spanclass="dv">1</span>) (inc l) (inc r)</a></code></pre></div>
</div>
<p>Un autre moyen de créer cet arbre est d’utiliser une fonction d’ordre supérieur. Cette fonction devrait être similaire à <code>map</code> n, mais devrait travailler sur un <code>BinTree</code> au lieu d’une liste. Voici cette fonction :</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb122"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb122-1"title="1"><spanclass="co">-- apply a function to each node of Tree</span></a>
<aclass="sourceLine"id="cb122-2"title="2"><spanclass="ot">treeMap ::</span> (a <spanclass="ot">-></span> b) <spanclass="ot">-></span><spanclass="dt">BinTree</span> a <spanclass="ot">-></span><spanclass="dt">BinTree</span> b</a>
<aclass="sourceLine"id="cb122-3"title="3">treeMap f <spanclass="dt">Empty</span><spanclass="ot">=</span><spanclass="dt">Empty</span></a>
<aclass="sourceLine"id="cb122-4"title="4">treeMap f (<spanclass="dt">Node</span> x left right) <spanclass="ot">=</span><spanclass="dt">Node</span> (f x)</a>
<aclass="sourceLine"id="cb122-5"title="5"> (treeMap f left)</a>
<aclass="sourceLine"id="cb122-6"title="6"> (treeMap f right)</a></code></pre></div>
</div>
<p><em>NB</em>: Je ne parlerai pas plus de cette fonction ici. Si vous vous intéressez à la généralisation de <code>map</code> à d’autres structures de données, cherchez des informations sur les foncteurs et <code>fmap</code>.</p>
<p>Félicitations pour être allé si loin! Maitenant, les choses vraiment extrêmes peuvent commencer.</p>
<p>Si vous êtes comme moi, vous êtes déjà familier avec le style fonctionnel. Vous devriez également comprendre les avantages de la paresse par défaut. Mais vous ne comprenez peut-être pas vraiment par où commencer pour faire un vrai programme. Et en particulier :</p>
<ul>
<li>Comment s’occuper des effets ?</li>
<li>Pourquoi y a t-il une étrange notation impérative lorsque l’on s’occupe de l’Entrée/Sortie? (E/S, <em>IO</em> pour <em>Input/Output</em> en anglais)</li>
</ul>
<p>Accrochez-vous, les réponses risquent d’être compliquées. Mais elles en valent la peine.</p>
<p>Une fonction typique qui fait de l’<code>IO</code> ressemble à un programme impératif:</p>
<pre><code>f :: IO a
f = do
x <- action1
action2 x
y <- action3
action4 x y</code></pre>
<ul>
<li>Pour définir la valeur d’un objet on utilise <code><-</code> .</li>
<li>Le type de chaque ligne est <code>IO *</code>; dans cet exemple:
<ul>
<li><code>action1 :: IO b</code></li>
<li><code>action2 x :: IO ()</code></li>
<li><code>action3 :: IO c</code></li>
<li><code>action4 x y :: IO a</code></li>
<li><code>x :: b</code>, <code>y :: c</code></li>
</ul></li>
<li>Quelques objets ont le type <code>IO a</code>, cela devrait vous aider à choisir. En particulier vous ne pouvez pas utiliser de fonctions pures directement ici. Pour utiliser des fonctions pures vous pourriez faire <code>action2 (pureFunction x)</code> par exemple.</li>
</ul>
</blockquote>
<p>Dans cette section, je vais expliquer comment utiliser l’IO, pas comment ça marche. Vous verrez comment Haskell sépare les parties pures et impures du programme.</p>
<p>Ne vous arrêtez pas sur les détails de la syntaxe Les réponses viendront dans la section suivante.</p>
<p>Que cherchons-nous à faire?</p>
<blockquote>
<p>Demander une liste de nombres à l’utilisateur. Afficher la somme de ces nombres.</p>
<aclass="sourceLine"id="cb128-5"title="5"><spanclass="fu">putStrLn</span><spanclass="st">"Enter a list of numbers (separated by comma):"</span></a>
<p>Nous devrions aussi prêter attention à l’effet du symbole <code><-</code>.</p>
<pre><code>do
x <- something</code></pre>
<p>Si <code>something :: IO a</code> alors <code>x :: a</code>.</p>
<p>Une autre remarque importante sur l’<code>IO</code>: Toutes les lignes d’un bloc <code>do</code> doivent être d’une des deux formes suivantes :</p>
<pre><code>action1 :: IO a
-- in this case, generally a = ()</code></pre>
<p>ou</p>
<pre><code>value <- action2 -- where
-- action2 :: IO b
-- value :: b</code></pre>
<p>Ces deux types de ligne correspondent à deux types différents de séquençage d’action. La signification de cette phrase devrait être plus claire à la fin de la prochaine section.</p>
<p>Argh! Un message d’erreur effrayant et un crash ! Notre première amélioration sera de répondre avec un message plus amical.</p>
<p>Pour faire cela, nous devons détecter que quelque chose s’est mal passé. Voici un moyen de le faire : utiliser le type <code>Maybe</code>. C’est un type très utilisé en Haskell.</p>
<p>Mais qu’est-ce que c’est ? <code>Maybe</code> est un type qui prend un paramètre. Sa définition est :</p>
<divclass="sourceCode"id="cb135"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb135-1"title="1"><spanclass="kw">data</span><spanclass="dt">Maybe</span> a <spanclass="ot">=</span><spanclass="dt">Nothing</span><spanclass="op">|</span><spanclass="dt">Just</span> a</a></code></pre></div>
<p>C’est un bon moyen de dire qu’il y a eu une erreur en essayant de créer/évaluer une valeur. La fonction <code>maybeRead</code> en est un bon exemple. C’est une fonction similaire à <code>read</code><ahref="#fn3"class="footnote-ref"id="fnref3"><sup>3</sup></a>, mais s’il y a un problème, la valeur retournée est <code>Nothing</code>. Si la valeur est bonne, la valeur retournée est <code>Just <la valeur></code>. Ne vous efforcez pas trop de comprendre cette fonction. J’utilise une fonction de plus bas niveau que <code>read</code> : <code>reads</code>.</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb136"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb136-1"title="1"><spanclass="ot">maybeRead ::</span><spanclass="dt">Read</span> a <spanclass="ot">=></span><spanclass="dt">String</span><spanclass="ot">-></span><spanclass="dt">Maybe</span> a</a>
<aclass="sourceLine"id="cb136-2"title="2">maybeRead s <spanclass="ot">=</span><spanclass="kw">case</span><spanclass="fu">reads</span> s <spanclass="kw">of</span></a>
<p>Maintenant, pour être plus lisible, on définit une fonction comme ceci : Si la chaîne a un mauvais format, elle retournera <code>Nothing</code>. Sinon, par exemple pour “1,2,3”, cela retournera <code>Just [1,2,3]</code>.</p>
<aclass="sourceLine"id="cb138-3"title="3"><spanclass="fu">putStrLn</span><spanclass="st">"Enter a list of numbers (separated by comma):"</span></a>
<aclass="sourceLine"id="cb138-7"title="7"><spanclass="dt">Just</span> l <spanclass="ot">-></span><spanclass="fu">print</span> (<spanclass="fu">sum</span> l)</a>
<aclass="sourceLine"id="cb138-8"title="8"><spanclass="dt">Nothing</span><spanclass="ot">-></span><spanclass="fu">error</span><spanclass="st">"Bad format. Good Bye."</span></a></code></pre></div>
</div>
<p>En cas d’erreur, on affiche un joli message.</p>
<p>Notez que le type de chaque expression dans le bloc <code>do</code> de <code>main</code> reste de la forme <code>IO a</code>. La seule construction étrange est <code>error</code>. Disons juste que <code>error msg</code> prend le type nécessaire (ici, <code>IO ()</code>).</p>
<p>Une chose très importante à noter est le type de toutes les fonctions définies jusqu’ici. Il n’y a qu’une seule fonction qui contient <code>IO</code> dans son type : <code>main</code>. Cela signifie que <code>main</code> est impure. Mais <code>main</code> utilise <code>getListFromString</code>, qui, elle, est pure. Nous pouvons donc facilement repérer quelles fonctions sont pures et lesquelles sont impures, seulement en regardant leur type.</p>
<p>Pourquoi la pureté a-t-elle de l’importance? Parmi ses nombreux avantages, en voici trois :</p>
<ul>
<li>Il est beaucoup plus facile de penser à du code pur qu’à du code impur.</li>
<li>La pureté vous protège de tous les bugs difficiles à reproduire dûs aux <ahref="https://fr.wikipedia.org/wiki/Effet_de_bord_(informatique)">effets de bord</a>.</li>
<li>Vous pouvez évaluer des fonctions pures dans n’importe quel ordre ou en parallèle, sans prendre de risques.</li>
</ul>
<p>C’est pourquoi vous devriez mettre le plus de code possible dans des fonctions pures.</p>
<aclass="sourceLine"id="cb139-3"title="3"><spanclass="ot">maybeRead ::</span><spanclass="dt">Read</span> a <spanclass="ot">=></span><spanclass="dt">String</span><spanclass="ot">-></span><spanclass="dt">Maybe</span> a</a>
<aclass="sourceLine"id="cb139-4"title="4">maybeRead s <spanclass="ot">=</span><spanclass="kw">case</span><spanclass="fu">reads</span> s <spanclass="kw">of</span></a>
<aclass="sourceLine"id="cb140-3"title="3"><spanclass="fu">putStrLn</span><spanclass="st">"Enter a list of numbers (separated by comma):"</span></a>
<p>Cette fonction est de type <code>IO [Integer]</code>. Cela signifie que la valeur récupérée est de type <code>[Integer</code>] et est le résultat d’actions d’E/S. D’aucuns diront avec enthousiasme :</p>
<blockquote>
<p>«C’est un <code>[Integer]</code> dans un <code>IO</code> !»</p>
</blockquote>
<p>Si vous voulez comprendre les détails derrière tout cela, vous devrez lire la prochaine section. Mais si vous voulez seulement <em>utiliser</em> l’E/S, contentez-vous pratiquer un peu et rappelez-vous de penser aux types.</p>
<p>Finalement, notre fonction <code>main</code>est bien plus simple :</p>
<p>Nous avons fini notre introduction à l’<code>IO</code>. C’était plutôt rapide. Voici les principales choses à retenir :</p>
<ul>
<li>Dans le bloc <code>do</code>, chaque expression doit avoir le type <code>IO a</code>. Vous êtes donc limité quant au panel d’expression disponibles. Par exemple, <code>getLine</code>, <code>print</code>, <code>putStrLn</code>, etc…</li>
<li>Essayez d’externaliser le plus possible les fonctions pures.</li>
<li>le type <code>IO a</code> signifie : une <em>action</em> d’E/S qui retourne un élément de type a. L’<code>IO</code> représente des actions; sous le capot, <code>IO a</code> est le type d’une fonction. Lisez la prochaine section si vous êtes curieux.</li>
</ul>
<p>Si vous pratiquez un peu, vous devriez être capable d’<em>utiliser</em> l’<code>IO</code>.</p>
<blockquote>
<p>-Exercices_:</p>
<ul>
<li>Écrivez un programme qui additionne tous ses arguments. Utilisez la fonction <code>getArgs</code>.</li>
<p>Voici un <spanclass="sc"><abbrtitle="Trop long; pas lu">tlpl</abbr>: </span> pour cette section.</p>
<p>Pour séparer les parties pures et impures, <code>main</code> est définie comme une fonction. qui modifie l’état du monde.</p>
<pre><code>main :: World -> World</code></pre>
<p>Une fonction aura des effets de bord si elle a ce type. Mais regardez cette fonction <code>main</code> typique:</p>
<pre><code>
main w0 =
let (v1,w1) = action1 w0 in
let (v2,w2) = action2 v1 w1 in
let (v3,w3) = action3 v2 w2 in
action4 v3 w3</code></pre>
<p>Nous avons beaucoup d’élements temporaires (ici, <code>w1</code>, <code>w2</code> et <code>w3</code>) qui doivent être passés à l’action suivante.</p>
<p>Nous créons une fonction <code>bind</code> ou <code>(>>=)</code>. Avec <code>bind</code> nous n’avons plus besoin de noms temporaires.</p>
<aclass="sourceLine"id="cb146-3"title="3"><spanclass="fu">putStrLn</span><spanclass="st">"Enter a list of numbers (separated by commas):"</span></a>
<p>Première remarque : on dirait de l’impératif. Haskell est assez puissant pour faire sembler impératif du code impur. Par exemple, si vous le vouliez vous pourriez créer une boucle <code>while</code> en Haskell. En fait, pour utiliser les <code>IO</code>, le style impératif est en général plus approprié.</p>
<p>Mais vous devriez avoir remarqué que la notation est inhabituelle. Voici pourquoi, en détail.</p>
<p>Dans un langage impur, l’état du monde peut être vu comme une énorme variable globale cachée. Cette variable cachée est accessible par toutes les fonctions du langage. Par exemple, vous pouvez lire et écrire dans un fichier avec n’importe quelle fonction. Le fait que le fichier putatif existe ou non est une éventualité qui relève des états possibles que le monde courant peut prendre.</p>
<p>En Haskell l’état courant du monde n’est pas caché. Au contraire, il est dit <em>explicitement</em> que <code>main</code> est une fonction qui change <em>potentiellement</em> l’état du monde. Son type est donc quelque chose comme :</p>
<p>Les fonctions ne sont pas toutes susceptibles de modifier cette variable. Celle qui peuvent la modifier sont impures. Les fonctions qui ne peuvent pas agir sur la variable sont pures<ahref="#fn4"class="footnote-ref"id="fnref4"><sup>4</sup></a>.</p>
<p>Haskell considère l’état du monde comme une variable à passer à <code>main</code>. Mais son type réel est plus proche de celui ci<ahref="#fn5"class="footnote-ref"id="fnref5"><sup>5</sup></a> :</p>
<p>où <code>a</code> est le type du résultat. Par exemple, une fonction <code>getChar</code> aura le type `World -> (Char, World).</p>
<p>Une autre chose à noter est l’astuce pour corriger l’ordre d’évaluation. En Haskell, pour évaluer <code>f a b</code>, vous avez l’embarras du choix :</p>
<ul>
<li>évaluer d’abord <code>a</code> puis <code>b</code> puis <code>f a b</code></li>
<li>évaluer d’abord <code>b</code> puis <code>a</code> puis <code>f a b</code></li>
<li>évaluer <code>a</code> et <code>b</code> parallèlement, puis <code>f a b</code></li>
</ul>
<p>Cela vient du fait que nous avons recours à une partie pure du langage.</p>
<p>Maintenant, si vous regardez la fonction <code>main</code>, vous voyez tout de suite qu’il faut évaluer la première ligne avant la seconde, car pour évaluer la seconde ligne vous devez utliser un paramètre donné suite à l’évaluation de la première ligne.</p>
<p>Cette astuce fonctionne très bien. Le compilateur donnera à chaque étape un pointeur sur l’id du nouveau monde courant. En réalité, <code>print</code> sera évaluée comme suit :</p>
<ul>
<li>Écrit quelque chose sur l’écran</li>
<li>Modifie l’id du monde</li>
<li>renvoyer <code>((), id du nouveau monde)</code>.</li>
</ul>
<p>Maintenant, si jetez un oeil au style de la fonction <code>main</code>, vous remarquerez qu’il est clairement peu commode. Essayons de faire la même chose avec la fonction <code>askUser</code> :</p>
<aclass="sourceLine"id="cb153-2"title="2"><spanclass="kw">let</span> (_,w1) <spanclass="ot">=</span><spanclass="fu">putStrLn</span><spanclass="st">"Enter a list of numbers:"</span><spanclass="kw">in</span></a>
<p>C’est similaire, mais peu commode. Voyez-vous toutes ces variables temporaires <code>w?</code>.</p>
<p>Voici la leçon : une implémentation naïve des IO dans les langages fonctionnels purs serait maladroite !</p>
<p>Heureusement, il y a un meilleur moyen de résoudre ce problème. Nous voyons un motif. Chaque ligne est de la forme :</p>
<divclass="sourceCode"id="cb154"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb154-1"title="1"><spanclass="kw">let</span> (y,w') <spanclass="ot">=</span> action x w <spanclass="kw">in</span></a></code></pre></div>
<p>Même si pour certaines lignes l’argument <code>x</code> n’est pas nécessaire. La sortie est un couple, <code>(answer, newWorldValue)</code>. Chaque fonction <code>f</code> doit avoir un type similaire à :</p>
<p>Maintenant, préparez-vous pour un petit tour de magie ! Faisons disparaître les variables temporaires de monde courant. Nous allons <code>attacher</code> (<em>NDT: <code>bind</code> en anglais</em>) les deux lignes. Définissons la fonction <code>bind</code>. Son type est assez intimidant au début :</p>
<aclass="sourceLine"id="cb160-2"title="2"><spanclass="ot">-></span> (a <spanclass="ot">-></span> (<spanclass="dt">World</span><spanclass="ot">-></span> (b,<spanclass="dt">World</span>)))</a>
<aclass="sourceLine"id="cb162-2"title="2"><spanclass="fu">print</span><spanclass="ot"> ::</span><spanclass="dt">Show</span> a <spanclass="ot">=></span> a <spanclass="ot">-></span><spanclass="dt">IO</span> ()</a></code></pre></div>
<p><code>getLine</code> est une action d’E/S qui prend le monde en paramètre et retourne un couple <code>(String, World)</code>. Cela peut être résumé par : <code>getLine</code> est de type <code>IO String</code>, que nous pouvons voir comme une action d’E/S qui retournera une chaîne de caractères “dans une E/S”.</p>
<p>La fonction <code>print</code> est elle aussi intéressante. Elle prend un argument qui peut être montré avec <code>show</code>. En fait, elle prend deux arguments. Le premier est la valeur et le deuxième est l’état du monde. Elle retourne un couple de type <code>((), World)</code>. Cela signifie qu’elle change l’état du monde, mais ne produit pas d’autre donnée.</p>
<p>Ce nouveau type <code>IO a</code> nous aide à simplifier le type de <code>bind</code> :</p>
<p>Comme <code>print</code> est de type <code>Show a => a -> (World -> ((), World))</code>, nous savons que <code>res = ()</code> (type <code>unit</code>) Si vous ne voyez pas ce qui est magique ici, essayons avec trois lignes cette fois.</p>
<p>Nous pouvons utiliser une meilleure notation. Utilisons <code>(>>=)</code> au lieu de <code>bind</code>. <code>(>>=)</code> est une fonction infixe, comme <code>(+)</code>; pour mémoire : <code>3 + 4 ⇔ (+) 3 4</code></p>
<p>Remarquez que vous pouvez utliser <code>x</code> dans <code>action2</code> et <code>x</code> et <code>y</code> dans <code>action3</code>.</p>
<p>Mais que se passe-t-il pour les lignes qui n’utilisent pas le <code><-</code> ? Facile, une autre fonction <code>blindBind</code> :</p>
<divclass="sourceCode"id="cb174"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb174-1"title="1"><spanclass="ot">blindBind ::</span><spanclass="dt">IO</span> a <spanclass="ot">-></span><spanclass="dt">IO</span> b <spanclass="ot">-></span><spanclass="dt">IO</span> b</a>
<p>Je n’ai pas simplifié cette définition pour plus de clarté. Bien sûr, nous pouvons utiliser une meilleure notation avec l’opérateur <code>(>>)</code>.</p>
<p>Enfin, une autre fonction est plutôt utile.</p>
<divclass="sourceCode"id="cb177"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb177-1"title="1"><spanclass="ot">putInIO ::</span> a <spanclass="ot">-></span><spanclass="dt">IO</span> a</a>
<aclass="sourceLine"id="cb177-2"title="2">putInIO x <spanclass="ot">=</span><spanclass="dt">IO</span> (\w <spanclass="ot">-></span> (x,w))</a></code></pre></div>
<p>D’une manière générale, c’est une façon de mettre des valeurs pures dans le “contexte d’E/S”. Le nom général pour <code>putInIO</code> est <code>return</code>. C’est un plutôt un mauvais nom lorsque vous commencez à programmer en Haskell. <code>return</code> est très différent de ce à quoi vous pourriez être habitué.</p>
<aclass="sourceLine"id="cb178-4"title="4"><spanclass="fu">putStrLn</span><spanclass="st">"Enter a list of numbers (separated by commas):"</span></a>
<aclass="sourceLine"id="cb179-3"title="3"><spanclass="ot">maybeRead ::</span><spanclass="dt">Read</span> a <spanclass="ot">=></span><spanclass="dt">String</span><spanclass="ot">-></span><spanclass="dt">Maybe</span> a</a>
<aclass="sourceLine"id="cb179-4"title="4">maybeRead s <spanclass="ot">=</span><spanclass="kw">case</span><spanclass="fu">reads</span> s <spanclass="kw">of</span></a>
<aclass="sourceLine"id="cb179-11"title="11"><spanclass="fu">putStrLn</span><spanclass="st">"Enter a list of numbers (sep. by commas):"</span><spanclass="op">>></span></a>
<imgsrc="../../../../Scratch/img/blog/Haskell-the-Hard-Way/dali_reve.jpg"alt="Dali, reve. It represents a weapon out of the mouth of a tiger, itself out of the mouth of another tiger, itself out of the mouth of a fish itself out of a grenade. I could have choosen a picture of the Human centipede as it is a very good representation of what a monad really is. But just to think about it, I find this disgusting and that wasn"/>
</div>
<p>Maintenant le secret peut être dévoilé : <code>IO</code> est une <em>monade</em>. Être une monade signifie que vous avez accès à du sucre syntaxique avec la notation <code>do</code>. Mais principalement, vous avez accès à un motif de codage qui tempérera le flux de votre code.</p>
<li>Le monades n’ont pas forcément quoi que ce soit à voir avec les effets de bord ! Il y a beaucoup de monades <em>pures</em>.</li>
<li>Les monades concernent plus le séquençage.</li>
</ul>
</blockquote>
<p>En Haskell, <code>Monad</code> est une classe de type. Pour être une instance d’une classe de type, vous devez fournir les fonctions <code>(>>=)</code> et <code>return</code>. La fonction <code>(>>)</code> est dérivée de <code>(>>=)</code>. Voici commment la classe de type <code>Monad</code> est déclarée (grosso modo) :</p>
<divclass="sourceCode"id="cb180"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb180-1"title="1"><spanclass="kw">class</span><spanclass="dt">Monad</span> m <spanclass="kw">where</span></a>
<aclass="sourceLine"id="cb180-2"title="2"><spanclass="ot"> (>>=) ::</span> m a <spanclass="ot">-></span> (a <spanclass="ot">-></span> m b) <spanclass="ot">-></span> m b</a>
<aclass="sourceLine"id="cb180-3"title="3"><spanclass="ot"> return ::</span> a <spanclass="ot">-></span> m a</a>
<aclass="sourceLine"id="cb180-4"title="4"></a>
<aclass="sourceLine"id="cb180-5"title="5"><spanclass="ot"> (>>) ::</span> m a <spanclass="ot">-></span> m b <spanclass="ot">-></span> m b</a>
<aclass="sourceLine"id="cb180-6"title="6"> f <spanclass="op">>></span> g <spanclass="ot">=</span> f <spanclass="op">>>=</span> \_ <spanclass="ot">-></span> g</a>
<aclass="sourceLine"id="cb180-7"title="7"></a>
<aclass="sourceLine"id="cb180-8"title="8"><spanclass="co">-- Vous pouvez ignorer cette fonction généralement,</span></a>
<aclass="sourceLine"id="cb180-9"title="9"><spanclass="co">-- je crois qu'elle existe pour des raisons historiques</span></a>
<aclass="sourceLine"id="cb180-10"title="10"><spanclass="ot"> fail ::</span><spanclass="dt">String</span><spanclass="ot">-></span> m a</a>
<li>le mot-clé <code>class</code> n’est pas votre ami. Une classe en Haskell <em>n’est pas</em> du même genre que celle des langages orientés-objet. Elles ont beaucoup de similarités avec les interfaces de Java. Un meilleur mot aurait été <code>typeClass</code>, ce qui signifierait un ensemble de types. Pour qu’un type appartienne à une classe, toutes les fonctions de cette classe doivent être fournies pour ce type.</li>
<li>Dans cet exemple particulier de classe de type, le type <code>m</code> doit être un type qui prend un argument. par exemple <code>IO a</code>, mais aussi <code>Maybe a</code>, <code>[a]</code>, etc…</li>
<li>Pour être une monade utile, votre fonction doit obéir à quelques règles. Si votre construction n’obéit pas à ces règles, des choses étranges pourraient se produire :</li>
</ul>
</blockquote>
<blockquote>
<pre><code>return a >>= k == k a
m >>= return == m
m >>= (\x -> k x >>= h) == (m >>= k) >>= h</code></pre>
</blockquote>
<h4id="maybe-monad">
Maybe est une monade
</h4>
<p>Il y a beaucoup de types différents qui sont des instances de <code>Monad</code>. L’un des plus faciles à décrire est <code>Maybe</code>. Si vous avez une séquence de valeurs <code>Maybe</code>, vous pouvez utiliser les monades pour les manipuler. C’est particulièrement utile pour enlever des constructions <code>if..then..else..</code> trop nombreuses.</p>
<p>Imaginez une opération bancaire complexe. Vous êtes éligible pour gagner 700€ seulement si vous pouvez effectuer une liste d’opérations sans tomber en dessous de zéro.</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb182"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb182-1"title="1">deposit value account <spanclass="ot">=</span> account <spanclass="op">+</span> value</a>
<aclass="sourceLine"id="cb182-2"title="2">withdraw value account <spanclass="ot">=</span> account <spanclass="op">-</span> value</a>
<aclass="sourceLine"id="cb182-3"title="3"></a>
<aclass="sourceLine"id="cb182-4"title="4"><spanclass="ot">eligible ::</span> (<spanclass="dt">Num</span> a,<spanclass="dt">Ord</span> a) <spanclass="ot">=></span> a <spanclass="ot">-></span><spanclass="dt">Bool</span></a>
<p>Maintenant, améliorons cela en utilisant le fait que <code>Maybe</code> est une Monade.</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb183"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb183-1"title="1"><spanclass="ot">deposit ::</span> (<spanclass="dt">Num</span> a) <spanclass="ot">=></span> a <spanclass="ot">-></span> a <spanclass="ot">-></span><spanclass="dt">Maybe</span> a</a>
<aclass="sourceLine"id="cb183-2"title="2">deposit value account <spanclass="ot">=</span><spanclass="dt">Just</span> (account <spanclass="op">+</span> value)</a>
<aclass="sourceLine"id="cb183-3"title="3"></a>
<aclass="sourceLine"id="cb183-4"title="4"><spanclass="ot">withdraw ::</span> (<spanclass="dt">Num</span> a,<spanclass="dt">Ord</span> a) <spanclass="ot">=></span> a <spanclass="ot">-></span> a <spanclass="ot">-></span><spanclass="dt">Maybe</span> a</a>
<aclass="sourceLine"id="cb183-5"title="5">withdraw value account <spanclass="ot">=</span><spanclass="kw">if</span> (account <spanclass="op"><</span> value) </a>
<aclass="sourceLine"id="cb183-9"title="9"><spanclass="ot">eligible ::</span> (<spanclass="dt">Num</span> a, <spanclass="dt">Ord</span> a) <spanclass="ot">=></span> a <spanclass="ot">-></span><spanclass="dt">Maybe</span><spanclass="dt">Bool</span></a>
<aclass="sourceLine"id="cb183-19"title="19"><spanclass="fu">print</span><spanclass="op">$</span> eligible <spanclass="dv">300</span><spanclass="co">-- Just True</span></a>
<p>Pas mauvais, mais nous pouvons faire encore mieux :</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb184"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb184-1"title="1"><spanclass="ot">deposit ::</span> (<spanclass="dt">Num</span> a) <spanclass="ot">=></span> a <spanclass="ot">-></span> a <spanclass="ot">-></span><spanclass="dt">Maybe</span> a</a>
<aclass="sourceLine"id="cb184-2"title="2">deposit value account <spanclass="ot">=</span><spanclass="dt">Just</span> (account <spanclass="op">+</span> value)</a>
<aclass="sourceLine"id="cb184-3"title="3"></a>
<aclass="sourceLine"id="cb184-4"title="4"><spanclass="ot">withdraw ::</span> (<spanclass="dt">Num</span> a,<spanclass="dt">Ord</span> a) <spanclass="ot">=></span> a <spanclass="ot">-></span> a <spanclass="ot">-></span><spanclass="dt">Maybe</span> a</a>
<aclass="sourceLine"id="cb184-5"title="5">withdraw value account <spanclass="ot">=</span><spanclass="kw">if</span> (account <spanclass="op"><</span> value) </a>
<aclass="sourceLine"id="cb184-9"title="9"><spanclass="ot">eligible ::</span> (<spanclass="dt">Num</span> a, <spanclass="dt">Ord</span> a) <spanclass="ot">=></span> a <spanclass="ot">-></span><spanclass="dt">Maybe</span><spanclass="dt">Bool</span></a>
<aclass="sourceLine"id="cb184-19"title="19"><spanclass="fu">print</span><spanclass="op">$</span> eligible <spanclass="dv">300</span><spanclass="co">-- Just True</span></a>
<p>Nous avons prouvé que les monades sont un bon moyen de rendre notre code plus élégant. Remarquez que cette idée d’organisation de code, en particulier pour <code>Maybe</code>, peut être utilisée dans la plupart des langages impératifs. En fait, c’est le type de construction que nous faisons naturellement.</p>
<blockquote>
<p>Une remarque importante :</p>
<p>Le premier élement de la séquence qui sera évalué comme <code>Nothing</code> stoppera l’évaluation. Cela signifie que vous n’exécutez pas toutes les lignes. Cela découle du caractère paresseux de Haskell.</p>
</blockquote>
<p>Vous pourriez aussi revoir ces exemples avec la définition de <code>(>>=)</code> pour <code>Maybe</code> en tête :</p>
<aclass="sourceLine"id="cb185-2"title="2"><spanclass="ot"> (>>=) ::</span><spanclass="dt">Maybe</span> a <spanclass="ot">-></span> (a <spanclass="ot">-></span><spanclass="dt">Maybe</span> b) <spanclass="ot">-></span><spanclass="dt">Maybe</span> b</a>
<aclass="sourceLine"id="cb185-4"title="4"> (<spanclass="dt">Just</span> x) <spanclass="op">>>=</span> f <spanclass="ot">=</span> f x</a>
<aclass="sourceLine"id="cb185-5"title="5"></a>
<aclass="sourceLine"id="cb185-6"title="6"><spanclass="fu">return</span> x <spanclass="ot">=</span><spanclass="dt">Just</span> x</a></code></pre></div>
<p>La monade <code>Maybe</code> a prouvé par un simple exemple qu’elle est utile. Nous avons vu l’utilité de la monade <code>IO</code>. Mais maintenant, voici un exemple encore plus cool : les listes.</p>
<aclass="sourceLine"id="cb188-2"title="2"> y <spanclass="ot"><-</span> allCases,</a>
<aclass="sourceLine"id="cb188-3"title="3"> z <spanclass="ot"><-</span> allCases,</a>
<aclass="sourceLine"id="cb188-4"title="4"><spanclass="dv">4</span><spanclass="op">*</span>x <spanclass="op">+</span><spanclass="dv">2</span><spanclass="op">*</span>y <spanclass="op"><</span> z ]</a></code></pre></div>
</div>
<p>Je ne listerai pas toutes les monades, car il y en a beaucoup. Utiliser les monades simplifie la manipulations de plusieurs notions dans les langages purs. Les monades sont très utiles, en particulier pour :</p>
<ul>
<li>L’E/S (IO),</li>
<li>les calculs non-déterministes,</li>
<li>générer des nombres pseudo-aléatoires,</li>
<li>garder un état de configuration,</li>
<li>écrire un état,</li>
<li>…</li>
</ul>
<p>Si vous m’avez suivi jusqu’ici, alors vous avez terminé ! Vous connaissez les monades<ahref="#fn6"class="footnote-ref"id="fnref6"><sup>6</sup></a> !</p>
<p>Dans la section sur <ahref="#infinite-structures">les structures infinies</a> nous avons vu quelques constructions simples. Malheureusement, nous avons enlevé deux propriétés de notre arbre:</p>
<oltype="1">
<li>Pas de valeurs identiques</li>
<li>Arbre bien ordonné</li>
</ol>
<p>Dans cette section nous allons tenter de garder la première propriété. Concernant la seconde, nous ne devons pas nous en préoccuper ici mais nous discuterons de comment la garder le plus possible.</p>
<divstyle="display:none">
<p>This code is mostly the same as the one in the <ahref="#trees">tree section</a>.</p>
<aclass="sourceLine"id="cb189-2"title="2"><spanclass="kw">data</span><spanclass="dt">BinTree</span> a <spanclass="ot">=</span><spanclass="dt">Empty</span></a>
<aclass="sourceLine"id="cb189-3"title="3"><spanclass="op">|</span><spanclass="dt">Node</span> a (<spanclass="dt">BinTree</span> a) (<spanclass="dt">BinTree</span> a) </a>
<aclass="sourceLine"id="cb189-6"title="6"><spanclass="co">-- declare BinTree a to be an instance of Show</span></a>
<aclass="sourceLine"id="cb189-7"title="7"><spanclass="kw">instance</span> (<spanclass="dt">Show</span> a) <spanclass="ot">=></span><spanclass="dt">Show</span> (<spanclass="dt">BinTree</span> a) <spanclass="kw">where</span></a>
<aclass="sourceLine"id="cb189-8"title="8"><spanclass="co">-- will start by a '<' before the root</span></a>
<aclass="sourceLine"id="cb189-9"title="9"><spanclass="co">-- and put a : a begining of line</span></a>
<aclass="sourceLine"id="cb189-10"title="10"><spanclass="fu">show</span> t <spanclass="ot">=</span><spanclass="st">"<"</span><spanclass="op">++</span> replace <spanclass="ch">'\n'</span><spanclass="st">"\n: "</span> (treeshow <spanclass="st">""</span> t)</a>
<aclass="sourceLine"id="cb189-16"title="16"> treeshow pref (<spanclass="dt">Node</span> x left <spanclass="dt">Empty</span>) <spanclass="ot">=</span></a>
<aclass="sourceLine"id="cb192-3"title="3">treeTakeDepth n (<spanclass="dt">Node</span> x left right) <spanclass="ot">=</span><spanclass="kw">let</span></a>
<p>tournera en boucle pour toujours. Simplement parce que le code essayera d’accéder à première valeur de <code>filter (<1) [2..]</code>. Mais <code>filter</code> n’est pas assez intelligent pour comprendre que le résultat est une liste vide.</p>
<p>Toutefois, cela reste un exemple sympa de ce qu’un programme non-stricit a à offrir.</p>
<p>Laissé pour exercice au lecteur:</p>
<ul>
<li>Prouver l’existence d’un nombre <code>n</code> tel que <code>treeTakeDepth n (treeFromList shuffle)</code> provoquera une boucle infinie.</li>
<li>Trouver une borne supérieur <code>n</code>.</li>
<li>Prouver qu’il n(y a pas de liste <code>shuffle</code> qui termine le programme pour n’importe quelle profondeur.</li>
<aclass="sourceLine"id="cb196-3"title="3"><spanclass="kw">data</span><spanclass="dt">BinTree</span> a <spanclass="ot">=</span><spanclass="dt">Empty</span></a>
<aclass="sourceLine"id="cb196-4"title="4"><spanclass="op">|</span><spanclass="dt">Node</span> a (<spanclass="dt">BinTree</span> a) (<spanclass="dt">BinTree</span> a) </a>
<divclass="sourceCode"id="cb197"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb197-1"title="1"><spanclass="co">-- declare BinTree a to be an instance of Show</span></a>
<aclass="sourceLine"id="cb197-2"title="2"><spanclass="kw">instance</span> (<spanclass="dt">Show</span> a) <spanclass="ot">=></span><spanclass="dt">Show</span> (<spanclass="dt">BinTree</span> a) <spanclass="kw">where</span></a>
<aclass="sourceLine"id="cb197-3"title="3"><spanclass="co">-- will start by a '<' before the root</span></a>
<aclass="sourceLine"id="cb197-4"title="4"><spanclass="co">-- and put a : a begining of line</span></a>
<aclass="sourceLine"id="cb197-5"title="5"><spanclass="fu">show</span> t <spanclass="ot">=</span><spanclass="st">"<"</span><spanclass="op">++</span> replace <spanclass="ch">'\n'</span><spanclass="st">"\n: "</span> (treeshow <spanclass="st">""</span> t)</a>
<aclass="sourceLine"id="cb197-11"title="11"> treeshow pref (<spanclass="dt">Node</span> x left <spanclass="dt">Empty</span>) <spanclass="ot">=</span></a>
<aclass="sourceLine"id="cb197-41"title="41">treeTakeDepth n (<spanclass="dt">Node</span> x left right) <spanclass="ot">=</span><spanclass="kw">let</span></a>
<aclass="sourceLine"id="cb197-45"title="45"><spanclass="dt">Node</span> x nl nr</a></code></pre></div>
</div>
</div>
<p>Pour résoudre ces problèmes nous allons modifier légèrement nos fonctions <code>treeFromList</code> et <code>shuffle</code>.</p>
<p>Un premier problème est le manque de nombres différents dans notre immlémentation de <code>shuffle</code>. Nous avons généré seulement <code>4331</code> nombres différents. Pour résoudre cela nous allons faire un meilleure fonction <code>shuffle</code>.</p>
<aclass="sourceLine"id="cb198-4"title="4"> p x <spanclass="ot">=</span> m<spanclass="op">*</span>x<spanclass="op">^</span><spanclass="dv">2</span><spanclass="op">+</span> n<spanclass="op">*</span>x <spanclass="op">+</span> o <spanclass="co">-- some polynome</span></a>
<aclass="sourceLine"id="cb198-5"title="5"> m <spanclass="ot">=</span><spanclass="dv">3123</span></a>
<aclass="sourceLine"id="cb198-6"title="6"> n <spanclass="ot">=</span><spanclass="dv">31</span></a>
<aclass="sourceLine"id="cb198-7"title="7"> o <spanclass="ot">=</span><spanclass="dv">7641</span></a>
<aclass="sourceLine"id="cb198-8"title="8"> c <spanclass="ot">=</span><spanclass="dv">1237</span></a></code></pre></div>
</div>
<p>Cette fonction à la propriété de ne pas avoir de bornes supérieure ou inférieure. Mais avoir une meilleure list <code>shuffle</code> n’est pas assez pour entrer dans une boucle infinie.</p>
<p>Généralement, nous ne pouvons pas décider que <code>filter (<x) xs</code> est vide. Donc pour résoudre le problème, je vais autoriser quelques erreurs dans la création de notre arbre binaire. Cette nouvelle version du code peut créer des arbres binaires qui n’ont pas à suivre les propriétés suivantes pour quelque uns de leurs noeuds:</p>
<blockquote>
<p>Tous les élements de la branche de gauche doit être strictement inférieur au la valeur racine.</p>
</blockquote>
<p>Remarquez que cela donnera <em>souvent</em> un arbre ordonné. En outre, avec cette construction, chaque noeud est unique dans l’arbre.</p>
<p>Voici notre nouvelle version de <code>treeFromList</code>. Nous avons simplement remplacé <code>filter</code> par <code>safefilter</code>.</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb199"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb199-1"title="1"><spanclass="ot">treeFromList ::</span> (<spanclass="dt">Ord</span> a, <spanclass="dt">Show</span> a) <spanclass="ot">=></span> [a] <spanclass="ot">-></span><spanclass="dt">BinTree</span> a</a>
<aclass="sourceLine"id="cb199-3"title="3">treeFromList (x<spanclass="op">:</span>xs) <spanclass="ot">=</span><spanclass="dt">Node</span> x left right</a>
<aclass="sourceLine"id="cb199-5"title="5"> left <spanclass="ot">=</span> treeFromList <spanclass="op">$</span> safefilter (<spanclass="op"><</span>x) xs</a>
<aclass="sourceLine"id="cb199-6"title="6"> right <spanclass="ot">=</span> treeFromList <spanclass="op">$</span> safefilter (<spanclass="op">></span>x) xs</a></code></pre></div>
</div>
<p>Cette nouvelle fonction <code>safefilter</code> est presque équivalente à <code>filter</code> mais n’entre pas dans des boucles infinies si le résultat est une liste finie. Si elle ne peut pas trouver un élément pour lequel le test est vrai après 10000 étapes consécutives, alors elle considère que la recherche est finie.</p>
<divclass="codehighlight">
<divclass="sourceCode"id="cb200"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb200-1"title="1"><spanclass="ot">safefilter ::</span> (a <spanclass="ot">-></span><spanclass="dt">Bool</span>) <spanclass="ot">-></span> [a] <spanclass="ot">-></span> [a]</a>
<aclass="sourceLine"id="cb200-2"title="2">safefilter f l <spanclass="ot">=</span> safefilter' f l nbTry</a>
<p>Vous devriez réaliser que le temps nécessaire pour afficher chaque valeur est différent. C’est parce que Haskell calcule chaque valeur lorsqu’il en a besoin. Et dans ce cas, il est demandé de l’afficher à l’écran.</p>
<p>Vous pouvez même essayer de remplacer la profondeur de <code>8</code> par <code>100</code>. Cela marchera sans tuer votre RAM! La gestion de la mémoire est faite naturellement par Haskell.</p>
<p>Laissé comme exercices au lecteur:</p>
<ul>
<li>Même avec une grande valeur constante pour <code>deep</code> et <code>nbTry</code>, cela semble marcher correctement. Mais dans le pire des cas, cela peut devenir exponentiel. Créez la pire liste à donner comme paramètre à <code>treeFromList</code>. <em>indice</em>: pensez à (<code>[0,-1,-1,....,-1,1,-1,...,-1,1,...]</code>).</li>
<li>J’ai commencé à implémenter <code>safefilter</code> comme ceci:
<pre>
safefilter' f l = if filter f (take 10000 l) == []
then []
else filter f l
</pre>
Expliquer pourquoi cela ne fonctionne pas et peut entrer dans une boucle infinie.</li>
<li>Supposez que <code>shuffle</code> est une liste de nombre réellement aléatoires avec de plus en plus de bornes. Si vous étudiez un peu cette structure, vous découvrirez qu’elle a toutes les chances d’être finie. En utilisant le code suivant (supposez que nous pouvons utliser <code>safefilter'</code> directement comme si cela n’était pas dans le <code>where</code> de <code>safefilter</code>. trouvez une définition de <code>f</code> telle que, avec une probabilité de <code>1</code>, <code>treeFromList' shuffle</code> est infinie?. Et prouvez-le. Avertissement, ce n’est qu’une conjecture.</li>
</ul>
<divclass="sourceCode"id="cb202"><preclass="sourceCode haskell"><codeclass="sourceCode haskell"><aclass="sourceLine"id="cb202-1"title="1">treeFromList' [] n <spanclass="ot">=</span><spanclass="dt">Empty</span></a>
<aclass="sourceLine"id="cb202-2"title="2">treeFromList' (x<spanclass="op">:</span>xs) n <spanclass="ot">=</span><spanclass="dt">Node</span> x left right</a>
<p>Merci à <ahref="http://reddit.com/r/haskell"><code>/r/haskell</code></a> et <ahref="http://reddit.com/r/programming"><code>/r/programming</code></a>. Vos commentaires étaient plus que bienvenus.</p>
<p>Particulièrement, je voudrais remercier mille fois <ahref="https://github.com/Emm">Emm</a> pour le temps qu’il a consacré à corriger mon anglais. Merci beaucoup.</p>
<sectionclass="footnotes">
<hr/>
<ol>
<liid="fn1"><p>Même si tous les langages récents essayent de les cacher, ils restent présents.<ahref="#fnref1"class="footnote-back">↩</a></p></li>
<liid="fn2"><p>Je sais que je triche. Mais je parlerais de la non-rigueur plus tard. <!-- IL FAUDRA TROUVER UNE AUTRE TRADUCTION POUR NON-STRICTNESS --><ahref="#fnref2"class="footnote-back">↩</a></p></li>
<liid="fn3"><p>Qui est elle-même très similaire à la fonction <code>eval</code> de javascript, appliquée sur une chaîne contenant du code au format JSON.<ahref="#fnref3"class="footnote-back">↩</a></p></li>
<liid="fn4"><p>Il y a quelques exceptions <em>peu sûres</em> à cette règle. Mais vous ne devriez pas en voir en application réelle, sauf pour le <em>debugging</em>.<ahref="#fnref4"class="footnote-back">↩</a></p></li>
<liid="fn5"><p>Pour les curieux, le vrai type est <code>data IO a = IO {unIO :: State# RealWorld -> (# State# RealWorld, a #)}</code>. Tous les <code>#</code> ont rapport avec l’optimisation et j’ai échangé quelques champs dans mon exemple. Mais c’est l’idée de base.<ahref="#fnref5"class="footnote-back">↩</a></p></li>
<liid="fn6"><p>Vous aurez quand même besoin de pratiquer un peu pour vous habituer à elles et pour comprendre quand les utiliser et créer les vôtres. Mais vous avez déjà fait un grand pas dans cette direction.<ahref="#fnref6"class="footnote-back">↩</a></p></li>