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 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,

• définissent le couplage générique entre deux entiers,
• définissent l'égalité entre deux couples d'entiers, et
• constatent la non-égalité de deux couples particuliers d'entiers,

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.

module Main where

module Main where

import Prelude 
  ( Unit
  , (==)
  , (&&)
  , ($)
  , show
  )
import Effect 
  ( Effect
  )
import Effect.Console 
  ( log
  )

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 (..)
  )

data SimpleCouple 
  :: Type
data SimpleCouple 
  = S Int Int

data MultiCouple 
  :: Type
data MultiCouple
foreign import data M 
  :: Int 
  -> Int 
  -> MultiCouple

class EgalitéV 
  :: Type 
  -> Constraint
class EgalitéV v 
  where
  égalitéV 
    :: v 
    -> v 
    -> Boolean

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

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

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

aprèsExécution 
  :: Boolean
aprèsExécution 
  = égalitéV 
      (S 3 4) 
      (S 5 6)

aprèsCompilation 
  :: forall b s
  . EgalitéT 
      (M 3 4) 
      (M 5 6) 
      b
  => Symbolise b s
  => Proxy s 
aprèsCompilation 
  = Proxy

main 
  :: Effect Unit
main 
  = log 
  $ rendu 
      aprèsExécution

main 
  :: Effect Unit
main 
  = log 
  $ rendu 
      aprèsCompilation