erreur de typage caml - Page 1

voila mon fichier ml

module type PILE_SIG =
 sig
  exception Vide
  type 'a pile
  val depiler : 'a pile -> 'a
  val empiler : 'a pile -> 'a-> unit
  val create : 'a pile
 end

module Pile : PILE_SIG=
 struct
  
  exception Vide
  type 'a pile = {mutable ls : 'a list}

  let depiler p =
    let a = List.hd p.ls in
	(p.ls<-(List.tl p.ls);a)
  let create = {ls=[]}
  let empiler p e =
    p.ls<-e:: p.ls
 end

val create : 'a pile

et la sortie de ocamlc: 
File "Pile.ml", line 11, characters 1-206:
Signature mismatch:
Modules do not match:
  sig
    exception Vide
    type 'a pile = { mutable ls : 'a list; }
    val depiler : 'a pile -> 'a
    val create : '_a pile
    val empiler : 'a pile -> 'a -> unit
  end
is not included in
  PILE_SIG
Values do not match:
  val create : '_a pile
is not included in

NOTE: je débute en caml

Ben il suffit que tu déclares dans la signature que create est une '_a pile et pas une 'a pile (en fait '_a pile veut dire qu'on ne connaît pas le type des éléments que tu mets dans ta pile mais ça ne peut être qu'un seul type, autrement dit tu ne peux pas empiler un entier puis une chaîne dans la même pile... 'a pile ne peut pas être le type d'une *valeur* (ça pourrait en revanche être le type de retour d'une fonction qui prend un 'a en paramètre, typiquement) parce que ça voudrait dire que tu pourrais faire ce genre de choses).

Mais à mon avis il y a un autre problème : c'est que tel que tu le déclares, create n'est pas une fonction : c'est une pile en variable globale ! à mon avis ce n'est pas ce que tu veux faire. Déclare create comme un unit -> '_a pile, et définis-le par :
let create () = {ls=[]}
ça me paraît plus logique

j'ai pas du bien comprendre (j'ai mis des _a partout où j'avais mis des a dans mon sig)

=>the type variable name '_a is not allowed in programs

en fait pour le create, c'est parce que j'ai tout essayé pour enlever l'erreur et c la dernière version, avant c'était un unit -> 'a pile

ah mais non il ne faut pas en mettre *partout*...
type 'a pile : tu déclares un type paramétrique, la variable s'appelle 'a, ça c'est bon.
val depiler : 'a pile -> 'a, ça c'est bon aussi : c'est encore une variable de type, elle sert à dire que ta fonction peut prendre en paramètre des truc pile et renvoyer des truc, aussi bien qu'elle peut prendre des machin pile et renvoyer des machin.
empiler : idem
create : là il ne s'agit pas d'une *variable de type* (elle n'apparaît que dans le type de retour), c'est un type fixe, celui de la valeur de retour de ta fonction. Et ce type est '_a pile, ce qui signifie « une pile d'éléments de on sait pas quel type mais toujours le même ». En fait ça veut dire que si tu prends une '_a pile et tu empiles dedans un int, par exemple, le compilateur va en déduire que '_a = int et qu'il s'agit donc d'une int pile, et c'est définitif

Sinon, en général, quand tu veux créer une signature c'est assez pratique de prendre celle qu'il te génère automatiquement et de la modifier comme tu veux (là tu vois bien que dans ce qu'il te répond il ne met un '_a qu'à un seul endroit).

bon alors quand je mets le _a il ne veut pas compiler et là je fais ça:

module type PILE_SIG=
 sig
  exception Vide
  type 'a pile
  val depiler : 'a pile -> 'a
  val empiler : 'a pile -> 'a-> unit
  val create : unit -> 'a pile
 end

module Pile : PILE_SIG=
 struct
  
  exception Vide
  type 'a pile = {mutable ls : 'a list}

  let depiler p =
    let a = List.hd p.ls in
	(p.ls<-(List.tl p.ls);a)
  let create ()= {ls=[]}
  let empiler p e =
    p.ls<-e:: p.ls
 end

let main () =
 let st = Pile.create in
  try  
   Pile.empiler st "UN";
   Pile.empiler st "DEUX";
   Pile.empiler st "TROIS";
   Pile.empiler st "QUATRE";
   print_string (Pile.depiler st);
   print_string (Pile.depiler st);
   print_string (Pile.depiler st);
   print_string (Pile.depiler st);
   print_string (Pile.depiler st);
  with 
   Pile.Vide -> print_string "ça suce";
main();;

et

laptop-ben:~/ocaml# ocamlc Pile.ml
File "Pile.ml", line 27, characters 16-18:
This expression has type unit -> 'a Pile.pile but is here used with type
  'b Pile.pile

(nb: je sais, je n'ai pas utilisé cette exception que je catche mais c'est prévu)

let st = Pile.create () in...
si tu mets pas les parenthèses, tu n'appelles pas la fonction
(N.B. j'aurais trouvé l'erreur vachement plus vite si j'avais su quelle était la ligne 27 ) (bon ok j'ai c/c dans ocaml ça m'a pas pris des heures mais bon ^^)

now, j'ai une syntax error sur le in dans

let st = (Pile.create ()) in

pas moi
t'as dû te planter quelque part va ^^

et ben moi ça marche pas

je reposte au cas où

module type PILE_SIG=
 sig
  exception Vide
  type 'a pile
  val depiler : 'a pile -> 'a
  val empiler : 'a pile -> 'a-> unit
  val create : unit -> 'a pile
 end

module Pile : PILE_SIG=
 struct
  
  exception Vide
  type 'a pile = {mutable ls : 'a list}

  let depiler p =
    let a = List.hd p.ls in
	(p.ls<-(List.tl p.ls);a)
  let create () = {ls=[]}
  let empiler p e =
    p.ls<-e:: p.ls
 end

 let st = (Pile.create()) in
  try
   Pile.empiler st "UN";
   Pile.empiler st "DEUX";
   Pile.empiler st "TROIS";
   Pile.empiler st "QUATRE";
   print_string (Pile.depiler st);
   print_string (Pile.depiler st);
   print_string (Pile.depiler st);
   print_string (Pile.depiler st);
   print_string (Pile.depiler st);
  with 
   Pile.Vide -> print_string "ça suce";
;;

C'est parce que t'as pas le droit de mettre autre chose que des déclarations au "toplevel" de ton fichier (ie des let, des module, des type, etc.), t'as pas le droit d'évaluer une expression direct... donc faut que ton "let st = ..." soit lui-même dans un let.
Ça marchait avec let main () = , mais t'es pas obligé de faire ça, tu peux te contenter d'un "let _ =", qui veut dire « calcule-moi la valeur pour les effets de bord mais je me fous du résultat ».

j'ai fait ça et ça marche
let _ =
begin
let st = (Pile.create()) in
try
Pile.empiler st "UN";
Pile.empiler st "DEUX";
Pile.empiler st "TROIS";
Pile.empiler st "QUATRE";
print_string (Pile.depiler st);
print_string (Pile.depiler st);
print_string (Pile.depiler st);
print_string (Pile.depiler st);
print_string (Pile.depiler st);
with
Pile.Vide -> print_string "ça suce";
end
;;

merci!

par contre avec let main()= puis à la fin main()ça marche pas peut etre parce que c'est une évaluation d'expression (?) au 'toplevel'

oui, il faut mettre à la fin "let _ = main ()" et non "main()" tout court
(par contre le begin et le end ne servent à rien, enfin ils gênent pas non plus hein, mais ils sont pas très utiles... et le double point-virgule ne sert à rien non plus (il sert juste dans le mode interactif pour dire au truc que c'est bon t'as fini de taper ^^, mais dans un fichier ben quand il arrive à la fin du fichier il sait que c'est fini ))

merci!
tu peux mexpliquer un peu la fonction de '_ ' en fait je l'utilisait déja pour les matches mais je ne comprends pas tutafé ce que ça fait vraiment
(ou si tu connais par coeur le chapitre du manuel où c'est marque ^^)

ben en fait , si tu veux évaluer l'expression expr, uniquement pour les effets de cette évaluation et pas pour le résultat (typiquement expr renvoie un résultat de type unit), plutôt que d'écrire "let a = expr", qui crée une variable inutile a, tu écris "let _ = expr", qui jette explicitement la valeur à la poubelle et ne crée pas de variable.

ok, merci,
je crois comprendre ce que fait vraiment le match xxx with _ maintenant
en fait ça bouffe la valeur sans lui donner de nom (sans instancier un valeur pour rien quoi) de la même façon que let _ = main () bouffe le résultat de main
mes profs m'avaient sorti que c'était une sorte de when others du Ada ou du default du C mais en fait ça n'a à peu près rien à voir

j'aime de plus en plus ce langage , il est presque aussi bien que le C, mais il est pas facile à prendre en main quand on est un addict de l'impératif

!slap BakaSama
• Vark slaps BakaSama around a bit with a large trout !


Comment oses-tu comparer cet immonde chose qu'est le caml avec un langage aussi parfait, beau et magnifique que le C !!!!!

-aml+aml

(-aml)°(+aml)=Id

Alors
->aml->

Vark :
!slap BakaSama
• BookeldOr slaps BakaSama around a bit with a large trout !


Comment oses-tu comparer cet immonde chose qu'est le caml avec un langage aussi parfait, beau et magnifique que le C !!!!!

d'où le presque....

et tu as oublié pur, le C estarfait, beau, magnifique et pur


enfin ça dépend du coding aussi, j'ai par exemple dans cette enveloppe un portage de vrally pour ti68k...

BakaSama :
enfin ça dépend du coding aussi, j'ai par exemple dans cette enveloppe un portage de vrally pour ti68k...

ah tiens donc

Je poste là, c'est vil, mais c'est juste pour que ça apparaisse dans les sujets des gens
J'aimerais savoir comment je pourrais faire pour implémenter en caml un type qui ressemblerait à des listes chainées, mais en gardant toujours un pointeur vers la fin de liste, pour pouvoir aggrandir la liste par la queue en O(1).

tu te mets au C

type 'a item = NàC | ELEM of 'a * item * item
type 'a liste_chainée_doublement_avec_ajout_en_queue_en_O_1_phear = {mutable start:'a item;mutable end:'a item;}

nope ?

Mais on est obligé de la faire doublement chaînée ? C'est dommage ça.

Ben le problème c'est que garder un pointeur sur seulement la fin ça ne te permet pas d'ajouter en queue en O(1) avec une liste chaînée « normale », il faut faire un truc mutable (sinon t'es de toute manière obligé de reconstruire ta liste intégralement...)
bon j'ai une proposition vite fait mal fait un peu pourrie (non, totalement pourrie en fait) :

type 'a mutable_liste = {head : 'a; mutable tail : 'a mutable_liste option}
type 'a liste_avec_fin = {contenu : 'a mutable_liste; fin : 'a mutable_liste}
type 'a liste_speciale = 'a liste_avec_fin option
let liste_vide = None
let ajout_en_tete debut suite =
  let contenu = {head = debut; tail = match suite with Some liste -> Some liste.contenu | None -> None} in
  let fin = match suite with Some liste -> liste.fin | None -> contenu in
  Some {contenu = contenu; fin = fin}
let ajout_en_queue liste queue = (* attention cette fonction modifie son argument #sick# *)
  let fin = {head = queue; tail = None} in
  let contenu = match liste with Some liste -> liste.fin.tail <- Some fin; liste.contenu | None -> fin in
  Some {contenu = contenu; fin = fin}

Bon c'est vraiment très crade je cherche un truc mieux

"Some liste -> liste.fin.tail <- Some fin;"
Hmm, ça ressemble aux trucs que tu critiques en C avec les priorités ^^

Y a un problème de priorité là ?
(je comprends pas trop de quoi tu parles, certes ma fonction est très crade mais je ne comprends pas cette critique précise...)