Discussion :

[alex_pi]

Bonsoir à tous.

Ceci n'est pas une question. Je voulais juste dire que j'avais enfin regardé les variants polymorphes de OCaml disponibles depuis la version 3, et que ça vaut franchement le détour. Je me permets de le souligner parce que j'en vois très peu "dans la nature" (je ne les ai jamais croisé sur les forums de developpez.net), et qu'il me semble que ça peut, dans certain cas, être assez puissant. Un petit exemple de code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
(* différents types *)
type num = [`Float of float | `Int of int]
type 'a opp = [`Plus of 'a | `Moins of 'a]
type 'a func = [`Sin of 'a | `Cos of 'a]
 
(* pour récupérer la valeur flottante *)
let recup_float = function
  | `Int x -> float_of_int x
  | `Float x -> x
 
(* séparation de la fonction pour traiter les évaluation 
   de fonctions*)
let eval_fun eval = function
  | `Sin x -> `Float (sin (recup_float (eval x)))
  | `Cos x -> `Float (cos (recup_float (eval x)))
 
 
let apply_opp opp_int opp_float = function
  | `Int x, `Int y -> 
      `Int (opp_int x y)
  | `Int x, `Float y ->
      `Float (opp_float (float_of_int x)  y)
  | `Float x, `Int y ->
      `Float (opp_float x  (float_of_int y))
  | `Float x, `Float y -> 
      `Float (opp_float x y)
 
 
(* séparation de la fonction pour traiter les évaluation 
   d'application d'oppérateur*)
let eval_opp eval = function
  | `Plus (x, y) ->
      apply_opp (+) (+.) (eval x, eval y)
  | `Moins (x, y) ->
      apply_opp (-) (-.) (eval x, eval y)
 
(* utilisation des deux fonctions précédantes *)
let rec eval = function
  | #num as r -> r
  | #opp as opp -> eval_opp eval opp
  | #func as func -> eval_fun eval func
 
(* début des exemples *)
 
let eval_affiche x = match eval x with
  | `Int x -> print_int x; print_newline ()
  | `Float x -> print_float x; print_newline ()
 
let un = `Int 1
let deux = `Float 2.
let s1 = `Sin (`Float 3.14159)
let o1 = `Plus (`Moins (un,s1), deux)
let o2 = `Moins (`Cos un, o1)
let _ = eval_affiche o2

Après, il est vrai que le typage peut faire un peu peur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
val o2 :
  [> `Moins of
       [> `Cos of [> `Int of int ] ] *
       [> `Plus of
            [> `Moins of [> `Int of int ] * [> `Sin of [> `Float of float ] ] ] *
            [> `Float of float ] ] ]

Pour de plus amples détails la doc officielle

Après, c'est sûr, on perd une certaine sécurité gagné par la définition complete des types unions. Mais je pense qu'avec un peu de rigueur dans l'annotation de type (qui permet de vérifier qu'une fonction a bien le type que l'on croit), le gain peut être plus qu'appréciable.

[SpiceGuid]

Dans certains cas ça remplace avantageusement la POO.
En particulier ça permet la modularisation de l'évaluation, très pratique pour écrire un interpréteur: code reuse through polymorphic variants