Loading AI tools
langage de programmation fonctionnel De Wikipédia, l'encyclopédie libre
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.15.15 () | |
| 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 | |
modifier  |
||
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 sémantique (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]
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 enregistrements 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.
Voici un programme "Hello world!" minimal en PureScript:
module Main where
import Effect.Console (log)
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:
module Main where
import Prelude
import Effect (Effect)
import Effect.Console (log)
main :: Effect Unit
main = log "Hello World!"
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 types différents car, bien que le nombre et le type des valeurs sont les mêmes, les étiquettes ne le sont pas.
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.
En réalité, la notation { étiquette1 :: Type1, étiquette2 :: Type2 } n'est qu'un sucre syntaxique d'une construction plus générale qui facilite l'extension des types d'enregistrements, Record en PureScript (l'extension des unions disjointes étiquetées[11] est similaire). Cette construction est réalisée à partir de déclarations, de juxtapositions et d'applications de prototypes (Row):
-- Prototypes (syntaxe commune aux enregistrements et aux variants):
type NonConcrétisableA r = ( aire :: Number | r )
type NonConcrétisableBC r = ( boîte :: Boolean, côté :: Number | r )
type NonConcrétisableABC r = NonConcrétisableA (NonConcrétisableBC r)
Il n'est pas directement possible de créer des valeurs correspondant à ces prototypes (Row Type et Type ne sont pas dans la même catégorie). Pour ce faire, on utilise le constructeur Record:
-- Type concret et ouvert (= paramétré):
type Enregistrement r = Record (NonConcrétisableABC r)
Des valeurs peuvent alors peupler ce type:
-- Type concret et fermé (= non-paramétré):
carré :: Enregistrement ()
carré =
{ côté: 2.0
, aire: 4.0
, boîte: false
}
ou une de ses extensions:
-- Type concret, étendu et fermé:
cube :: Enregistrement (volume :: Number)
cube =
{ côté: 2.0
, aire: 24.0
, volume: 8.0
, boîte: true
}
La similitude assumée entre le système de types d'Haskell et celui de PureScript comporte néanmoins certaines nuances, tant au niveau de la syntaxe (par exemple, le "genre" (en) * d'Haskell se nomme Type en PureScript), qu'aux niveaux des contraintes liées à sa manipulation (aucune extension n'est nécessaire pour accéder à la programmation au niveau "types" en PureScript) et des applications (la programmation au niveau "types" est nécessaire dans certains cas.)
En guise d'illustration sont présentés comparativement ci-après deux programmes PureScript complets qui, tous deux,
mais, tandis que l'un est écrit dans un style de programmtion au niveau "valeurs" (connues au moment de l'exécution du programme), l'autre est écrit dans le style de programmation de niveau "types" (déterminés dès l'étape de compilation du programme) qui s'apparente à la programmation logique.
De plus, tandis que le premier programme manipule des entiers (signés) en simple précision (Int), le second
utilise des entiers en multiprécision (Int également, le contexte permettant la distinction), car l'usage de ce genre d'entiers nécessite la programmation de niveau "types" en PureScript si on se limite aux bibliothèques pré-installées.
| Code au niveau valeurs | Description au niveau valeurs | Code au niveau types | Description au niveau types | |
|---|---|---|---|---|
module Main where
|
module Main where
| |||
import Prelude
( Unit
, (==)
, (&&)
, ($)
, show
)
import Effect
( Effect
)
import Effect.Console
( log
)
| l.5: comparaison d'entiers incluse | import Prelude
( Unit
, ($)
)
import Data.Symbol
( reflectSymbol
, class IsSymbol
)
import Effect
( Effect
)
import Effect.Console
( log
)
import Prim.Boolean
( True
, False
)
import Prim.Int
( class Compare
)
import Prim.Ordering
( Ordering
, EQ
)
import Type.Prelude
( Proxy (..)
)
|
l.22 : comparaison d'entiers incluse Les éléments de | |
data SimpleCouple
:: Type
data SimpleCouple
= S Int Int
| l.20: S, le constructeur de type est employé directement pour décrire comment créer une nouvelle valeur possédant le type SimpleCouple
|
data MultiCouple
:: Type
data MultiCouple
foreign import data M
:: Int
-> Int
-> MultiCouple
|
l.36: l.37 et 38: | |
class EgalitéV
:: Type
-> Constraint
class EgalitéV v
where
égalitéV
:: v
-> v
-> Boolean
|
l.22: la logique de ce programme tient entre les lignes 36 et 40; la classe, ici, est facultative et ne serait utile que si d'autres types possédaient la propriété l.30: |
class EgalitéT
:: MultiCouple
-> MultiCouple
-> Boolean
-> Constraint
class EgalitéT m1 m2 b
| m1 m2
-> b
class Subordonnée
:: Ordering
-> Ordering
-> Boolean
-> Constraint
class Subordonnée
compart
comparu
résultat
| compart comparu
-> résultat
|
l.41 à 48: première étape essentielle de la mise en place de la logique du programme, cette partie fait état des entrées ( l.44 et 53: | |
instance
EgalitéV
SimpleCouple
where
égalitéV
(S v1 w1)
(S v2 w2)
= v1 == v2
&& w1 == w2
|
instance
Subordonnée
EQ
EQ
True
else
instance
Subordonnée
c1
c2
False
instance
( Compare
t1
t2
compart
, Compare
u1
u2
comparu
, Subordonnée
compart
comparu
résultat
) =>
EgalitéT
(M t1 u1)
(M t2 u2)
résultat
|
l.74 à 91: cette seconde étape constitue le cœur du problème et est résolu durant la phase de compilation | ||
rendu
:: Boolean
-> String
rendu = show
|
|
class Symbolise
:: Boolean
-> Symbol
-> Constraint
class Symbolise b s
| b -> s
instance
Symbolise
True
"True"
instance
Symbolise
False
"False"
rendu
:: forall s
. IsSymbol s
=> Proxy s
-> String
rendu = reflectSymbol
|
l.97 à 106: fonctionnalité auxiliaire permettant ultérieurement d'utiliser la fonction | |
aprèsExécution
:: Boolean
aprèsExécution
= égalitéV
(S 3 4)
(S 5 6)
|
l.51 et 52: 3, 4, 5 et 6 sont considérés en simple précision |
aprèsCompilation
:: forall b s
. EgalitéT
(M 3 4)
(M 5 6)
b
=> Symbolise b s
=> Proxy s
aprèsCompilation
= Proxy
|
l.118 et 119: 3, 4, 5 et 6 sont considérés en multiprécision l.122: derrière le type l.124: c'est l'identifiant | |
main
:: Effect Unit
main
= log
$ rendu
aprèsExécution
|
main
:: Effect Unit
main
= log
$ rendu
aprèsCompilation
|
Seamless Wikipedia browsing. On steroids.
Every time you click a link to Wikipedia, Wiktionary or Wikiquote in your browser's search results, it will show the modern Wikiwand interface.
Wikiwand extension is a five stars, simple, with minimum permission required to keep your browsing private, safe and transparent.
