passer en #light ce module [Résolu]

[gorgonite]

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é

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

[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;;

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

[gorgonite]

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)

[gorgonite]

Salut,


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

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.

[LLB]

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

[gorgonite]

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