Jacques Garrigue a écrit :

> Je ne suis pas sur de tout comprendre, mais si le type de

Désolé, j'envoie du code désormais

> Et quid des types pas encore declares?
> L'idee des variants polymorphes est de se debarasser des declarations
> prealables.
> Mais on peut toujours ecrire des declarations a` posteriori:
> 
>    type 'a anyView = ['a heapView | 'a otherView]
> 

En réalité, comme je ne restreins pas le type de mes fonctions dans le
code source (mais seulement dans le mli), l'interpréteur ne prend pas
en compte mes déclarations (que je ne fais que pour convenance
personnelle afin de pouvoir éventuellement vérifier la conformité des
types inférés avec ce que j'attends) 

Au demeurant, je pensais que l'idée des variantes polymorphes, plus
que débarasser le programmeur des déclarations préalables était de
permettre l'écriture incrémentielle de code (par exemple plusieurs
programmeurs qui piochent dans un flot de données les valeurs qu'ils
peuvent traiter et laissent les autres)

Enfin, la documentation sur les variantes polymorphes est assez
succinte, par exemple elle n'aborde pas le cas où un constructeur est
à la fois marqué d'un < et d'un > (alors que c'est le type de la
première fonction dans mon code, j'ai dû me reporter au livre
"développement d'applications en Objective Caml") 

Je suis vraiment loin d'avoir complètement compris le fonctionnement
des variantes polymorphes : à la vue du premier exemple de la section
"Avanced use"

# let f = function `A -> `C | x -> x ;;
val f : ([> `A | `C] as 'a) -> 'a

# f `E;;
- : _ [> `A | `C | `E] = `E

je m'imaginais donc que

# let f = function `A -> 1 | _ -> 0 ;;
# let x = `E in (f x, x) ;;

me répondrait - : int * _[> `A | `E] = (0, `E)
or il répond int * _[>`E]

        Diego Olivier