(*****************************************************************************) (*****************************************************************************) (* servez-vous du manuel de référence ocaml disponible à l'url: http://caml.inria.fr/distrib/ocaml-4.02/ocaml-4.02-refman.txt *) (* On désire fabriquer une table associant des nombres à virgules flottantes à des chaînes de caractères. On codera une telle table à l'aide d'une liste de couples (chaine, nombre). Il nous faudra également une fonction de recherche et une fonction d'insertion. *) type str2float_tbl = (string * float) list;; let insert tbl str x = (str,x)::tbl;; (* Q1 : commentez le type de la fonction insert, en particulier celui du paramètre tbl; modifiez sa definition de telle sorte que son type soit str2float_tbl -> string -> float -> str2float_tbl; a-t-on besoin de specifier le type des parametres str et x ? *) (* Q2 : écrire la fonction de recherche 'search' dont le type doit être search : str2float_tbl -> string -> float option voir documentation pour le type 'option'. *) (* par exemple, (search [("x", 1.1) ; ("y", 1.3)] "y") doit retourner (Some 1.3) *) (* Q3: le type option offre un moyen d'écrire proprement des fonctions partielles, le mécanisme des exceptions en est un autre (voir documentation), utilisez ce dernier pour ecrire une nouvelle version de la fonction search, cette fois-ci de type search : str2float_tbl -> string -> float *) (* attention, c'est un peu subtil, cette fois (search [("x", 1.1) ; ("y", 1.3)] "y") doit retourner 1.3 et non (Some 1.3) ! *) (* Un autre concept fondamental est celui de type inductif. Il permet à l'utilisateur de définir de nouveaux types comme union de types. L'exemple suivant définit un nouveau type (recursif) qui code les expressions arithmétiques: *) type expr = Const of float | Var of string | Sum of expr * expr | Diff of expr * expr | Prod of expr * expr | Quot of expr * expr (* par exemple l'expression "3x + 2" sera codée par (Sum (Prod (Const 3.0, Var "x"), Const 2.0)) *) (* Q4: définir un élément de type expr qui code l'expression 2x + 4y + 1 *) (* Q5 : écrire une fonction qui transforme une expression en une chaine de caractère lisible *) (* Q6: que fait la fonction suivante (on utilise ici la dernière version de search) ? *) let rec eval tbl e = match e with Const x -> x | Var id -> search tbl id | Sum (e1,e2) -> (eval tbl e1) +. (eval tbl e2) | Diff (e1,e2) -> (eval tbl e1) -. (eval tbl e2) (* Q7: Commentez le warning emis par l'interpreteur, essayez cette fonction avec l'expression definie précédemment. Corrigez le code de eval pour eliminer le warning en question *) (* Q8: ecrire une fonction qui calcule l'expression de la dérivée d'une expression de type expr relativement à une variable dont l'identifiant sera donné par une chaine de caractère. Attention, son type sera string -> expr -> expr (la fonction aura deux arguments, l'identifiant de la variable par rapport à laquelle on dérive et l'expression à dériver *) (* Q9: écrire une fonction qui simplifie une expression. Par exemple, la dérivée de l'expression donnée en Q4 par rapport à x devrait être simplifiée en "Const 2.0" ... *) (*****************************************************************************) (*****************************************************************************)