Implémentation des types fantômes dans F #

Question

Les programmeurs Ocaml peuvent utiliser des 'types fantômes' pour imposer certaines contraintes à l'aide du système de types. Un bel exemple peut être trouvé au http://ocaml.janestreet.com/?q=node/11.

La syntaxe type readonly ne fonctionne pas en F #. Il pourrait être remplacé par un pseudo-type fantôme défini comme type readonly = ReadOnlyDummyValue afin de mettre en œuvre les astuces dans le billet de blog mentionné ci-dessus.

Existe-t-il un meilleur moyen de définir les types fantômes en F #?

Answer 1

Je pense que le type de définition utilisant simplement type somename ne fonctionnera pas dans F #. Le compilateur F # doit générer un certain type .NET à partir de la déclaration et la spécification F # ne définit pas explicitement ce qui devrait arriver pour les types fantômes.

Vous pouvez créer un type concret (par exemple avec type somename = ReadOnlyDummyValue) dans le fichier d'implémentation (.fs) et masquer les composants internes du type en ajoutant simplement type somename au fichier d'interface (.fsi). De cette façon, vous obtenez assez proche d'un type fantôme - l'utilisateur en dehors du fichier ne verra pas les internes du type.

Une autre alternative intéressante serait d'utiliser des interfaces. Cela me semble logique, car l'interface vide est probablement le type le plus simple que vous pouvez déclarer (et n'introduit pas d'identifiants factices). Interface vide ressemble à ceci:

type CanRead = interface end 
type CanWrote = interface end 

La chose intéressante, dans ce cas, est que vous pouvez également créer des interfaces héritées:

type CanReadWrite = 
    inherit CanRead 
    inherit CanWrite 

Ensuite, vous pouvez écrire une fonction qui peut prendre des valeurs de type Ref<CanRead, int> mais également des valeurs de type Ref<CanReadWrite, int> (parce que ces valeurs prennent également en charge la lecture):

let foo (arg:Ref<#CanRead, int>) = // ...  

Cela semble être quelque chose qui pourrait être u serein. Je serais en fait très intéressé si cela peut aussi être fait dans OCaml (parce qu'il repose sur le support F # pour les interfaces et l'héritage).