Discussion :

[gorgonite]

Salut,


J'ai signalé dans un post précédent que je chercherais à paramétrer un module (environment) par un autre module (structure interne quelconque ayant une interface à la Hashtbl)


je suis parti sur la création d'une classe avec des méthodes statiques que je devrais surcharger.

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
#light
#nowarn "62"

/// static type to represent any Hashtab-like type
type ('a,'b) IHashtab() =
   static member create (i : int) : ('a,'b) IHashtab = IHashtab<'a,'b>()
   static member add  (m : ('a,'b) IHashtab) (key:'a) (value:'b) : unit = raise Not_found
   static member replace (m : ('a,'b) IHashtab) (key:'a) (value:'b) : unit = raise Not_found
   static member find (m : ('a,'b) IHashtab) (key:'a) : 'b = raise Not_found
   static member iter (f : 'a -> 'b -> unit) (m : ('a,'b) IHashtab) : unit = ()
   static member remove (m : ('a,'b) IHashtab) (key:'a) : unit = raise Not_found

exception Not_found

/////////////////////

open Ihashtab
open System.Reflection
type environment = IHashtab<string,valeur>

type 'a Environment() =
    inherit IHashtab<string,valeur>()
    static member create i : environment = 
       let typeA = typeof<'a>
       let methodA = typeA.GetMethod("create")
       methodA.Invoke(null,[|i|])

(*
    static member find (env : environment) (v : string) : valeur = 'a.find env v
    static member iter f (env : environment) = 'a.iter f env
    static member add (env : environment) v val_expr = 'a.add env v val_expr
    static member replace (env : environment) v val_expr = 'a.replace env v val_expr
    static member assign (env : environment) (v : string) (val_expr : valeur) =
      try 
        let _ = find env v
        replace env v val_expr 
      with Not_found -> 
        add env v val_expr 
*)

Ensuite, il suffit de jouer avec l'introspection pour invoquer les méthodes, et de caster le résultat...

mais pour le moment, impossible de caster ^^

Code :

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

Error	1	Type constraint mismatch. The type   obj is not compatibile with type  environment.

ça me semble être une bonne approche pour garder l'aspect "module"

qu'en dites-vous ?

[SpiceGuid]

En fait c'est juste un type polymorphe.
Tu peux créer autant de fonctions make/create que tu veux qui implémenteront chacune un ('a,'b) hash_table.

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
module HashTable = struct

type ('a,'b) t =
  {
  add: 'a -> 'b -> unit;
  replace: 'a -> 'b -> unit;
  find: 'a -> 'b;
  remove: 'a -> unit;
  }

let make i =
  let mes_champ_privés = ... in
  let add k v = ...
  and replace k v = ... 
  and find k = ...
  and remove k = ...
  in
  {
  add = add;
  replace = replace;
  find = find;
  remove = remove;
  }

end

[gorgonite]

mais ensuite comment être sûr de pouvoir utiliser un seul module d'abstraction pour accéder à tout ?

parce que dans ce style, j'avais pensé à cela... mais ça ne me plaît pas trop

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
 
#light
#nowarn "62"
 
/// static type to represent any Hashtab-like type
type ('a,'b) IHashtab =
 interface
   abstract member add  : 'a -> 'b -> unit
   abstract member replace : 'a -> 'b -> unit
   abstract member find : 'a -> 'b
   abstract member iter : ('a -> 'b -> unit) -> unit
   abstract member remove : 'a -> unit
 end
 
exception Not_found
 
//////////////////
 
open Ihashtab
type environment<'value> (i : int) =
  let hashtab = Hashtbl.create i
 
  interface IHashtab<string,'value> with
    member self.add  key value =
      Hashtbl.add hashtab key value
 
    member self.replace key value =
      Hashtbl.replace hashtab key value
 
    member self.remove key =
      Hashtbl.remove hashtab key
 
    member self.find key =
      Hashtbl.find hashtab key
 
    member self.iter f =
      Hashtbl.iter f hashtab

[SpiceGuid]

Je ne saisi pas bien ton inquiétude.

En OCaml tu écrirais:

Code :

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

1
2
3
let H = HashTable.make n in
H.add ...;
H.find ...;

En F# tu peux écrire:

Code :

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

1
2
3
4
let h = HashTable.make n in
open HashTable;
h.add ...;
h.find ...;

[gorgonite]

avec le second code, et ce module environment, j'arrive à avoir quelque chose de correct tout est abstrait par IHashtab<string,valeur>

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
/// environment can be seen as a set of (name,value)
module Environment =
  /// Creates a new environment
  let create i = environment(i) :> IHashtab<string,valeur> 
  /// Adds a variable in the environment, and assigns it the given value
  let add (env:IHashtab<string,valeur>) key value =
     env.add key value
  /// Replaces the value of a variable
  let replace (env:IHashtab<string,valeur>) key value =
     env.replace key value
  /// Removes the entry corresponding to a variable
  let remove (env:IHashtab<string,valeur>) key =
     env.remove key
  /// Finds the value of a variable
  let find (env:IHashtab<string,valeur>) key =
     env.find key
  /// Iterates a function on all the elements
  let iter f (env:IHashtab<string,valeur>) =
     env.iter f
  /// Tries to replace value, but if it doesn't exist, it creates it
  let assign (env:IHashtab<string,valeur>) key value = 
     try 
       let _ = find env key
       replace env key value 
     with Not_found -> 
       add env key value

en revanche, F# ne me laisse pas paramétrer mon module Environment par 'valeur afin de pouvoir utiliser une class environment<'valeur>

[gorgonite]

bizarre, ça ne remplit pas ma hashtab

[LLB]

J'ai du mal à comprendre ce que tu veux exactement, au final.

mais pour le moment, impossible de caster ^^

Essaie avec unbox.

Mais cette approche n'est pas bonne (elle est dangereuse).



Sinon, pour ajouter des méthodes à un type, tu as les extensions de méthodes.

Code :

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

1
2
type Map with
  member m.foo = 42

Tu peux passer par une classe abstraite :

Code :

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

1
2
3
4
5
type Hash() =
  abstract member Add: int -> int -> unit
  default h.Add x y = not_found()
 
let make = {new Hash() with member h.Add x y = printfn "%d,%d" x y }

Tu peux aussi passer par une interface (IDictionary existe déjà). Éventuellement, tu peux survoler le fichier collections.fs pour avoir un exemple (par exemple, le type Map implémente l'interface IDictionary).