Discussion :

[zuymanto]

Bonjour à tous,

J'ai un soucis de comprehension sur un exo, je cite:

module Euro = (MFloat : MONNAIE);;
module Dollar = (MFloat : MONNAIE);;
Vérifiez que les deux monnaies sont bien incompatibles entre elles. Quel mécanisme de OCaml permet de s’en assurer ? (Le mécanisme de type génératifs)
Exercice 2 [Bureau de change] On souhaite maintenant créer un bureau de change sous forme de module qui permette de convertir une somme en euros en une somme en dollars.
1. Donnez la signature du module la plus abstraite (par exemple le taux de change n’a pas be- soin d’être connu). Rappel : la signature d’un module peut elle même contenir des variables de type module.
2. Donnez en une implémentation.

Je ne comprend pas comment je peux utiliser le module Euro et Dollar dans ce n-ième module pour faire le module change de plus je ne vois même pas pourquoi il fait allusion à l'imbrication de module.

Le module Mfloat contient un type t = float, ainsi que les opérations un (retourne une unité), plus (addition), et prod (produit) et monnaie cache juste le type float de MFloat.

Des explications s'il vous plait?

[SpiceGuid]

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
module type Money =
  sig
    type t
    val one : t
    val plus : t -> t -> t
    val prod : float -> t -> t
  end 

module MFloat =
  struct
    type t = float
    let one = 1.0
    let plus = ( +.)
    let prod = ( *.)
  end  

module Euro = (MFloat : Money)  
module Dollar = (MFloat : Money)

Pour l'incompatibilité des monnaies, on te demande de prouver (à l'aide d'une expression mal typée) qu'il y a incompatibilité entre le type Euro.t et le type Dollar.t, en clair tu dois faire apparaître un message de ce genre :

Code :

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

1
2
Error: This expression has type Dollar.t
       but an expression was expected of type Euro.t

D'après ce que je crois comprendre la question 1. te demande de compléter les pointillés dans ce code :

Code :

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

1
2
3
4
5
6
module type Changer =
  sig
    module MA : ...
    module MB : ...
    val change : ...
  end

Toujours d'après ce que je crois comprendre, la question 2. te demande de compléter les pointillés dans ce code :

Code :

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

1
2
3
4
5
6
module EuroToDollar
  : Changer with module ... and module ... 
  =
  struct
    ...
  end

Par contre au final ma fonction change est un peu roublarde: la banque garde les centimes d'euros (il faut bien manger ).

edit: pour comparer deux valeurs float tu peux utiliser la fonction compare.

[zuymanto]

Bonsoir SpiceGuid,
Pour tout ce qui est avant l'exo 2 j'ai compris.
Sauf par contre le test je n'ai pas reussi à tester l'incompatibilité !
J'ai un main qui contient ce code et la compilation m'indique une erreur.

Code :

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

1
2
3
4
5
6
7
module Euro = (Mfloat : Monnaie) ;;
module Dollar = (Mfloat: Monnaie);;
let unD = Dollar.un ;;
let unE = Euro.un ;;
print_float (Dollar.prod unE unE) ;;
print_float Mfloat.un ;;
print_newline ();;

Erreur --

Code :

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

1
2
3
ocamlc -c  main.ml
File "main.ml", line 1, characters 24-31:
Error: Unbound module type Monnaie

Monnaie est bien crée et compilé ainsi que MFloat donc je ne comprend pas.

Sinon pour Change j'avais plutôt écris :

Code :

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

1
2
3
4
5
6
module Change :
sig
  module type Euro = (MFloat : Monaie)
  module type Dols = (MFloat : Monaie)
 
end ;;

Je me rend compte que c'est une trop grosse restriction pour le module change et qu'effectivement je dois juste identifier un module A et B.
Mon code est potentiellement même niveau syntaxique, incorrect.

[Ptival]

Code :

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

Error: Unbound module type Monnaie

Où as-tu défini le module type Monnaie ?

- Tu peux avoir un fichier Monnaie.mli qui ne contient que le corps de la signature (ce qui ne semble pas être le cas vu l'erreur...)

- Tu peux avoir un fichier Foo.mli qui contient notamment les lignes :

Code :

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

1
2
3
4
 
module type Monnaie = sig
...
end

auquel cas tu dois probablement l'atteindre en faisant "open Foo" pour mettre "Monnaie" dans ta portée, ou bien en le qualifiant complètement "Foo.Monnaie".

Bref, peux-tu détailler ce que tu entends par :

Monnaie est bien crée et compilé

s'il-te-plaît ?

(Et sinon, effectivement pour Change, ta spécification te pousse à changer toujours d'Euro vers Dols, mais tu veux pouvoir un jour échanger en Yen !)

[zuymanto]

En fait non plus tot dans la journée j'ai été aidé par tu sais qui =) pour les modules.
Et monnaie est normalement bien défini -_-'
La preuve:

Code :

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

1
2
3
4
5
  type t
  val un   : t
  val plus : t -> t -> t
  val prod : t -> t -> t
  val print: t -> unit

et
la compilation

Code :

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

1
2
3
4
5
6
7
8
9
10
11
all: monnaie.cmi mfloat.cmo main.cmo
	ocamlc -o prog  mfloat.cmo main.cmo
 
clean:
	rm -f prog *.cmo *.cmi *~
 
# generic rules :
#################
 
.SUFFIXES: .mll .mly .mli .ml .cmi .cmo .cmx
 [..]

Donc je ne comprend vraiment pas le problème.
J'ai compris la pour module type M = sig (* mli's content file *) end;;
Et là je ne vois vraiment pas l'erreur.

[Cacophrene]

Bonjour,

Ta commande de compilation, justement, pose problème ! Tu n'indiques pas à ocamlc qu'il faut utiliser ton module Monnaie. Essaie ceci :

Code :

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

ocamlc monnaie.cmo mfloat.cmo main.cmo -o prog

Cordialement,
Cacophrène

[zuymanto]

Bonjour,

Ta commande de compilation, justement, pose problème ! Tu n'indiques pas à ocamlc qu'il faut utiliser ton module Monnaie. […]
Cacophrène

Théoriquement Monnaie n'est pas compilable en fichier objet non? Etant totalement une interface.
De plus, j'ai fait l'expérience suivante (juste par désespoir)

Code :

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

module Dollar = (Mfloat: Monnaie);;

Code :

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

module Dollar = (Monnaie: Mfloat);;

Et le compilateur me dit respectivement:

Code :

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

1
2
3
4
5
File "main.ml", line 2, characters 23-30:
Error: Unbound module type Monnaie
//
File "main.ml", line 2, characters 24-30:
Error: Unbound module type Mfloat

Désespérant. Je ne vois absolument pas où est l'erreur, soit quelque chose que je n'ai absolument pas compris dans les modules soit un détail vicieux vite passé.

[Cacophrene]

Bonsoir,

Théoriquement Monnaie n'est pas compilable en fichier objet non? Etant totalement une interface.

Tu n'as qu'un fichier .mli, sans implémentation associée (fichier .ml) ? Je pense que tu peux commencer par changer ça Un fichier de code (.ml) et un fichier d'interface (.mli).

Cordialement,
Cacophrène

[zuymanto]

́E1.2 : Ecrivez une interface MONNAIE de telle façon à ce que le type t soit abstrait.

Je ne pense pas que l'implémentation de Monnaie soit nécessaire et n'est pas demandé. Monnaie est ici comme une interface qu'une implémentation pourra hérité.
Et d'après le problème de compilation expliqué plus haut (cf. Mfloat: Monnaie -> Mfloat: Monnaie: Mfloat), il semblerait que le problème ne vienne pas vraiment du fait que monnaie ne soit pas implémenté.

[SpiceGuid]

Tu perds beaucoup trop de temps avec ocamlc.
Contournes-le.
Mets tout ton code dans un fichier unique Money.ml (la solution complète de l'exercice fait environ 40 lignes).
Démarre ocaml et :
1. Ou bien tu fais du copier-coller du texte vers la console en ajoutant ;; à la fin
2. Ou bien tu utilise les directives :

Code :

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

1
2
 #cd  "dir-name";; 
 #use "Money.ml";;

[zuymanto]

Dans la BI tout fonctionne comme je l'ai dit.
Et tout faire dans un fichier aussi n'est pas un problème.

Je n'ai jamais fait d'OCaml pour une compilation séparé et c'est bien là le but ici. D'autre part j'aimerais savoir si vous avez des exemples d'utilisation d'ocamldeps dans un Makefile car comme je fait dans un projet conséquent il est possible que ce devient invivable.

Actuellement j'ai :

• mfloat.ml — Qui implemente un module avec un type t = float
• monnaie.mli — Qui décrit la signature des monaies ( exactement mfloat avec le type caché). J'aimerai pouvoir créer des modules ayant pour signature Monnaie, dans l'avenir.
• main.ml — Qui contient module Euro et Dollar et des tests. J'aimerai externer Euro et Dollar dans des fichiers distincts.
• Potentiellement Euro.ml et Dollar.ml qui contiendrait les seules ligne module Euro = (...) ;; par exemple mais il semblerait que je devrait alors faire Euro.Euro. ce que je ne souhaite pas.

[zuymanto]

Code :

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

Error: Unbound module type Monnaie

Où as-tu défini le module type Monnaie ?
[…]
Bref, peux-tu détailler ce que tu entends par :
[…]

Monnaie est une interface dans un mli donc. Juste le corps y es contenu

Code :

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

1
2
3
4
5
6
 type t
  val un   : t
  val plus : t -> t -> t
.
.
.

Il compile lorsque je lance ocamlc -c monnaie.mli et je peux vien faire et il est bien crée puisque je peux le charger dans la BI. J'ai surement mal compris quelque chose sur l'interaction des modules entre eux parce qu'à ce niveau je commence à perdre la tête.
Edit: Joyeux st Valentin ?

[Ptival]

Alors c'est quelque chose que je ne comprends jamais vraiment bien avec OCaml, mais j'ai l'impression qu'il n'est pas prévu que tu aies un fichier .mli présentant une signature sans un fichier .ml contenant une implémentation de cette signature finalisant l'unité de compilation.

-----

Solution 1) Abuser les unités de compilation :

Monnaie.mli :

Code :

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

1
2
3
4
 
module type Monnaie = sig
...
end

Euro.mli :

Code :

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

1
2
3
4
5
6
 
open Monnaie
 
module Euro : Monnaie = struct
...
end

Main.mli :

Code :

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

1
2
3
4
 
open Euro
 
let _ = Euro.(print un)

Pour compiler tout ça :
ocamlc -c Monnaie.mli
ocamlc -c Euro.ml
ocamlc -c Main.ml
ocamlc -o Main Euro.cmo Main.cmo

-----

Solution 2) Abandonner la compilation séparée...

Monnaies.mli :

Code :

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

1
2
3
4
5
6
 
module type Monnaie = sig
...
end
 
module Euro : Monnaie

Monnaies.ml :

Code :

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

1
2
3
4
5
6
7
8
 
module type Monnaie = sig
... (* oui, la même signature... *)
end
 
module Euro : Monnaie = struct
...
end

Main.ml :

Code :

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

1
2
3
4
 
open Monnaies
 
let _ = Euro.(print un)

Compilation :
ocamlc -c Monnaies.mli
ocamlc -c Monnaies.ml
ocamlc -c Main.ml
ocamlc -o Main Monnaies.cmo Main.cmo


Je ne sais pas si ce sont les "bonnes" façons de faire, mais au moins cela marche. En attendant que les experts viennent expliquer pourquoi ce que j'explique c'est mal

Edit: Joyeux st Valentin ?

Merci.

[Cacophrene]

Bonjour,

Je ne pense pas que l'implémentation de Monnaie soit nécessaire et n'est pas demandé

Ce que je te demande d'écrire n'est pas vraiment une implémentation puisque c'est la copie conforme de ton fichier monnaie.mli dans un fichier monnaie.ml. Il n'y a donc aucune implémentation à proprement parler. En fait, les compilateurs ne s'attendent pas à trouver un fichier mli tout seul... la solution de contournement de Ptival est bonne mais rend les choses bien confuses pour un problème lié à ocamlc/ocamlopt plus qu'à OCaml lui-même.

Ceci dit, dans ton exercice il n'y a pour ainsi dire aucune raison de mettre tous les bouts de code dans des fichiers distincts (ce serait plutôt une bonne pratique dans une application grandeur nature). Le système de modules n'est pas restreint aux fichiers. La solution de SpiceGuid est la meilleure. Si tu as besoin d'un type Monnaie, tu peux le définir dans le même fichier que le reste... et tu compiles simplement avec quelque chose comme ocamlc exercice.ml -o test_exercice.

Cordialement,
Cacophrène

[gasche]

Ce qu'il faut bien comprendre, c'est qu'un mli ne définit pas une signature OCaml utilisable dans les autres modules. Il précise la signature de l'implémentation associée, dans le .ml. Quand tu écris "foo.mli", ça ne revient pas à définir "module type Foo = sig ... end", mais à définir la partie signature de "module Foo : sig ... end = struct ... end". Dans le reste du programme, l'identifiant `Foo` désigne donc un *module* (une structure) plutôt qu'une interface (une signature).

Si tu veux continuer à mettre cette interface dans un .mli, la solution est de mettre l'interface dans un champ signature: dans foo.mli tu mets

module type S = sig
... contenu du .mli ...
end

Du coup, `Foo` désigne toujours un module, mais un module qui contient une signature, et tu peux faire référence à cette signature par `Foo.S` dans les autres fichiers. C'est un peu de la triche parce que tu n'as pas de .ml associé, mais un module qui contient seulement des signatures et types ne produit en fait pas de code compilé, donc il est seulement utilisé par le typeur (qui utilise seulement les .mli, pas besoin des .ml) et l'absence de .ml passe inaperçue.

Ptival > je préfère éviter d'utiliser `open` pour expliquer les modules aux gens, ça rend les choses plus difficiles à suivre. Du coup il vaut mieux utiliser un nom différent pour le fichier et ses composants, Monnaie.S c'est plus clair que Monnaie.Monnaie je trouve.

[zuymanto]

Ce qu'il faut bien comprendre, c'est qu'un mli ne définit pas une signature OCaml utilisable dans les autres modules. Il précise la signature de l'implémentation associée, dans le .ml. Quand tu écris "foo.mli", ça ne revient pas à définir "module type Foo = sig ... end", mais à définir la partie signature de "module Foo : sig ... end = struct ... end". Dans le reste du programme, l'identifiant `Foo` désigne donc un *module* (une structure) plutôt qu'une interface (une signature).

Merci c'est ce que j'ai comprendre cette nuit.

Ptival > je préfère éviter d'utiliser `open` pour expliquer les modules aux gens, ça rend les choses plus difficiles à suivre. Du coup il vaut mieux utiliser un nom différent pour le fichier et ses composants, Monnaie.S c'est plus clair que Monnaie.Monnaie je trouve.

Moi aussi.

Bon finalement j'ai tout mis dans un fichier et il m'arrive encore des bricoles.
Une erreur toujours sur les modules.

module type MONNAIE =
sig
...
end;;

module MFloat : MONNAIE =
struct
...
end;;

...

Le compilateur émet une erreur assez étrange sur le matchage du symbole "sig"
Une idée?

[gasche]

Sans l'erreur, difficile de dire quoi que ce soit.

Je parie sur le fait que ta signature ne correspond pas à ton implémentation : dans ton exemple de départ tu as "un" d'un côté et "one" de l'autre part exemple.

[zuymanto]

L'erreur est la suivante :

Code :

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

1
2
File "All.ml", line 3, characters 0-3:
Error: This 'sig' might be unmatched

Et mon fichier contient donc:

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
 
 
module type MONNAIE =
  sig
    type t 
    let un: t
    let plus : t -> t -> t
    let prod : t -> t -> t
    let print: t -> unit
  end ;;
 
module MFloat: MONNAIE =
  struct
    type t = float
    let un =  1.
    let plus e1 e2 = e1 +. e2
…

Je commence à me poser des questions sur ocaml je voulais m'en faire mon langage de prédilection et délaisser le c mais finalement...

[Ptival]

Bête erreur de syntaxe : dans une signature tu écris "val name : type" et pas "let" !

Note aussi que les ";;" sont optionnels quand tu écris dans un fichier, où les retours à la ligne indiquent où s'arrêter. Ils servent vraiment dans ta boucle interactive quand tu dois taper plusieurs lignes, et lorsque tu en as terminé tu l'indiques avec ";;".

[zuymanto]

Merci beaucoup.
Après cela je n'ai plus d'erreur à ce niveau mais par contre sur cette définition:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
module type CHANGE =
  sig (* ligne 24 *)
    module type MA =
      sig
        include module type of MONNAIE
        val taux: t
      end
    module type MB =
      sig
        include module type of MONNAIE
        val taux: t
      end
    val change: MA -> MB -> MB.t (* ligne 35 *)
  end ;;

L'erreur est :

Code :

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

1
2
3
4
File "exo3.ml", line 35, characters 19-21:
Error: Syntax error: 'end' expected
File "exo3.ml", line 24, characters 2-5:
Error: This 'sig' might be unmatched

J'ai dû mal tapper quelque chose.
Je souhaite pouvoir faire des changes sur deux monnaies MA et MB qui seront implémenté différemment selon le module de change qu'on désire développer.
---
Plus tard je compte le faire avec les foncteurs bien évidements.