Pollux
:

BookeldOr
:

Pollux :
Ben non, comme je l'ai dit à mon avis c'est "by design" que c'est comme ça...

de toutes façons, comme j'ai dit, actuellement ça n'est pas possible facilement

Oui, et "comme j'ai dit" c'est volontaire que ça ne soit pas possible ^^

et puis, pour expliciter que la fonction traite les classes de manière défférente, on pourrait imaginer d'écrire son type en mettant en évidence la disjonction, par exemple
(mother | daughter) -> ()

C'est vrai que ça pourrait être sympa d'avoir un type "somme croissante", de la forme A | B | C avec A<B<C, qui pourrait être considéré de façon transparente comme un #A dans tous les cas, puis par pattern-matching pourrait être séparé en #B / A (ou en #C / B)

Parce que là les alternatives c'est :
- représenter ça comme une somme disjointe normale, mais c'est un peu pénible pour utiliser le plus grand sous-type commun (ce qui risque d'être pourtant l'utilisation la plus fréquente)
- représenter ça comme le plus grand sous-type commun, avec un "daughter option" en plus pour les opérations spécifiques aux daughter (mais c'est un peu crade, par exemple ça ne fournit aucune garantie que le daughter serait, s'il est présent, physiquement égal au mother)

pour vérifier ça, un daughter ref option, et on peut vérifier si c'est bien le meme paramètre que le premier avec l'opé ==
mais c'est encore plus lourd

BookeldOr :
au fait,
vous avez essayé de typer le prog que j'ai posté un peu plus haut ?
c'est assez marrant

./75 ?

let p x y = fun z -> z x y ;;

let q () = 
  let x1 = fun x -> p x x in 
  let x2 = fun z -> x1 (x1 z) in 
  let x3 = fun z -> x2 (x2 z) in 
  let x4 = fun z -> x3 (x3 z) in 
  let x5 = fun z -> x4 ( x4 z) in 
    x5 (fun z -> z);;

(facile à comprendre que le type généré croit très vite, avec un x6 c'est encore plus long, etc...