PureScript

PureScript est un langage de programmation fonctionnel fortement typé dont la compilation produit du code JavaScript. Il peut être utilisé pour développer des applications web, des applications serveur, et également des applications de bureau grâce au framework Electron. Sa syntaxe est pour l'essentiel comparable à celle d'Haskell. Cependant, le langage introduit un polymorphisme paramétré particulier lié aux enregistrements extensibles[2] : les enregistrements polymorphes (en). De plus, contrairement à Haskell, PureScript adhère à une stratégie d'évaluation stricte.

PureScript
Date de première version 2013
Paradigmes fonctionnel
Auteur Phil Freeman
Dernière version 0.13.4 ()
Typage Fort, statique,Inférence de type
Influencé par Elm, F#, Haskell, Koka, OCaml, Roy, Standard ML
Licence Permissive (Licence_BSD_Modifiée)[1]
Site web www.purescript.org
Extensions de fichiers .purs

Historique

PureScript fut initialement conçu par Phil Freeman en 2013. Celui-ci entama son travail sur PureScript après différentes tentatives insatisfaisantes de compilations d'Haskell vers JavaScript préservant sa semantique (en utilisant par exemple Fay, Haste, ou GHCJS)[3].

Depuis, le projet a été repris par la communauté et est développé sur GitHub[4]. Parmi les outils essentiels additionnels développés par la communauté, on peut citer l'outil dédié de compilation "Pulp"[5], le site documentaire "Pursuit"[6], et le gestionnaire de packages "Spago"[7]

Caractéristiques

PureScript se fonde sur l'évaluation stricte, la structure de données persistante et l'inférence de types. Le système de types de PureScript partage de nombreuses caractéristiques avec celui de langages fonctionnels similaires comme Haskell: les types algébriques de données et le filtrage par motif, les "higher kinded types" (en), les "type classes" (en) et les dépendances fonctionnelles, ainsi que le polymorphisme "higher-rank" (en). Le système de types de PureScript assure également les enregistrements polymorphes (en) et les enregistremens extensibles[8]. Toutefois, PureScript ne possède pas certaines des caractéristiques les plus avancées d'Haskell comme les GADT et les "type families" (en).

Le compilateur de PureScript tend à produire du code JavaScript lisible, autant que possible. Grâce à une simple interface "FFI" (en) il permet l'intégration de code JavaScript existant[8].

PureScript assure la compilation incrémentale, et la distribution inclut un support au développement intéractif à partir de plugins à installer dans l'éditeur de code source[9]. Des plugins existent pour un grand nombre d'éditeurs connus incluant Vim, Emacs, Sublime Text, Atom et Visual Studio Code.

Exemples de codes

Voici un programme "Hello world!" minimal en PureScript:

1 module Main where
2 
3 import Effect.Console (log)
4 
5 main = log "Hello World!"

Ici, le type du programme est inféré et vérifié par le compilateur PureScript. Une version plus verbeuse du même programme pourrait explicitement inclure des annotations de type:

1 module Main where
2 
3 import Prelude
4 
5 import Effect (Effect)
6 import Effect.Console (log)
7 
8 main :: Effect Unit
9 main = log "Hello World!"

Enregistrements en PureScript

Le modèle choisi pour développer les enregistrements en PureScript a permis l'accès à certaines fonctionnalités qui sont encore absentes d'Haskell[10], ce qui fait de lui l'une des caractéristiques majeures du langage.

En tout premier lieu, il faut préciser qu'en PureScript chaque enregistrement possède un type particulier réservé à cet usage, qui est lui-même présenté sous la forme d'un enregistrement composé par un ensemble (non ordonné) de couples `étiquette :: type`.

Ainsi

carré :: {côté :: Number, aire :: Number}
carré = {côté: 3.0, aire: 9.0}

et

disque :: {rayon :: Number, aire :: Number}
disque = {rayon: 1.0, aire: 3.141592653589793}

sont deux enregistrements de type différents car, bien que le nombre et le type des valeurs sont les mêmes, les étiquettes ne le sont pas.

Enregistrements polymorphes

Il est toutefois possible de définir une fonction qui peut s'appliquer à chacun des enregistrements précédents grâce au concept d'enregistrement polymorphe:

aireDe :: forall r. {aire :: Number | r} -> Number
aireDe = _.aire

où le type de l'argument peut se lire comme "le type de tout enregistrement qui possède une étiquette `aire` de type `Number`, et qui possède éventuellement d'autre(s) étiquette(s)". L'argument de cette fonction est donc un enregistrement polymorphe et le compilateur aurait inféré

aireDe :: forall a b. {aire :: a | b} -> a

si l'annotation n'avait pas été précisée.

Voir aussi

  • Elm: Langage de programmation spécifique à un domaine pour la création déclarative d'interfaces utilisateur graphiques basées sur un navigateur Web
  • TypeScript: Un langage de programmation fortement typé qui transpile en JavaScript

Références

  1. « purescript/purescript », sur GitHub
  2. « Hugs documentation », sur www.haskell.org
  3. « Read PureScript by Example | Leanpub », sur leanpub.com (consulté le 14 mars 2019)
  4. « PureScript on Github »
  5. « Pulp », PureScript Contrib (consulté le 14 mars 2019)
  6. « Pursuit », sur pursuit.purescript.org (consulté le 14 mars 2019)
  7. « 🍝 PureScript package manager and build tool powered by Dhall and package-sets: spacchetti/spago », spacchetti, (consulté le 14 mars 2019)
  8. « Documentation for the PureScript language, compiler, and tools.: purescript/documentation », PureScript, (consulté le 14 mars 2019)
  9. « purs ide: Editor and tooling support for the PureScript programming language », (consulté le 21 avril 2019)
  10. « Extensible record », sur wiki.haskell.org

Liens externes

  • Portail de la programmation informatique
Cet article est issu de Wikipedia. Le texte est sous licence Creative Commons - Attribution - Sharealike. Des conditions supplémentaires peuvent s'appliquer aux fichiers multimédias.