Discussion :

[Soshius]

Bonjour a tous, j'ai apparemment un probleme de typage ici mais je ne trouve pas du tout ou il peut etre et je ne comprend pas ce qui "merde"...

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
 
let rec appartienVu
(fileVu: ('a * 'b * int) list)
(etat: ('b * ('a * int))) =
  match fileVu with
  |[] -> false
  |a::reste -> if (a=((fst(snd(etat))),(fst(etat)),(snd(snd(etat))) )) then true else appartienVu reste etat;;
 
let rec insererFileAttenteSSB 
(opPossEtat: ('b*('a*int)) list) 
(fileAttente: ('b * ('a * int)) list)
(fileVu: ('a*'b*int) list) = 
  match opPossEtat with
  [] -> fileAttente
  |a::reste -> if (appartienVu fileVu a)
      then (insererFileAttenteSSB reste fileAttente fileVu)::fileAttente
      else a::(insererFileAttenteSSB reste fileAttente fileVu)::fileAttente;;

l'erreur est la suivante :

Code :

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

1
2
3
4
5
6
7
8
 
#  ..match opPossEtat with
    [] -> fileAttente
    |a::reste -> if (appartienVu fileVu a)
        then (insererFileAttenteSSB reste fileAttente fileVu)::fileAttente
        else a::(insererFileAttenteSSB reste fileAttente fileVu)::fileAttente..
Error: This expression has type ('a * ('b * int)) list
       but an expression was expected of type 'a * ('b * int)

[Ptival]

Le constructeur de listes :: a pour type :
'a -> 'a list -> 'a list

Aux lignes 15 et 16 de ton exemple, tu essaies de placer une liste en tête d'une liste, alors que tu ne peux placer qu'un élément.

Tu cherches plutôt un opérateur de concaténation ^, qui a pour type :
'a list -> 'a list -> 'a list

Ceci étant, ton code est aussi assez maladroit pour plusieurs raisons :
- plutôt que d'utiliser fst, snd, tu devrais pouvoir obtenir les éléments contenus dans etat par un filtrage par motif avec un motif come (x, (y, z))
- pourquoi ne pas avoir seulement des ('a * 'b * int) ? Quel est l'intérêt de la forme ('b * ('a * int)) ?
- plutôt que d'écrire :

Code :

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

if cond then true else quelquechose

tu peux écrire :

Code :

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

cond or quelquechose

- plutôt que de réécrire les types cinquante fois, utilise des abréviations :

Code :

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

type etat == ('a * 'b * int)

voire un type algébrique, éventuellement sous formes d'enregistrements :

Code :

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

type 'a 'b etat == { nom_de_a : 'a ; nom_de_b : 'b ; nom_de_i : int }

Enfin, je ne suis pas certain de ce que tu souhaites faire, mais un schéma de récursivité explicite avec une concaténation sur le retour de l'appel récursif n'est pas forcément ce que tu souhaites (peu efficace, est-ce vraiment nécessaire à ton but ?)

[gasche]

Ptival > ton propos d'ensemble est tout à fait exact, mais quelques petits détails de syntaxe:

- l'opération de concaténation est (@), pas (^) (ça c'est pour les chaînes de caractères): `foo @ bar`
- `or` est sans doute encore valide mais déprécié, il vaut mieux utiliser `||` et `&&` (puisque `and` veut dire autre chose, c'est moins symétrique)
- les abréviations de type ne prennent `==` plutôt que `=` qu'en Caml Light. Pour les définitions d'un nouveau type de donnée (type algébrique ou enregistrement) comme dans ton deuxième exemple c'est toujours `=`. Pour savoir si c'est `==` ou `=` pour les abbréviations il faut savoir s'il utilise Caml Light ou OCaml (Objective Caml).
- la syntaxe des définitions de types paramétrés est "non curryfiée": `type ('a, 'b) foo = ...` plutôt que `type 'a 'b foo = ...` (on peut enlever les parenthèses quand il n'y a qu'un seul paramètre).

Par ailleurs, en plus de tes conseils sur la programmation sur lequel tu as tout à fait raison, on peut repérer que ses deux fonctions sont en fait des reformulations de fonctions bien connues qui sont déjà présentes dans la bibliothèque standard: il s'agit d'une fonction type `mem`, qui te l'appartenance (member) à une liste, et, si j'ai bien compris, d'une fonction de type `filter` qui conserve seulement les éléments vérifiant un prédicat. En Caml Light, seul `mem` existe, en OCaml c'est `List.mem` et `List.filter`.

Ceci dit, si Soshius est motivé pour apprendre à coder correctement, il vaut effectivement mieux corriger un par un les défauts de son code (la manipulation des couples comme tu le dis, et l'affreuse complexité quadratique liée à la concaténation systématique dans insererFileAttenteSSB) que réécrire en deux lignes avec des fonctions standard sans rien dire.

Enfin, en Caml la norme est d'utiliser la notation par mots séparés avec des underscore, inserer_file_attente_SSB. C'est un détail, mais ça donne moins l'impression de s'arracher les yeux à lire du Java.

[Ptival]

Oui désolé pour la syntaxe Caml, je ne la connais malheureusement pas beaucoup (j'ai fait des recherches Google pour trouver, mais je pouvais tomber sur de la doc obsolète ou mélanger du Caml light/lourd/OCaml). Merci pour les précisions.

Et pour mem et filter, c'est bien ce que je voulais dire quand je disais vouloir éviter des schémas de récursivité explicites.
Généralement, quelqu'un a déjà écrit ces choses pour nous, à moins de faire des choses très précises sur des types de données customisés.

Et donc effectivement, pour le point de vue pédagogique il serait bon de savoir écrire ces fonctions correctement, ou d'aborder un meilleur design des données manipulées. Ensuite, il faudra effectivement passer à l'ordre supérieur !