Discussion :

[cladsam]

Bonjour,

mon soucis est le suivant : j'ai une liste d'int, je veux récupérér une liste de triplets de valeurs. par exemple, si j'ai la liste :
[1;2;3;4;5;6] je voudrais obtenir :

[(1,2,3);(4,5,6)].

je prends la tete avec cette connerie et je ne m'en sort pas du tout .
j'ai essayer ces pistes :

Code :

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

1
2
3
4
5
6
7
8
 
 let rec list_to_point list = 
       let convert a = match a with 
     [x;y;z]->(x,y,z)
      | _ -> (0,0,0) in
    match list with
       | x::fin -> convert x :: list_to_point fin
       | []     -> [];;

j'ai fait tout plein de tests de ce genre dans tous les sens mais jamais il ne passe de int list a int*int*int list , est-ce que vous pourriez m'expliquer ce que je fais mal s'i vous plait ?

[Strab]

Bonjour,

Un petit détail pour commencer, ta fonction convert ne dépend pas de list, inutile donc de la définir à l'intérieur de list_to_point, sinon est elle est reconstruite à chaque fois.

Le problème est que tu définis convert comme prenant une liste, et ensuite tu appelles convert avec une tête de liste, le compilateur en déduit donc que list est une liste de listes.

Tu veux plutôt quelque chose comme :

Code :

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

1
2
3
4
5
 
let rec list_to_point list = match list with
  | x::y::z::reste -> (x,y,z)::(list_to_point reste)
  | _ -> []
;;

J'ai pas essayé.

[cladsam]

Bonjour,

Un petit détail pour commencer, ta fonction convert ne dépend pas de list, inutile donc de la définir à l'intérieur de list_to_point, sinon est elle est reconstruite à chaque fois.

Le problème est que tu définis convert comme prenant une liste, et ensuite tu appelles convert avec une tête de liste, le compilateur en déduit donc que list est une liste de listes.

Tu veux plutôt quelque chose comme :

Code :

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

1
2
3
4
5
 
let rec list_to_point list = match list with
  | x::y::z::reste -> (x,y,z)::(list_to_point reste)
  | _ -> []
;;

J'ai pas essayé.

merci mon bon seigneur, ce que tu proposes la, c'est ce que je CROYAIS avori essayé en tout premier, ce qui em paraissait le plus logique et le plus simple.
Cependant, ca n'avait pas marché j'obtenais du 'a list -> 'a liste .. et pour cause j'avais mis des ; a la place des ,

MERCI beaucoup infirniment !!!!

[InOCamlWeTrust]

Code :

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

1
2
3
4
5
6
7
8
 
 let rec list_to_point list = 
       let convert a = match a with 
     [x;y;z]->(x,y,z)
      | _ -> (0,0,0) in
    match list with
       | x::fin -> convert x :: list_to_point fin
       | []     -> [];;

Tu fais ce que tu veux mais par expérience je te conseille de bien parenthèser et présenter ton code :

Code :

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

1
2
3
4
5
6
7
8
9
 
let rec list_to_point list = 
  let convert a = match a with 
    | x :: y :: z :: [] -> (x, y, z)
    | _ -> (0,0,0) in
 
  match list with
    | x :: fin -> (convert x) :: (list_to_point fin)
    | [] -> []

[cladsam]

Tu fais ce que tu veux mais par expérience je te conseille de bien parenthèser et présenter ton code :

Code :

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

1
2
3
4
5
6
7
8
9
 
let rec list_to_point list = 
  let convert a = match a with 
    | x :: y :: z :: [] -> (x, y, z)
    | _ -> (0,0,0) in
 
  match list with
    | x :: fin -> (convert x) :: (list_to_point fin)
    | [] -> []

tu as entièrement raison en plus d'êtr evite illisible ca provoque parfois des effets bizarres lorsque comme moi tu ne maitrises pas bien les priorités d'évaluation du langage du genre :
SOit F1 une fonction qui prend 1 argument de type A
Soit F2 une fonction qui prend 1 argument de type B et renvoit un type A
Soit V une valeur de type C, parfois,

F1 F2 V provoque un "fonction called with too many arguments sur F1" ce qui n'arrive jamais avec
F1 (F2 V)

[Jedai]

parfois,
F1 F2 V provoque un "fonction called with too many arguments sur F1" ce qui n'arrive jamais avec
F1 (F2 V)

Si F1 est une fonction de type * -> *, on ne parle pas de "parfois", mais de "toujours". En Haskell remarque tu peux écrire ça comme ça :

Code :

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

F1 $ F2 V

Où $ est un opérateur infixe d'application, mais qui a une priorité moindre que l'application de fonction, ce qui évite donc d'avoir à mettre plein de parenthèses. Parfois il ressemble presque à un "pipe inversé" sur certaines lignes où il est présent à répétition. J'aime assez personnellement, ça évite l'embrouillamini de parenthèses, et c'est très lisible.

--
Jedaï

[InOCamlWeTrust]

Je sais que je me répète, mais je veux marteller cette idée : la syntaxe Caml est beaucoup trop conflictuelle comme pour pouvoir écrire les choses légèrement... à celà s'ajoute le fait que l'analyse syntaxique est du type LaLR, ce qui peut provoquer des résultats surprenants (du genre on te dit que l'erreur est à la ligne 150 alors que le problème provient de la ligne 12... ça m'est déjà arrivé, et j'ai failli perdre tous mes cheveux !).

Le parser Objective Caml contient, je crois de mémoire, une soixantaine de conflits, dont trente Shift-Reduce et trente Reduce-Reduce... et pour Caml Light, c'est pire ! Seule la personne qui a écrit le parser (c'est-à-dire Xavier Leroy) peut utiliser une syntaxe allègée... et les autres de la Caml Team, aussi...

Si tu veux voir comment pouvoir écrire du Caml léger, tu peux utiliser Camlp4 : il suffit que tu prennes un de tes fichiers, n'importe lequel, et que tu fasses, de mémoire...

Code :

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

1
2
 
camlp4 pa_o.cmo pr_o.cmo fichier.ml