Discussion :

[neo666]

Bonjour

je voudrais savoir s'il existe une fonction qui transforme une chaine de caractere en liste
par exemple si j'ai "[1;2]" j'aimerai avoir [1;2]

merci d'avance

[InOCamlWeTrust]

Non, mais tu peux le faire toi-même.

Pourquoi veux-tu faire une fonction aussi tordue et compliquée ?

[neo666]

mon programme contient une interface MSDOS avec l'utilisateur.

supposons que l'on veuille calculer la longueur d'une liste donnée par l'utilisateur
Par exemple l'utilisateur entre la liste [1;2], le probleme c'est que le programme considere [1;2] comme une chaine de caractere et non pas une liste.

C'est pourquoi j'ai besoin de transformer ma chaine de caractere en liste

[Jedai]

Généralement, sauf si tu es un sadique, tu demanderas plutôt à ton utilisateur de t'écrire une liste sous la forme "1, 2" ou même "1 2", nettement plus facile à écrire (et accessoirement à parser).
Si tu utilisais Haskell il te suffirait d'utiliser la fonction "read" mais puisque tu es sous OCaml, je pense qu'il va falloir écrire toi-même le découpage de la string en liste de string et ensuite utiliser "List.map int_of_string" ou quelque chose comme ça.

--
Jedaï

[neo666]

pour etre plus precis je manipule une liste d'un type que j'ai defini : le type formule qui se de decompose ainsi

type formule = Arrobase of int*formule | P of string | Et of formule*formule | ... ;;

donc si l'utilisateur entre "Arrobase(1,Et(P("p"),P("q")))" j'aimerai avoir [Arrobase(1,Et(P("p"),P("q")))]

[SpiceGuid]

C'est un cas typique de l'utilisation du module Lex.
La source du module: ici.
L'explication détaillée de son utilisation: là.

Voici à quoi ressemblerait le code pour parser une liste d'entiers (avec détection et rapport d'erreur) :

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
let lex = Lex.make stdin

in let read_until l =
  let a = Lex.demand_int() in
  if Lex.granted_mono ';' then read_until (a::l) 
  else a::l

in let read_list () =  
  try
    Lex.demand_mono '[';
    let result = read_until [] in
    Lex.demand_poly "];;";
    List.rev result
  with
  | Lex.Demand_denied(position,demand) ->
      Lex.print_position position;
      Lex.print_denied demand;

in read ()

Je suis certain que tu trouveras au chapitre VII assez d'explications pour étendre le code ci-dessus à l'analyseur que tu souhaites

[NokyDaOne]

pour etre plus precis je manipule une liste d'un type que j'ai defini : le type formule qui se de decompose ainsi

type formule = Arrobase of int*formule | P of string | Et of formule*formule | ... ;;

donc si l'utilisateur entre "Arrobase(1,Et(P("p"),P("q")))" j'aimerai avoir [Arrobase(1,Et(P("p"),P("q")))]

Pourquoi si tu programmes en OCaml ne pas demander plutôt une string du type :
"Arrobase 1 (Et (P "p") (P "q"))"

et apès tu pourrais trouver ton bonheur avec OCamlLex et OCamlYacc

[gasche]

Pourquoi ne pas tout simplement lui demander d'utiliser le toplevel ?

[alex_pi]

Pourquoi ne pas tout simplement lui demander d'utiliser le toplevel ?

Soit tu veux faire une interface agreable ou l'utilisateur peut taper 1@P("p") & Q("q") auquel cas tu n as pas d'autre choix que de passer par un lexeur/parseur (a la main ou avec les outils tout fait, c est au choix), soit tu veux qu'il le tappe directement avec la syntaxe du top level, auquel cas autant utiliser directement le sus dit top level comme le suggeste bluestorm.

[InOCamlWeTrust]

Moi je propose, pour commencer, ça (non essayé).

Code :

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

1
2
3
4
5
6
7
 
let rec int_list_of_input () =
    try
        (read_int ()) :: (int_list_of_input ())
    with
        (* Verifier la syntaxe de Invalid_argument... j'm'en souviens pus ! *)
        | Invalid_argument _ -> []

Tu entres ceci dans la console...

Code :

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

1
2
3
4
5
 
> int_list_of_input ()
3
666
7

Et je pense que tu devrais avoir ceci...

Code :

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

1
2
 
int list - [3; 666; 7]

[neo666]

hello

désolé de répondre si tard mais j'ai eu un week end assez chargé.
merci pour toute vos reponses.

Vous suggeger d'utiliser le top level, mais comment faire exactement ?

[InOCamlWeTrust]

Est-ce que tu as compris les codes que l'on t'a donnés ?

Si ton programme contient une interface MS DOS, ou autre, mieux vaut demander à ton utilisateur d'entrer les nombres un à un, et non sous forme de liste. En effet, quel intérêt, pour l'utilisateur, de devoir écrire des crochets et des point-virgule quand on peut tout aussi bien les entrer un à un, l'un après l'autre ? De plus, écrire des crochets, des point-virgule, etc... t'oblige à devoir faire un travail de parsing plus délicat.

Essaye la petite fonction que je t'ai proposée dans le dernier message, puis adapte-la à ton cas. Ca peut être un début. Je ne pense pas qu'il existe de code plus court/simple pour récupérer une liste de nombres (peut-être avec Genlex, mais bon !).

[neo666]

je vais tester ton programme

sauf que dans mon programme , je ne manipule pas une liste d'enteir mais une liste d'un type que j'ai défini

en tout cas je vais tester ton code, ca m'aidera peut etre

[gorgonite]

Je pense que le probleme est que tu ne fais pas de distinction entre la sintaxe abstraite et la syntaxe concrete. Je m'explique : Si j'ai bien compris, tu veux definir un mini langage et faire des choses dessus. Ce que tu nous donnes la est la syntaxe abstraite de ton mini-langage, celle qui est ensuite manipulee en interne par ton interpreteur. C'est assez classiquement une structure d'arbre, la dessus, rien a redire.
En revanche, il semble que tu n'as pas encore defini de syntaxe concrete pour ton langage, c'est a dire une syntaxe utilisable par un utilisateur. Imagine si pour ecrire un programme Caml, tu devais taper

Code :

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

Def_fun_rec("fact", "n", If_statement( Less(Var "n", Int 1), Int 1, Fun_call(Var "fact" ,sub(Var "n", Int 1))))

Ca ferait rapidement mal a la tete non? Donc de la meme facon, si tu veux que ton minilangage soit utilisable, il faut que tu lui donnes une syntaxe concrete.
Par exemple :

Code :

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

"salut" -> <3 @ [P(hop) & V(paf)] >

(Je ne connais pas le but de ton langage, donc je ne sais pas si c est une syntaxe appropriee.)
Et ensuite, il te faudra ecrire un lexeur/parseur (soit a la main, soit avec des outils plus puissant) pour passer de la syntaxe concrete a la syntaxe abstraite. Tu pourras alors manipuler tes programmes a soit.

Est ce vaguement plus clair ?

[InOCamlWeTrust]

Tiens, voici un exemple qui fait déjà ce que tu veux, et qui ne coûte vraiment pas cher en termes de lignes de code !

Tu peux t'en servir pour compléter ton modèle. Le travail à fournir est très automatique, comme tu peux le voir : il suffit de descendre l'arbre du type des formules et de créer, pour chaque nouveau constructeur/type, la fonction de lecture associée.

Les fonctions read_integer () et read_string () sont juste là pour envelopper les appels à read_int () et read_line () de la librairie standard : elles sont, bien-sûr, interchangeables.

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
25
26
27
28
 
(* Formules *)
type formule =
  | Arrobase of int * formule
  | Et of formule * formule 
  | P of string
 
(* Lit une formule *)
let rec read_formule () =
  print_endline "Veuillez entrer une formule";
  match read_line () with
    | "Arrobase" -> Arrobase (read_integer (), read_formule ())
    | "Et" -> Et (read_formule (), read_formule ())
    | "P" -> P (read_string ())
    | _ -> failwith "Formule inconnue"
 
(* Lit un entier ; peut être remplacé par read_int () *)
and read_integer () =
  print_endline "Veuillez entrer un entier";
  try
    read_int ()
  with
    | Failure "int_of_string" -> failwith "Entier incorrect"
 
(* Lit une chaîne de caractères ; peut être remplacé par read_line () *)
and read_string () =
  print_endline "Veuillez entrer une chaîne de caractères";
  read_line ()

[neo666]

merci de ta reponse

j'ai tapé ton code et ca compile bien
cependant j'ai encore un petit soucis :
lorsque je demande a l'utilisateur d'entrer une formule, par exemple il tape al formule suivante : Arrobase(N(1),P(p))
ca me renvoie "Formule inconnue"

[InOCamlWeTrust]

Tu n'as rien compris au code alors.

L'utilisateur doit entrer (les "<-" expriment les appuis sur la touche Enter)

Code :

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

1
2
3
4
5
6
 
Arrobase<-
N<-
1<-
P<-
p<-

C'est un tout petit code qui permettra à l'utilisateur d'interagir avec le programme.

[neo666]

C'est bon,mon probleme a l'air d'etre résolu
En tout cas ça fait ce que je veux

Merci beaucoup pour votre aide et vos conseils

cordialement

neo666