Cet article, de la série “IA de jeux”, aborde les performances d’exécution en Haskell. En effet, Haskell peut produire du code natif relativement rapide mais cela nécessite de comprendre certaines particularités du langage et du compilateur.

Cet article, de la série “IA de jeux”, présente une implémentation de l’algorithme Monte-Carlo Tree Search, en Haskell, pour le jeu Puissance 4. Cette implémentation est ensuite comparée aux IA de l’article précédent (random et Monte-Carlo).

Cet article, de la série “IA de jeux”, aborde la mise en place d’une intelligence artificielle, en Haskell : bots simples, comparaison, interface utilisateur. Pour cela, on réutilisera le jeu de Puissance 4 présenté dans l’article précédent. Une IA plus évoluée sera présentée dans le prochain article.

Cet article, de la série “IA de jeux”, aborde l’implémentation d’un Puissance 4, en Haskell. Afin de pouvoir comparer avec l’implémentation C++ des articles précédents, il présente également quelques concepts et structures de données efficaces ainsi que les tests unitaires.

Voir également : CPPFrUG 44 - Performance et optimisation - Clément Grégoire

Cet article, de la série “IA de jeux”, aborde la mise en place d’une intelligence artificielle. Il se base sur le jeu de Puissance 4 implémenté dans l’article précédent mais doit pouvoir s’appliquer facilement à d’autres jeux ou implémentations. Enfin, seules quelques IA simples sont présentées ici, ainsi que leur utilisation dans une interface utilisateur ou dans un programme de comparaison. Une IA plus évoluée sera détaillée dans le prochain article.

Cet article, de la série “IA de jeux”, aborde l’implémentation d’un Puissance 4, en C++. Il rappelle d’abord les règles du jeu, les fonctionnalités à implémenter et les difficultés à prévoir. Il propose ensuite une implémentation, relativement simple et efficace. Enfin, il montre comment tester cette implémentation avec des tests unitaires.

Cet article est le premier d’une série consacrée à l’implémentation d’un jeu de Puissance 4 et de quelques Intelligences Artificielles. L’objectif est à la fois d’aborder le domaine des IA de jeux, mais également de voir comment les implémenter relativement efficacement, en C++ et en Haskell.

Cet article résume et illustre les notions vues dans les articles précédents sur un exemple concret, implémenter un DSL pour générer du HTML simplifié. Il présente notamment l’approche monadique utilisée dans la bibliothèque Lucid.

L’approche Tagless Final est une façon classique d’organiser du code. Elle permet notamment d’implémenter des DSL ou de compléter le pattern ReaderT.

Grossièrement, l’approche Tagless Final en Haskell consiste à définir le langage de l’application via des classes de types et à définir des interpréteurs de ce langage via des instances. Cette approche a pour avantage d’être facile à comprendre et à faire évoluer.

Cet article développe l’approche Tagless Final à partir d’un exemple classique (définir et interpréter un langage d’expressions arithmétiques) puis présente un exemple d’application Tagless Final + pattern ReaderT.

Le design pattern ReaderT est une architecture de code classique en Haskell. Elle permet de séparer la couche métier de l’environnement d’exécution, tout en explicitant les fonctionnalités nécessaires.

Au tutoriel 59, on a vu comment utiliser les transformateurs de monade pour “empiler” les fonctionnalités voulues, via le système de types. On va maintenant détailler la monade State et voir comment l’implémenter avec des transformateurs et avec une classe de type “à la MTL”.

En Haskell, une monade permet de définir une suite d’actions dans un contexte particulier (par exemple, des entrées/sorties, des communications HTTP, des calculs pouvant échouer, etc). Les transformateurs de monades permettent d’intégrer un contexte dans un autre, et ainsi de structurer le code via une pile de monades bien définie et vérifiée par le système de types.

Cet article présente le principe des transformateurs de monades en Haskell, ainsi que quelques transformateurs classiques et des exemples d’utilisation. Cependant, il ne traite pas de leur fonctionnement interne ni de leur utilisation pour structurer une vraie base de code.

Cet article introduit les DSL (ou langages dédiés, en français) et en quoi Haskell est intéressant pour les mettre en œuvre.

Précédemment, on a vu comment Haskell implémente des structures évoluées comme Functor, Applicative et Monad. On va maintenant voir comment utiliser ses structures pour réaliser du parsing, c’est-à-dire analyser un texte respectant un schéma attendu.

Les foncteurs, les applicatives et les monades sont des structures permettant d’ajouter des fonctionnalités particulières à des types (par exemple, appliquer une fonction à l’intérieur du type, chainer des opérations…). Ces notions sont très puissantes et très classiques en Haskell mais peuvent paraître difficiles au premier abord car elles sont souvent peu connues dans les autres langages et font appel à des notions assez avancées comme la notion de kind (sorte d’un type).

Cet article introduit la notion de sorte, puis présente et illustre les notions de foncteur, d’applicative et de monade. Enfin, il présente comment implémenter ces fonctionnalités pour un nouveau type.

En Haskell, DeriveGeneric est une fonctionnalité qui analyse la définition d’un type. Ceci permet de générer automatiquement des instances de classe de type. Plus généralement, le principe des Generics en Haskell est assez proche de ce qu’on appelle souvent réflexion dans d’autres langages. Les Generics sont un outil très intéressant mais cet article traite uniquement d’un cas d’utilisation : importer/exporter un type Haskell depuis/vers le format JSON.

En plus des types algébriques (ADT), Haskell supporte les classes de types (Type Classes). Celles-ci permettent notamment de spécifier des contraintes sur des types polymorphes. Les classes de types sont un outil très performant en Haskell, qui est utilisé pour définir des structures de haut-niveau comme les Functor et les Monad.

Les classes de types existent également dans d’autres langage, sous des formes généralement moins évoluées. Par exemple, les traits en Rust et les concepts en C++20.

Cet article présente les classes de types en Haskell, à partir de quelques exemples. Il introduit également un exemple de structure évoluée, les Functor.