Ocaml module/class - Page 3

Moumou :
Sally > Ben en fait je n'ai jamais fait d'OO à la caml, mais je pensais que ça marchait un peu pareil que java, non ? Ie quand on déclare une classe on déclare qu'elle hérite d'une autre, et dans ce cas toute fonction qui prend en argument la classe mère peut prendre la classe fille.

Moumou :
Ben alors c'est bien du sous-typage. Enfin c'est ce que moi et le futur chef de Sally appelons du sous-typage

Moumou :
Sally > Ben en fait je n'ai jamais fait d'OO à la caml, mais je pensais que ça marchait un peu pareil que java, non ? Ie quand on déclare une classe on déclare qu'elle hérite d'une autre, et dans ce cas toute fonction qui prend en argument la classe mère peut prendre la classe fille.

# class chaine =
    object(self)
      method longueur = 42
    end;;
class chaine : object method longueur : int end
# class caractere =
    object(self)
    method   longueur = 1
      method nom_unicode = "HOT BEVERAGE"
  end;;
  class caractere :
  object method longueur : int method nom_unicode : string end
# let paire_vers_liste x y = [x;y];;
val paire_vers_liste : 'a -> 'a -> 'a list = <fun>
# let nimportequoi_vers_chaine c = (c:>chaine);;
val nimportequoi_vers_chaine : #chaine -> chaine = <fun>
# let caractere_vers_chaine (c:caractere) = (c:>chaine);;
val caractere_vers_chaine : caractere -> chaine = <fun>
# let fonction (x:chaine) (y:caractere) = paire_vers_liste x y;;
This expression has type caractere = < longueur : int; nom_unicode : string >
but is here used with type chaine = < longueur : int >
Only the first object type has a method nom_unicode

Pollux :
Et bien sûr que si il y a du downcasting possible sans Obj.magic, heureusement (c'est l'upcasting qui n'est pas possible)

Le problème, c'est pas qu'il n'est pas possible, c'est plutôt que l'inférence de type n'est pas toujours capable de le faire tout seul et qu'il faut l'"aider" avec :>...

❰13:44❱ benjamin@bookeldor-main:~/merdier❯ocaml
        Objective Caml version 3.08.3

# class mother =
object(o)
 method m () =
  print_string "mother\n"
end;;
        class mother : object method m : unit -> unit end

# class daughter =
object(o)
 inherit mother as mom
 method m2 () =
  print_string "daughter\n"
end;;
          class daughter : object method m : unit -> unit method m2 : unit -> unit end

# let plop () =
   let c = new mother
   and d = new daughter
   in
   let e = (d :> mother)
   in
     c#m ();
     d#m2 ();
     (e :> daughter)#m2 ()
  ;;
This expression cannot be coerced to type
  daughter = < m : unit -> unit; m2 : unit -> unit >;
it has type mother but is here used with type #daughter
Only the second object type has a method m2

# let plop_qui_marche () =
 let c = new mother
 and d = new daughter
 in
 let e = (d :> mother)
 in
   c#m ();
   d#m2 ();
   ((Obj.magic e) : daughter)#m2 ()
;;
                  val plop_qui_marche : unit -> unit = <fun>

# plop_qui_marche ();;
mother
daughter
daughter
- : unit = ()

match (instanceof o) with
   mother -> o#m
| daughter -> o#m2
;;

BookeldOr :
oui c'est sympa, et d'ailleurs Obj.magic n'est pas là pour rien

BookeldOr
: un truc sympa ça serait de faire un <upcast>

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

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

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

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

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)

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);;

BookeldOr :
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

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

Moumou :
Sally > Ben en fait je n'ai jamais fait d'OO à la caml, mais je pensais que ça marchait un peu pareil que java, non ? Ie quand on déclare une classe on déclare qu'elle hérite d'une autre, et dans ce cas toute fonction qui prend en argument la classe mère peut prendre la classe fille.

 > oui pour que ça passe il faut aller jusqu'à # let fonction = (paire_vers_liste : chaine -> chaine -> chaine list :> chaine -> caractere -> chaine list);;    
val foncti