On the expressive power of indexed applicative and monadic structures
Sur le pouvoir expressif des structures applicatives et monadiques indexées
Résumé
It is well-known that very simple theoretic constructs such as Either (type-theoretic equivalent of the logical "or" operator), State (composable state transformers), Applicative (generalized function application), and Monad (generalized sequential program composition) structures (as they are named in Haskell) cover a huge chunk of what is usually needed to elegantly express most computational idioms used in conventional programs. However, it is conventionally argued that there are several classes of commonly used idioms that do not fit well within those structures, the most notable examples being transformations between trees (data types, which are usually argued to require ether generalized pattern matching or heavy metaprogramming infrastructure) and exception handling (which are usually argued to require special language and run-time support). This work aims to show that many of those idioms can, in fact, be expressed by reusing those well-known structures with minor (if any) modifications. In other words, the purpose of this work is to apply the KISS (Keep It Stupid Simple) and/or Occam's razor principles to algebraic structures used to solve common programming problems. Technically speaking, this work aims to show that natural generalizations of Applicative and Monad type classes of Haskell combined with the ability to make Cartesian products of them produce a very simple common framework for expressing many practically useful things, some of the instances of which are very convenient novel ways to express common programming ideas, while others are usually classified as effect systems. On that latter point, if one is to generalize the presented instances into an approach to design of effect systems in general, then the overall structure of such an approach can be thought of as being an almost syntactic framework which allows different effect systems adhering to the general structure of the "marriage" framework to be expressed on top of. (Though, this work does not go into too much into the latter, since this work is mainly motivated by examples that can be immediately applied to Haskell practice.) Note, however, that, after the fact, these technical observation are completely unsurprising: Applicative and Monad are generalizations of functional and linear program compositions respectively, so, naturally, Cartesian products of these two structures ought to cover a lot of what programs usually do.
Il est bien connu que des constructions théoriques très simples telles que les structures Either (équivalent type théorique de l'opérateur logique "ou"), State (représentant des transformateurs d'état composables), Applicative (application des fonctions généralisée) et Monad (composition de programmes séquentielles généralisée), nommés structures en Haskell, couvrent une grande partie de ce qui est habituellement nécessaire pour exprimer avec élégance la plupart des idiomes informatiques utilisés dans les programmes classiques. Cependant, il est usuellement admis qu'il existe plusieurs classes d'idiomes couramment utilisés qui ne s'intègrent pas bien à ces structures, les exemples les plus remarquables étant les transformations entre arbres (types de données, dont l'utilisation doit s'appuyer soit sur les motifs généralisés soit sur une infrastructure de méta programmation lourde) et traitement des exceptions (qui sont d'habitude supposés nécessiter un langage spécial et une prise en charge de l'exécution). Ce travail a pour but de montrer que beaucoup de ces idiomes peuvent, en fait, être exprimés en réutilisant ces structures bien connues avec des modifications mineures (le cas échéant). En d'autres termes, le but de ce travail est d'appliquer les principes du rasoir KISS (Keep It Stupid Simple) et/ou d'Occam aux structures algébriques utilisées pour résoudre des problèmes de programmation courants. Techniquement parlant, ce travail a pour but de montrer que les généralisations naturelles de classes de types Applicative et Monad de Haskell, associées à la possibilité d'en faire des produits cartésiens, en produisent un cadre commun très simple pour exprimer de nombreuses choses pratiques, dont certaines sont des nouvelles méthodes très commodes pour exprimer des idées de programmation communes, tandis que les autres peuvent être vues comme systèmes d'effets. Sur ce dernier point, si l'on veut généraliser des exemples présentés dans une approche de la conception de systèmes d'effets en général, on peut alors considérer la structure globale de cette approche comme un cadre quasi syntaxique qui permet d'ériger une structure générale du cadre "mariage" au dessus de différents systèmes d'effets adhérant aux principes de base. (Bien que ce travail ne soit pas trop approfondi dans la dernière, car il est principalement motivé par des exemples qui peuvent être immédiatement appliqués à la pratique de Haskell.) Il convient toutefois de noter qu'en fait, ces observations techniques n'ont rien d'étonnant: Applicative et Monad sont respectivement des généralisations de composition fonctionnelle et linéaire des programmes; ainsi, naturellement, les produits cartésiens de ces deux structures doivent couvrir en grande partie ce que les programmes font habituellement.
| Origine | Version validée par le jury (STAR) |
|---|
Loading...