Discussion :

[GnuVince]

Je voulais jouer avec les types fantômes, mais je crois mal connaître le fonctionnement des modules dans OCaml, car le code suivant compile sans problème:

SafeString.mli:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
module SafeString : sig
  type 'a t
  type safe
  type unsafe
 
  val new_string : string -> unsafe t
  val unsafe_to_safe : unsafe t -> safe t
  val exec_sql : safe t -> unit
end

SafeString.ml

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
 
module SafeString =
struct
  type 'a t = Str of string
  type safe
  type unsafe
 
  let new_string s = Str s
 
  let unsafe_to_safe unsafe_str =
    match unsafe_str with
      | Str s -> Str ("[SAFE] " ^ s)
 
  let exec_sql s =
    match s with
      | Str s -> Printf.printf "select * from tbl where id=%s\n" s
end
 
 
let _ =
  let s = SafeString.new_string "'world" in
    SafeString.exec_sql s

Compilation/exécution:

Code :

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

1
2
3
4
5
 
19:49 vince@archvince:~/prog/ocaml/phantom$ ocamlopt SafeString.mli
19:49 vince@archvince:~/prog/ocaml/phantom$ ocamlopt SafeString.ml
19:49 vince@archvince:~/prog/ocaml/phantom$ ./a.out 
select * from tbl where id='world

Je me serais attendu à ce que la compilation de SafeString.ml échoue, car j'essaye de passer un unsafe SafeString.t à une fonction qui doit recevoir un safe SafeString.t.

Est-ce que quelqu'un pourrait me démêler S.V.P.?

Merci,

Vincent.

[gasche]

Les types deviennent fantômes au moment où tu "scelles" le module en cachant la définition des types avec une interface. Dans ton code c'est fait dans le .mli, donc à l'extérieur du module. Seul le code utilisant le module SafeString *de l'extérieur* est concerné. Si tu plaçais ton code d'exemple dans un autre fichier, utilisant le module SafeString.SafeString (le module SafeString dans le fichier "modulisé" safestring.ml), tu aurais une erreur.

L'autre solution, plus simple et plus logique, est de contraindre directement l'interface de ton module SafeString :

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
module type SAFESTRING = sig
  type 'a t
  type safe
  type unsafe
 
  val new_string : string -> unsafe t
  val unsafe_to_safe : unsafe t -> safe t
  val exec_sql : safe t -> unit
end
 
module SafeString : SAFESTRING =
struct
  type 'a t = Str of string
  type safe
  type unsafe
 
  let new_string s = Str s
 
  let unsafe_to_safe unsafe_str =
    match unsafe_str with
      | Str s -> Str ("[SAFE] " ^ s)
 
  let exec_sql s =
    match s with
      | Str s -> Printf.printf "select * from tbl where id=%s\n" s
end
 
 
let _ =
  let s = SafeString.new_string "'world" in
    SafeString.exec_sql s

PS : qu'est-ce que tu essaies d'obtenir au final ? On dirait une interface pour gérer une fonction "escape" dans un contexte web sale, mais je ne comprends pas trop la signification de "exec_sql" du coup.

[TropMDR]

@bluestorm : bah la signature d'exec_sql attend une chaine qui a été échappée

Sinon j'ajouterai que tu n'as pas besoin de créer un nouveau type. Tu peux très bien utiliser directement le type string :

type 'a t = string

[GnuVince]

@bluestorm: en mettant la fonction d'appel dans un fichier main.ml, j'ai le comportement que je voulais, merci. L'exemple n'a pas d'utilité pratique, c'était juste pour "simuler" le cas où un programmeur oublierait de bien sanitiser une chaîne avant de l'inclure dans un appel SQL.

@TropMDR: merci pour le petit truc.

[NokyDaOne]

Je voulais jouer avec les types fantômes, mais je crois mal connaître le fonctionnement des modules dans OCaml, car le code suivant compile sans problème:

SafeString.mli:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
module SafeString : sig
  type 'a t
  type safe
  type unsafe
 
  val new_string : string -> unsafe t
  val unsafe_to_safe : unsafe t -> safe t
  val exec_sql : safe t -> unit
end

SafeString.ml

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
 
module SafeString =
struct
  type 'a t = Str of string
  type safe
  type unsafe
 
  let new_string s = Str s
 
  let unsafe_to_safe unsafe_str =
    match unsafe_str with
      | Str s -> Str ("[SAFE] " ^ s)
 
  let exec_sql s =
    match s with
      | Str s -> Printf.printf "select * from tbl where id=%s\n" s
end
 
 
let _ =
  let s = SafeString.new_string "'world" in
    SafeString.exec_sql s

Mais quel code choquant. type 'a t défini par Str of string
ya pas le moindre 'a dedans. Ça sent le design foireux à 1000 mètres ce truc là.

[gasche]

C'est justement le principe des types fantômes : on utilise des variables de type qui ne décrivent pas forcément des données physiquement présentes dans les valeurs, mais qui transportent de l'information statique qui nous intéresse. En utilisant un module privé, on peut contrôler la façon dont sont créés et utilisés les éléments de type ('a t), pour garantir certains invariants sur ('a).

Ici, on garantit que la variable ('a) peut prendre deux valeurs, (safe) et (unsafe), qu'une chaîne fournie donne une valeur (unsafe), et que la seule manière de construire une valeur (safe) est d'utiliser la fonction de protection (unsafe_to_safe). En d'autres termes, on garantit statiquement que toutes les chaînes fournies à exec_sql ont été protégées.

Si tu remplaces ce squelette par une vraie fonction de protection, tu peux avoir un module qui fait que le compilateur vérifie tout seul l'absence de faille par injection SQL (par exemple).

Tu devrais prendre un peu de temps pour te familiariser avec les types fantômes, c'est une notion assez utile. Voici deux billets de blog qui en présentent des usages en Caml :
- Camltastic : Phanton types
- Static access control using phantom types

[NokyDaOne]

Parceque

Code :

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

1
2
3
4
5
6
7
8
9
 
module SafeString : sig
  type safe
  type unsafe
 
  val new_string : string -> unsafe
  val unsafe_to_safe : unsafe -> safe
  val exec_sql : safe -> unit
end

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
module SafeString =
struct
  type safe = string
  type unsafe = string
 
  let unsafe_to_safe unsafe_str =
    "[SAFE] " ^ unsafe_str
 
  let exec_sql s =
    Printf.printf "select * from tbl where id=%s\n" s
end

tu n'aimes pas ça ? Pourtant ça revient exactement au même sans le 'a t.

[[troll]]
Voilà ce que c'est de travailler avec un langage sans Monades. Vous passez votre temps à en définir des sous version bcp moins performantes.
[[/troll]]

[TropMDR]

tu n'aimes pas ça ? Pourtant ça revient exactement au même sans le 'a t.

Supposons maintenant que tu veuilles définir la concaténation de deux chaines ? En supposant que deux chaines "safe" concaténées restent safes, avec les types fantomes, tu peux écrire

Code :

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

let concat s1 s2 = s1 ^s2

et lui donner le type

Code :

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

concat : 'a t -> 'a t -> 'a t

Dans ta version, il te faudra concat_safe et concat_unsafe, puisque tu as perdu le polymorphisme

[[troll]]
Voilà ce que c'est de travailler avec un langage sans Monades. Vous passez votre temps à en définir des sous version bcp moins performantes.
[[/troll]]

Un "langage sans monade" ? Mince alors, comment ils font pour écrire lwt ? Qu'est ce que le type option ?

Ce n'est pas parce qu'il n'y a pas de type classes, et donc pas de possibilité de surcharger >>= qu'il n'y a pas de monades.

C'est bien de vouloir troller, c'est mieux quand il y a vaguement quelque chose derrière.

[NokyDaOne]

Supposons maintenant que tu veuilles définir la concaténation de deux chaines ? En supposant que deux chaines "safe" concaténées restent safes, avec les types fantomes, tu peux écrire

Code :

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

let concat s1 s2 = s1 ^s2

et lui donner le type

Code :

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

concat : 'a t -> 'a t -> 'a t

Dans ta version, il te faudra concat_safe et concat_unsafe, puisque tu as perdu le polymorphisme

C'est pas faux. Mais je suis sûr que l'on peut faire sans le type fantôme, j'y réfléchirai ce soir.

Un "langage sans monade" ? Mince alors, comment ils font pour écrire lwt ? Qu'est ce que le type option ?

Ce n'est pas parce qu'il n'y a pas de type classes, et donc pas de possibilité de surcharger >>= qu'il n'y a pas de monades.

C'est bien de vouloir troller, c'est mieux quand il y a vaguement quelque chose derrière.

Euh normalement on ne nourrit pas un troll.

[gasche]

Un autre exemple de code qui profite des types fantômes :

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
module Expr : sig
  type 'a expr
  val int : int -> int expr
  val bool : bool -> bool expr
  val sum : int expr -> int expr -> int expr
  val if_ : bool expr -> 'a expr -> 'a expr -> 'a expr
end = struct
  type t =
    | Int of int
    | Bool of bool
    | Sum of t * t
    | If of t * t * t
  type 'a expr = t
 
  let int n = Int n
  let bool b = Bool b
  let sum a b = Sum (a, b)
  let if_ p a b = If (p, a, b)
end

Il faut noter que les signatures apportent ici une sûreté de type à la construction des valeurs. Même si l'on donnait une façon d'inspecter les valeurs de type "expr" (ce qui est possible), certaines opérations naturelles dans ce modèle (par exemple (eval : 'a expr -> 'a)) ne sont pas faciles à coder dans le cadre du système de type de OCaml, et demandent des choses plus avancées comme les GADT, ou un usage prudent de Obj.magic.