passer en #light ce module

Version imprimable

Salut,

J'essaie en vain de passer ce module en version #light

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
module Environment : 
  sig
    val assign : environment -> string -> valeur -> unit
    val find : environment -> string -> valeur
    val create : int -> environment
    val iter : (string -> valeur -> unit) -> environment -> unit
  end = struct
    //include Hashtbl
    let create i : environment = Hashtbl.create i
    let find env (v : string) : valeur = Hashtbl.find env v
    let iter f (env : environment) = Hashtbl.iter f env 
 
    let assign env (v : string) (val_expr : valeur) =
      try 
        let _ = Hashtbl.find env v
        Hashtbl.replace env v val_expr 
      with Not_found -> 
        Hashtbl.add env v val_expr 
  end

pour infos, il passe en syntaxe normale

au passage, le sig ne sert à rien puisque le include n'a pas marché :cry:

12/05/2008, 20h01
LLB
Si tu veux déclarer un module, fais juste :
Code:

1 2 module foo = let f x = ...
Le "end" à la fin est optionnel.

Pour le include, tu peux faire :
Code:

1 2 3 module Environment = Hashtbl module Environment = // tes fonctions
Tu peux d'ailleurs ajouter des fonctions à n'importe quel module existant, avec la 2e ligne.

Pour la signature, elle devrait normalement aller dans un fichier .fsi.
12/05/2008, 21h40
gorgonite
ça marche, mais c'est un peu lourd à utiliser :
Code:

1 2 3 4 > module Environment = Hashtbl > module Environment = struct let assign env v expr = Hashtbl.add env v expr end;; > let env : (string,int) Hashtbl.t = Environment.create 10;;
Citation:

Envoyé par LLB

Pour la signature, elle devrait normalement aller dans un fichier .fsi.

ben j'aimerais bien pouvoir tout mettre en le fichier .fs comme en OCaml... ;)

finalement, je passerais pas un fsi plus tard... pour le moment, j'expose tout ;)

voilà mon code :
Code:

1 2 3 4 5 6 7 8 9 10 module Environment = Hashtbl module Environment = let create i : environment = Hashtbl.create i let assign env (v : string) (val_expr : valeur) = try let _ = Hashtbl.find env v Hashtbl.replace env v val_expr with Not_found -> Hashtbl.add env v val_expr
nb : j'ai quand même spécifié create, sinon il fallait que je spécifie systématiquement le type renvoyé par Environment.create (donc Hashtbl.create)

13/05/2008, 17h38
gorgonite

Salut,

ben en fait, ça n'a pas l'air de marcher :cry:

ce code :

Code:

Environment.find env v

me répond ceci :

Code:

interpret.fs:77:error: FS0039: The value, constructor, namespace or type 'find' is not defined.

J'avais oublié de répondre à ce message. En gros : chez moi, ça marche.

Le code suivant compile.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#light
 
module Environment = Hashtbl
module Environment =
    let create i = Hashtbl.create i
 
    let assign env (v : string) (val_expr : int) =
      try
        let _ = Hashtbl.find env v
        Hashtbl.replace env v val_expr 
      with Not_found ->
        Hashtbl.add env v val_expr;;
 
Environment.create |> ignore
Environment.find |> ignore

30/05/2008, 09h05
gorgonite

effectivement, ça marche avec F# 1.4.9.15 sous vista... mais çe ne marchait pas avec F# 1.3.*** sous Mono/Linux :cry: