Les types infinis (types récursifs) ne sont-ils pas possibles en F #?

Question

Je discutais avec Sadek Drobi sur twitter quand on m'a dit que F # ne semblait pas supporter Infinite Types. Il se trouve que dans C#, vous pouvez faire quelque chose le long de ces lignes:

delegate RecDelegate<T> RecDelegate<T>(T x); 

Cependant, après quelques essais sur nos deux parties, nous avons déterminé que la même chose dans F # semble impossible à la fois implicite et explicite.

explicite:

type 'a specialF = 'a->specialF<'a> 

erreur FS0191: Cette définition de type implique une référence cyclique immédiate par une abréviation, champ struct ou relation d'héritage.

Implicite:

let rec specialF (x: 'a) = specialF 

Type mismatch. Attend un 'b mais étant donné un' a -> 'b. Le type résultant serait infini en unifiant '' b '' et '' a -> 'b'.

Bien sûr, ce sont des échantillons intentionnellement simples. Je me demandais si je me trompais d'une façon ou d'une autre. Peut-être ai-je manqué un type d'annotation nécessaire?

Answer 1

Vous pouvez aussi faire quelque chose comme

type 'a RecType = RecType of ('a -> 'a RecType) 

pour créer un type nommé par lequel effectuer la récursion. Maintenant cela fonctionne:

let rec specialF = RecType (fun _ -> specialF) 

Answer 2

type d<'T> = delegate of 'T -> d<'T> //' 
let del : d<int> = null 
let anotherDel = del.Invoke(1).Invoke(2).Invoke(3) 

Je pense que vous avez besoin d'un type nommé qui est représentable directement dans CLI pour briser la récursion, donc en F # cela signifie que vous avez besoin d'un délégué de type réel ainsi.

Answer 3

Les types d'enregistrements récursifs devraient également fonctionner.

type A = { A : A } 
let rec a : A = { A = a } 

Je serais intéressé par une application pratique. Ou même un peu pratique :)