paramétrer un module par un autre module

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:

---

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:

---

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 ?

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:

---

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

---

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:

---

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

---

Je ne saisi pas bien ton inquiétude.

En OCaml tu écrirais:

Code:

---

1 2 3

let H = HashTable.make n in H.add ...; H.find ...;

---

En F# tu peux écrire:

Code:

---

1 2 3 4

let h = HashTable.make n in open HashTable; h.add ...; h.find ...;

---

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

Code:

---

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>

bizarre, ça ne remplit pas ma hashtab :cry:

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

Citation:

---

Envoyé par gorgonite

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:

---

1 2	type Map with member m.foo = 42

---

Tu peux passer par une classe abstraite :

Code:

---

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

Citation:

---

Envoyé par LLB

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

---

je joue... je veux surtout voir ce qu'il diffère (modules paramétrés en OCaml, mais pas en F#)

pour le moment, je ne suis pas sur quelque chose de trop sérieux... tant que tu ne me voies pas parler de quelque chose en rapport avec le forme SSA, je suis sur un modèle de test ;)

Citation:

---

Envoyé par LLB

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

---

je vais tenter... mais ça risque de m'obliger à définir plus de méthodes que je n'en ai réellement besoin ;)



sinon comprends-tu pourquoi rien ne semble remplir ma hashtab avec l'interface IHashtab et la classe environment :koi:

Code:

---

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 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76

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

---

en gros, ça passe sans TRY_PARAMETRIC_ENV, mais pas avec :cry:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

gorgonite@GorgonMobile:~/Bureau/these/projets/fsharp-pseudo_pascal$ make test /usr/bin/mono --runtime=v2.0.50727 compilo.exe --show-ast --int --analyze ./test.code [Declare ["x"]; Assign (Var "x",Intconst 1); While (Test ("<>",[Var "x"; Intconst 5000]), [Assign (Var "x",Operateur ("+",[Var "x"; Intconst 1]))])]     Unhandled Exception: System.Collections.Generic.KeyNotFoundException: The given key was not present in the dictionary. at Microsoft.FSharp.Collections.HashTableOps.chainFind[String,valeur] (IEqualityComparer`1 ops, System.String x, Microsoft.FSharp.Collections.HashChain`2 _arg1) [0x00000] at Microsoft.FSharp.Collections.HashTableOps.find[String,valeur] (Microsoft.FSharp.Collections.HashMultiMap`2 t, System.String x) [0x00000] at Microsoft.FSharp.Collections.HashMultiMap`2[System.String,Types+valeur].get_Item (System.String ) [0x00000] at Types+Environment.assign (IHashtab`2 env, System.String key, .valeur value) [0x00000] make: *** [test] Erreur 1

---

Citation:

---

Envoyé par gorgonite

sinon comprends-tu pourquoi rien ne semble remplir ma hashtab avec l'interface IHashtab et la classe environment :koi:

---

ben voilà, j'utilisais des assign pour remplir, mais à la première assignation, il fait un add et non un replace.

donc KeyNotFoundException est levée... il faut alors préciser que Not_found est justement un alias pour cette exception

Code:

---

exception Not_found = System.Collections.Generic.KeyNotFoundException

---

le hic est que cela marchait bien avec le module Hashtbl de la librairie de base, ont-ils fait cette "magouille" aussi ?

Utilise la fonction "not_found()", plutôt que de redéfinir ton exception. Les exceptions sont parfois mappées aux types .Net, justement pour améliorer l'interopérabilité.

Évite d'utiliser des exceptions pour les cas "normaux". Ici, tryfind + pattern matching est largement préférable.


Mais a priori, c'est la solution de la classe abstraite qui correspond le mieux à tes besoins.

Citation:

---

Envoyé par LLB

Utilise la fonction "not_found()", plutôt que de redéfinir ton exception. Les exceptions sont parfois mappées aux types .Net, justement pour améliorer l'interopérabilité.

---

mais je ne lève pas d'exception ici... je voulais juste la récupérer :cry:
je vais regarder de plus près :D

Citation:

---

Envoyé par LLB

Évite d'utiliser des exceptions pour les cas "normaux". Ici, tryfind + pattern matching est largement préférable.

---

EDIT : arf, bien sûr IHashtab<'key,'value>.tryfind : 'key -> option<'value>

fait :king:

Citation:

---

Envoyé par LLB

Mais a priori, c'est la solution de la classe abstraite qui correspond le mieux à tes besoins.

---

effectivement, mais je trouve dommage de ne pas pouvoir paraméter mon module par un type, et ainsi garder environment<'valeur> et Environment<'environment> :cry:

Citation:

---

mais je ne lève pas d'exception ici... je voulais juste la récupérer

---

Tu ne l'as pas déclaré avant ?

Si tu utilises l'exception Not_found, tu devrais avoir un warning (compatibilité Caml). Sauf si tu l'as redéfini...

Citation:

---

Envoyé par LLB

Tu ne l'as pas déclaré avant ?

Si tu utilises l'exception Not_found, tu devrais avoir un warning (compatibilité Caml). Sauf si tu l'as redéfini...

---

j'ai du la déclarer dans ihashtab.fs

sinon j'ai fait un nowarn 62 :aie: