probleme de syntaxe lié au type

**yardras** · 27/12/2010, 21h32

Bonsoir a tous,
j'essaie de creer un module qui ait le type objet et qui soit : soit une epee soit arc etc...

mais j'obtiens une erreur de syntaxe et je ne vois pas pourquoi ! Si vous pouviez m'eclairer!! merci bien

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
module Objet = struct
 
  (* objets d'attaques *)
  type epee = {nom : string ; atk : int}
  type arc = {nom : string ; atk : int}
  type hache = { nom : string ; atk : int}
 
  (* objets de defense *)
  type bouclier = {nom : string ; def_arc : int ; def_autre : int }
  type cotte_maille = { nom : string ; def_arc : int ; def_autre : int }
  type casque = { nom : string ; def : int }
 
  (* objets de soin *)
  type potion = { nom : string ; pv : int }
 
  (* type plus general *)
  type objet =  obj : epee 
	       | obj : arc 
	       | obj : hache
	       | obj : bouclier
	       | obj : cotte_maille
	       | obj : casque 
 
end

**InOCamlWeTrust** · 02/01/2011, 02h23

Ce que tu veux faire n'est tout simplement pas possible, et viole le principe même de l'inférence de type à la Caml.

Une façon de faire, plus simple et presque aussi facile, est d'utiliser un type énuméré avec des constructeurs de type. Une autre solution, plus élégante mais un peu plus lourde, reviendrait à utiliser l'aspect objet de OCaml. On pourrait par exemple définir une interface objet appelée objet, puis autant de classes que d'objets différents.

**Cacophrene** · 02/01/2011, 21h22

Bonsoir,

En plus de la remarque de fond d'IOWT, j'ajoute que les définitions suivantes posent problème :

Code :

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

1
2
3
4
type epee = {nom : string ; atk : int}
type arc = {nom : string ; atk : int}
type hache = { nom : string ; atk : int}

En effet les trois types utilisent les mêmes noms de champs (nom et atk), ce qui va poser des problèmes par la suite... Bref, ici, comme l'a dit IOWT, une solution à base d'objets prend tout son sens...

Cordialement,
Cacophrène

**gasche** · 03/01/2011, 14h02

Je pense qu'on peut bien faire ce qu'il veut sans objets, en factorisant les informations similaires dans des sous-types.

Code pas testé :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
type objet = { nom : string; caracs : carcs }
and caracs =
  | Potion of caracs_potion
  | Arme of type_arme * caracs_arme
  | Armure of type_armure * caracs_armure
 
and caracs_potion = { pv : int }
 
and type_arme = Epee | Arc | Hache
and caracs_arme = { atk : int }
 
and type_armure = Bouclier | Casque | Cotte_maille
and caracs_armure = { def : type_arme -> int }

Si on veut éviter les conflits de noms, on peut utiliser des modules. C'est agréable depuis la fonctionnalité Module.(expression) de 3.12.

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
module Arme = struct
  type sorte = Epee | Arc | Hache
  type caracs = { atk : int }
end
 
module Armure = struct
  type sorte = Bouclier | Casque | Cotte_maille
  type caracs = { def : (Arme.sorte, int) assoc }
  and ('a, 'b) assoc = ('a * 'b) list
end
 
type objet = { nom : string; caracs : caracs }
and caracs =
  | Arme of Arme.sorte * Arme.caracs
  | Armure of Armure.sorte * Armure.caracs

(Le choix d'un `(Arme.sorte, int) assoc` plutôt qu'un simple `Arme.sorte -> int` est là pour rendre possible la sérialisation)

**Cacophrene** · 03/01/2011, 17h23

Bonjour,

Envoyé par bluestorm

Si on veut éviter les conflits de noms, on peut utiliser des modules. C'est agréable depuis la fonctionnalité Module.(expression) de 3.12.

Je connais quelqu'un qui répondrais que la version 3.12 est encore très récente... et qu'il vaut mieux s'en tenir à 3.11 pour le moment.

On peut aussi remarquer que, dans un record, si on a explicité {Foo.bar}, il est inutile de préciser {Foo.bar; Foo.foobar}. Une seule levée d'ambiguïté suffit.

Cordialement,
Cacophrène