42 votes

Existe-t-il un langage ou un style de modélisation visuelle pour le paradigme de la programmation fonctionnelle ?

UML est une norme destinée à la modélisation des logiciels qui seront écrits dans des langages OO, et va de pair avec Java. Cependant, pourrait-on l'utiliser pour modéliser des logiciels destinés à être écrits dans le paradigme de la programmation fonctionnelle ? Quels diagrammes seraient rendus utiles par les éléments visuels intégrés ?

Existe-t-il un langage de modélisation destiné à la programmation fonctionnelle, plus précisément à Haskell ? Quels outils de création de diagrammes recommandez-vous ?

Modifié par OP le 02 septembre 2009 :

Ce que je recherche, c'est la représentation la plus visuelle et la plus légère de ce qui se passe dans le code. Des diagrammes faciles à suivre, des modèles visuels qui ne sont pas nécessairement destinés aux autres programmeurs. Je vais développer un jeu en Haskell très bientôt, mais comme ce projet est pour mon travail de conclusion de diplôme, je dois introduire une sorte de formalisation de la solution proposée. Je me demandais s'il existe un équivalent de la norme UML+Java, mais pour Haskell. Devrais-je me contenter de storyboards, de descriptions écrites, de diagrammes non formalisés (quelques images superficielles ressemblant à des organigrammes), de descriptions non formalisées de cas d'utilisation ?

Édité par jcolebrand le 21 juin 2012 :

Notez que le demandeur souhaitait à l'origine une métaphore visuelle, et maintenant que nous avons eu trois ans, nous recherchons des outils plus nombreux et plus performants. Aucune des réponses initiales n'a vraiment abordé le concept d'"outil de conception de métaphores visuelles", donc... c'est ce que le nouveau bounty cherche à fournir.

43voto

John Millikin Points 86775

Je crois que le langage de modélisation pour Haskell s'appelle " mathématiques ". C'est souvent enseigné dans les écoles.

30voto

Conal Points 9874

Oui, il existe des langages/techniques de modélisation/spécification largement utilisés pour Haskell. Ils ne sont pas visuels.

En Haskell, les types donnent un partiel spécification. Parfois, cette spécification détermine entièrement le sens/résultat tout en laissant plusieurs choix de mise en œuvre. Au-delà de Haskell, dans les langages avec des types dépendants, comme Agda et Coq (parmi d'autres), les types sont beaucoup plus souvent utiles en tant qu'outil de gestion de l'information. complet spécification.

Lorsque les types ne suffisent pas, ajoutez des spécifications formelles, qui prennent souvent une forme fonctionnelle simple. (D'où, je crois, les réponses que le langage de modélisation de choix pour Haskell est Haskell lui-même ou "math"). Dans une telle forme, vous donnez une définition fonctionnelle qui est optimisée pour la clarté et la simplicité et pas seulement pour l'efficacité. La définition peut même impliquer des opérations non calculables telles que l'égalité des fonctions sur des domaines infinis. Ensuite, étape par étape, vous transformez la spécification sous la forme d'un programme fonctionnel efficacement calculable. Chaque étape préserve la sémantique (dénotation), et ainsi la forme finale ("implémentation") est garantie d'être sémantiquement équivalente à la forme originale ("spécification"). Vous verrez que ce processus est désigné par différents noms, notamment "transformation de programme", "dérivation de programme" et "calcul de programme".

Les étapes d'une dérivation typique sont principalement des applications du "raisonnement équationnel", complétées par quelques applications de l'induction (et de la co-induction) mathématique. La possibilité d'effectuer un raisonnement aussi simple et utile a été l'une des principales motivations des langages de programmation fonctionnelle à l'origine, et ils doivent leur validité à la nature "dénotative" de la "programmation véritablement fonctionnelle". (Les termes "dénotatif" et "véritablement fonctionnel" sont tirés de l'article fondateur de Peter Landin, intitulé Les 700 prochains langages de programmation .) Ainsi, le cri de ralliement pour la programmation fonctionnelle pure était autrefois "bon pour le raisonnement équationnel", bien que je n'entende pas cette description aussi souvent ces jours-ci. En Haskell, le dénotatif correspond aux types autres que IO et les types qui s'appuient sur IO (par exemple STM ). Tandis que le rapport dénotatif/non- IO sont bons pour un raisonnement équationnel correct, le IO /Les types non dénotatifs sont conçus pour être mauvais pour le raisonnement équationnel incorrect.

Une version spécifique de la dérivation à partir de la spécification que j'utilise aussi souvent que possible dans mon travail en Haskell est ce que j'appelle les "morphismes de classe de type sémantique" (TCM). L'idée est de donner une sémantique/interprétation pour un type de données, puis d'utiliser le principe des TCM pour déterminer (souvent de manière unique) la signification de la plupart ou de toutes les fonctionnalités du type via les instances de classe de type. Par exemple, je dis que la signification d'une classe de type Image est une fonction de l'espace 2D. Le principe de la MTC me dit alors la signification de la Monoid , Functor , Applicative , Monad , Contrafunctor y Comonad comme correspondant à ces instances pour les fonctions. C'est un lot de fonctionnalités utiles sur des images aux spécifications très succinctes et convaincantes ! (La spécification est la fonction sémantique plus une liste de classes de types standard pour lesquelles le principe de MCT sémantique doit tenir). Et pourtant, j'ai une énorme liberté quant à la manière de représenter et le principe de la MCT sémantique élimine les fuites d'abstraction. Si vous êtes curieux de voir quelques exemples de ce principe en action, consultez l'article suivant Conception dénotationnelle avec morphismes de classe de type .

21voto

Don Stewart Points 94361

Nous utilisons des prouveurs de théorèmes pour faire de la modélisation formelle (avec vérification), comme Isabelle ou Coq. Parfois, nous utilisons des langages spécifiques au domaine (par exemple Cryptol) pour réaliser la conception de haut niveau, avant de dériver l'implémentation Haskell de "bas niveau".

Souvent, nous utilisons simplement Haskell comme langage de modélisation, et nous dérivons la mise en œuvre réelle via la réécriture.

Les propriétés QuickCheck jouent également un rôle dans le document de conception, ainsi que les décompositions de type et de module.

13voto

Ori Pessach Points 4957

Oui, Haskell.

J'ai l'impression que les programmeurs qui utilisent des langages fonctionnels ne ressentent pas le besoin de simplifier leur langage de prédilection lorsqu'ils réfléchissent à leur conception, ce qui est une façon (plutôt désinvolte) de voir ce qu'UML fait pour vous.

6voto

fsl Points 335

J'ai regardé quelques interviews vidéo, et lu quelques interviews, avec des personnes comme Erik Meijer et Simon Peyton-Jones. Il semble que lorsqu'il s'agit de modéliser et de comprendre un domaine problématique, ils utilisent les signatures de type, en particulier les signatures de fonction.

Les diagrammes de séquence (UML) pourraient être liés à la composition de fonctions. Un diagramme de classe statique (UML) pourrait être lié aux signatures de type.

Prograide.com

Prograide est une communauté de développeurs qui cherche à élargir la connaissance de la programmation au-delà de l'anglais.
Pour cela nous avons les plus grands doutes résolus en français et vous pouvez aussi poser vos propres questions ou résoudre celles des autres.

Powered by:

X