Programmation fonctionnelle

De
Publié par

  • cours - matière potentielle : cours
Programmation fonctionnelle Notes de cours Cours 5 19 Octobre 2011 Sylvain Conchon 1/24
  • change assoc
  • sequence de lettres menant de la racine de l'arbre
  • association liee
  • int
  • exception
  • exceptions
  • lettres
Publié le : mardi 27 mars 2012
Lecture(s) : 30
Source : lri.fr
Nombre de pages : 21
Voir plus Voir moins

Programmation fonctionnelle
Notes de cours
Cours 5
19 Octobre 2011
Sylvain Conchon
sylvain.conchon@lri.fr
1/24Le programme de cette semaine
Le mode T9 des t´el´ephones portables
2/24Les notions abord´ees avec ce programme
I Exceptions
I Dictionnaires
I Arbres de pr´efixes
3/24Les exceptions
# 1 / 0;;
Exception : Division by zero.
# let x = [| 1 |];;
val x : int array = [| 1 |];;
# x.(1);;
Exception : Invalid argument "index out of bounds".
# int of string "bonjour";;
Exception : Failure "int of string".
I Le m´ecanisme d’exception permet de g´erer le probl`eme des
fonctions partielles : une exception est lev´ee si aucune valeur
ne peut ˆetre renvoy´ee par la fonction.
I Si l’exception n’est pas rattrap´ee (voir ci-apr`es), le programme
se termine.
4/24Les exceptions : d´eclaration et typage
# exception Fin;; Fin
# raise Fin; print int 10;;
Exception : Fin.
# exception E of int;; E of int
# let f x = if x = 0 then raise (E(x)) else 10 / x;;
val f : int -> int = <fun>
# f 0;;
Exception : E(0)
I Une exception est d´efinie `a l’aide du mot-cl´e exception.
I Comme pour les constructeurs, elle commence par une
majuscule et elle peut attendre des arguments.
I On l`eve une exception `a l’aide de la fonction raise.
I Ce m´ecanisme est transparent au typage.
5/24Les exceptions : rattrapage
# let f x = if x = 10 then raise (E(10)) else 10 / x;;
# try f 0 with
| Division by zero -> 0
| E x -> x;;
- : int = 0
I Une exception peut ˆetre rattrap´ee `a l’aide de la construction
try-with qui permet de d´efinir des gestionnaires
d’exceptions.
I Comme pour un pattern-matching, un gestionnaire permet de
r´ecup´erer les arguments associ´es aux exceptions.
6/24Dictionnaires
Un dictionnaire est une structure de donn´ees qui permet d’associer
des clefs (de type ’a) `a des valeurs (de type ’b).
La mani`ere la plus simple de r´ealiser un dictionnaire est d’utiliser
une liste de paires (’a * ’b) list.
La biblioth`eque OCaml fournit un certain nombre de fonctions
permettant de manipuler de tels dictionnaires. En particulier,
I la fonction List.assoc renvoie la valeur associ´ee `a une clef
(elle l`eve l’exception Not found si aucune valeur n’est
associ´ee)
’a -> (’a * ’b) list -> ’b
I la fonction List.remove assoc supprime la premi`ere
association li´ee `a une clef
’a -> (’a * ’b) list -> (’a * ’b) list
7/24Dictionnaires : changement d’association
Pour changer l’association li´ee `a une clef dans un dictionnaire, on
d´efinit la fonction change assoc de type
’a -> ’b -> (’a * ’b) list -> (’a * ’b) list
de sorte que change assoc i v l change l’association li´ee `a i
dans la liste l par le couple (i, v)
let rec change assoc i v l =
match l with
| [] -> [ (i, v) ]
| (x, )::l when x=i -> (i, v)::l
| z::l -> z::(change assoc i v l)
8/24Les arbres de pr´efixes
Structure de donn´ees pour repr´esenter des ensembles de « mots».
Par mots, il faut comprendre toute valeur ocaml pouvant ˆetre
d´ecompos´ee comme une suite de « lettres» :
I les valeurs de type string sont des mots dont les lettres sont
de type char
I les entiers de type int sont ´egalement des mots dont les
lettres peuvent ˆetre simplement les chiffres 0 et 1
I etc.
9/24D´ecomposition
On utilise cette d´ecomposition en lettres pour repr´esenter des
ensembles de mots de la mani`ere suivante :
I chaque branche est ´etiquet´ee par une lettre
I chaque nœud contient un bool´een qui indique si la s´equence
de lettres menant de la racine de l’arbre `a ce nœud est un mot
appartenant `a l’ensemble
10/24

Soyez le premier à déposer un commentaire !

17/1000 caractères maximum.