Programmation fonctionnelle Prog rammation Prog

U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 1
XU - ensiie - Prog. fonctionnelle 2011/2012
x
λx.M
β
−
→
induction/récurrence
capture tout programme
(M1 M2 )
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 3
� Preuve de correction aisée et naturelle
Bonus modèle formel : λ-calcul
Programmation similaire à raisonnement mathématique (modulo scories)
(pourquoi �= comment)
� Abstraction, programmation de haut niveau
(JAMAIS de modification)
(expressions, fonctions de première classe)
• Persistance
� Simplification du code et donc correction
� Efficacité (undo gratuit)
• Tout est valeur
Aspects principaux ici :
Programmation fonctionnelle
XU - ensiie - Prog. fonctionnelle 2011/2012
2011/2012
Xavier Urbain
Programmation fonctionnelle
XU - ensiie - Prog. fonctionnelle 2011/2012
100% pur jus ?
Pénible ?
Utilisé ?
Efficace ?
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 4
Troll bashing
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 2
Programmation fonctionnelle
XU - ensiie - Prog. fonctionnelle 2011/2012
Travaux dirigés : aspects théoriques, intérêt
Machines : manipulation, mise en œuvre
• Outils (itérateurs, constructions, etc.)
• Structure de donnée
Chaque partie :
Débroussaillage (1 ou 2 cours)
Futé : Problème � bonne structure � langage adapté
Troll : impératif ! fonctionnel !
Programmation. . .
arguments toujours évalués en premier
les types sont nos amis !
ici : noyau fonctionnel et exceptions
• Le langage Caml
• Purely Functional Data Structures
SML !
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 7
• Cambridge University Press
XU - ensiie - Prog. fonctionnelle 2011/2012
• Dunod
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 8
• Leroy, Weis
Camllight !
• http://www.pps.jussieu.fr/Livres/
ora/DA-OCAML/
• Okasaki
• Cousineau, Mauny
• Chailloux, Manoury, Pagano
• Édiscience/Dunod
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 6
• O’Reilly
Biblio
XU - ensiie - Prog. fonctionnelle 2011/2012
mais on va quand-même apprendre la syntaxe
UN COURS D ’O CAML
• Approche fonctionnelle de la programmation
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 5
COURS
N’EST PAS
CE
• Développement d’applications avec OCaml
XU - ensiie - Prog. fonctionnelle 2011/2012
Biblio
XU - ensiie - Prog. fonctionnelle 2011/2012
Persistance =⇒ gestion mémoire efficace, très complexe, cachée
• Boucle d’interaction � pratique
• Interprété � vers bytecode, générique
• Compilé � vers natif, efficace
• Évaluation stricte
• Fortement typé
langages
développé à l’INRIA http://caml.inria.fr
• Fonctionnel + traits impératifs
O CAML
Haskell, Scheme, Lisp, ML, Erlang, Gallina. . .
Programmation fonctionnelle
···
0000000000000000000000010110111101000101010000111
···
0000000000000000000000010110111101000101010000111
···
XU - ensiie - Prog. fonctionnelle 2011/2012
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 11
XU - ensiie - Prog. fonctionnelle 2011/2012
Segmentation ?
intuition
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 12
0010101011011111001101010000 ?
1000010101000101010101101000010111100010101000101
1000010101000101010101101000010111100010101000101
0010101011011111001101010000 ?
0010101011011111100010101000101111100011010100101
···
intuition
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 10
0010101011011111100010101000101111100011010100101
En gros :
Mémoire. . .
XU - ensiie - Prog. fonctionnelle 2011/2012
···
0000000000000000000000010110111101000101010000111
1000010101000101010101101000010111100010101000101
0010101011011111100010101000101111100011010100101
1101010100010111100101010110111110011010100001110
En gros :
Mémoire. . .
1101010100010111100101010110111110011010100001110
···
intuition
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 9
exploration
1101010100010111100101010110111110011010100001110
En gros :
Mémoire. . .
XU - ensiie - Prog. fonctionnelle 2011/2012
Arithmétique. . .
Comparaisons, opérations logiques. . .
Valeurs basiques. . .
Séparateur (expr) ;;
• Déclarations → noms
• Expressions → valeurs
Programme = suite finie
Noyau fonctionnel
;;
XU - ensiie - Prog. fonctionnelle 2011/2012
condition
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 15
Remarque : branchement �= fonction logique
if (2.718 > 3.141) then 666 else 42 ;;
Égal à value1 si c vaut true
Égal à value2 si c vaut false
XU - ensiie - Prog. fonctionnelle 2011/2012
• Pas de conversion implicite
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 16
– Mêmes types pour comparaisons, etc.
– Mêmes types des deux côtés dans branchement
• Bon typage nécessaire :
• Manipulation d’expressions (tout au même niveau)
3 + (if 42 <= 666 then 1 else -272) ;;
expressions
Type de c bool et même type pour value1 et value2
Encore des expressions !
Noyau fonctionnel
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 14
then true else false ;;
XU - ensiie - Prog. fonctionnelle 2011/2012
condition
(* vaut 42 *)
expressions
(0x2ff_df_aa = 50_323_370) or (3 < 666) ;;
(* vaut 42 *)
expressions
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 13
(ni segfault)
if
Remarque : branchement �= fonction logique
if (2.718 > 3.141) then 666 else 42 ;;
Égal à value1 si c vaut true
Égal à value2 si c vaut false
Type de c bool et même type pour value1 et value2
if c then value1 else value2
Branchement
Noyau fonctionnel
if c then value1 else value2
Branchement
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
sur même type
typées
exploration
sur même type, sans implicite
Fortement typé : jamais de problèmes de confusion
Arithmétique. . .
Comparaisons, opérations logiques. . .
Valeurs basiques. . .
Séparateur (expr) ;;
• Déclarations → noms
• Expressions → valeurs
Programme = suite finie
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
portée
{(toto,42),. . . }
{(titi,666),(toto,42),. . . }
{(titi,666),(toto,42),. . . }
{(toto,42),. . . }
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 19
Identificateur viable dans expression interne
let titi = 111 * 6 in
titi * 666 * toto
XU - ensiie - Prog. fonctionnelle 2011/2012
ici : capture
let toto = 111 * 6 in
toto * 666 * toto
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 20
{(toto,42),. . . }
{(toto,666),(toto,42),. . . }
{(toto,666),(toto,42),. . . }
{(toto,42),. . . }
let x = e1 in e2
expressions avec déclarations
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 18
portée
{(toto,42),. . . }
{(titi,666),(toto,42),. . . }
{(titi,666),(toto,42),. . . }
{(toto,42),. . . }
let x = e1 in e2
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
Identificateur viable dans expression interne
let titi = 111 * 6 in
titi * 666 * titi
Donner un nom à une expression globalement ou localement
expressions avec déclarations
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 17
{(toto,666),(titi,42),(toto,42),. . . }
{(titi,42),(toto,42),. . . }
{(toto,42),. . . }
Donner un nom à une expression globalement ou localement
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
titi ? � 42
let toto = 666
Identificateur : expression
let titi=toto
let toto = 40 + 2
Jamais modifié car persistance
(* x : nom de la valeur d’expr *)
let x = e1 in e2
expressions avec déclarations
let x = expr
Noyau fonctionnel
Donner un nom à une expression globalement ou localement
déclarations
Donner un nom à une expression globalement ou localement
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
Syntaxe application :
(my_function my_param)
2. Évaluation du corps
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 23
(M N )
λx.M
fonctions
1. Remplacement dans le corps du paramètre par une valeur
Évaluation de l’application :
déclarations
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 21
Un paramètre formel, ici x, un corps M (expression)
Type : si M :β quand x:α alors type de fonction : α → β
fun x -> M
Objet comme les autres
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
let _ = e1 in e2
Donner un nom à une expression ou pas
...
and y = e2 in
let x = e1
Déclarations simultanées
...
let y = e2 in
let x = e1 in
Enchaîner les déclarations
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
fonctions
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 24
let f = fun x -> (fun y -> M1)
Retourner comme valeur. . .
(M N )
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 22
let f = fun x -> (x something)
Prendre en paramètre. . .
let f = fun x -> M
Nommer. . .
Objet comme les autres
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
Syntaxe application :
(my_function my_param)
2. Évaluation du corps
λx.M
fonctions
1. Remplacement dans le corps du paramètre par une valeur
Évaluation de l’application :
Un paramètre formel, ici x, un corps M (expression)
Type : type paramètre → type de la valeur du corps obtenue
fun x -> M
Objet comme les autres
Noyau fonctionnel
(ordre supérieur)
Prendre en paramètre. . .
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 27
� fun y -> 1764 + y * y
f2 42
XU - ensiie - Prog. fonctionnelle 2011/2012
� fun y -> 42 * 42 + y * y
f1 42
Pas équivalentes pour application partielle
let x2 = x * x in fun y -> x2 + y * y
let f2 = fun x ->
XU - ensiie - Prog. fonctionnelle 2011/2012
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 28
� Nommages respectifs de 42, true et "Cooper"
let (t1,t2,t3) = triplet;;
Déstructuration
let triplet = (42,true,"Cooper");;
Types différents, taille fixe
α × (β × γ) → δ �= α × β × γ → δ �= α → β → γ → δ
(,,,,)
t1 et t2 types : t1 × t2 type des couples (x1 , x2 ) avec x1 : t1 et x2 : t2
types produits
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 26
let f1 = fun x -> fun y -> x * x + y * y
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
let f x1 . . . xn = M
Remarque. — Notation équivalente :
Pas que des types de base. . .
fonctions
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 25
(tant que → dans type)
fonctions
� Nouvelles fonctions dépendant de l’environnement à la création
Procédé : clôture
Remarque. — application partielle
(f e1 · · · ek ) avec k < n
Donc de type (au pire) : α1 → · · · → αn → β
let f = fun x1 -> · · · -> fun xn -> M
Noyau fonctionnel
Remarque. — Pas d’évaluation « sous les λ »
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
(α → β) → γ �= α → (β → γ)
Type : α → (β → γ) lorsque M 1 : γ sachant x : α et y : β
let f = fun x -> (fun y -> M 1)
Retourner comme valeur. . .
Type : (α → β) → γ lorsque :
something : α, x : α → β et M : γ sachant ça
M
��
�
�
let f = fun x -> (· · · (x something) · · · )
fonctions
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
i.real;;
Accès : ident•field_name
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 31
let i = { real = 0.0 ; im : 1.0 }
type cplx = { real : float ; im : float };;
XU - ensiie - Prog. fonctionnelle 2011/2012
Motif : constructeurs + variables
| ···
| motif2 -> e2
| motif1 -> e1
match valeur with
Différencier par structure : filtrage
(* Étiquette int *)
(* MAJUSCULE *)
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 32
Filtrer : ∃? remplacement idoine
(* Vus DANS L’ORDRE *)
(* Tout ceci : expression *)
| Ordinaire of int
type rang = | Roi | Dame | Valet
| Carreau | Trèfle
type couleur = | Pique | Coeur
constructeurs
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 30
Types produits avec noms de champs : enregistrements
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
let t2 : quadruplet = 4,3,2,1;;
let t1 = 1,2,3,4;;
Définir la structure d’une valeur.
déclaration de types
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 29
déclarations de types
type quadruplet = int * int * int * int;;
Affirmation : ( ident : type )
Créer ses types. . .
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
• snd : α × β → β
Élément de droite
• fst : α × β → α
Élement de gauche
Déclaration : type t = type
Fonctions d’accès :
Noyau fonctionnel
Créer ses types. . .
types produits
Cas particulier des paires
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
(* Même valeur *)
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 35
| Dame | Valet -> print_string "OK"
| _ -> print_string "OK"
XU - ensiie - Prog. fonctionnelle 2011/2012
Filtrer : ∃? remplacement idoine
constructeurs
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 34
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 36
(* Ordre donc en dernier *)
print_string "Oooh"
| Ordinaire toto ->
| Ordinaire toto ->
print_string "Oooh"
| Roi -> print_string "Wow"
···
match x with
let x =
Motif : constructeurs + variables
Pas de nom de valeur dans motifs
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
| Roi -> print_string "Wow"
···
Filtrer : ∃? remplacement idoine
constructeurs
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 33
match x with
let x =
Motif : constructeurs + variables
Pas de nom de valeur dans motifs
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
| Ordinaire y ->
constructeurs
Filtrer : ∃? remplacement idoine
print_string "Oooh"
| Roi -> print_string "Wow"
print_string "Oooh"
| Ordinaire toto ->
···
| Roi -> print_string "Wow"
let y = 2
let x =
Motif : constructeurs + variables
Pas de nom de valeur dans motifs
Noyau fonctionnel
match x with
···
Filtrer : ∃? remplacement idoine
constructeurs
match x with
let x =
Motif : constructeurs + variables
Pas de nom de valeur dans motifs
Noyau fonctionnel
motif
->
···
XU - ensiie - Prog. fonctionnelle 2011/2012
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 39
Récursion non terminale : empilement non borné de * � risques
n * (fact (n-1))
if n = 0 then 1 else
let rec fact = fun n ->
� (n + 1)! = (n + 1) × v
• Hyp. n! = v
• Cas de base : 0! = 1
Exemple : factorielle
let rec f = · · · f · · ·
récursion
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 37
Fonction récursive : cas de base, hypothèse de récurrence
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
| _ -> · · ·
| C (Coeur, Dame) -> print_string "Qu’on lui coupe la tête !"
match ident with
(* Filtrage *)
(* Déstructuration *)
type carte = C of (couleur * rang)
Structure profonde :
let f = function motifS
let f = fun
récursion
n) (n - 1)
XU - ensiie - Prog. fonctionnelle 2011/2012
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 40
Récursion terminale : jamais d’empilement trop gros
let rec fact = fact_gen 1;;
Cas particulier
fact_gen (acc *
if n = 0 then acc else
let rec fact_gen = fun acc -> fun n ->
� (f a (n + 1)) = (f (a × (n + 1)) n) = a × (n + 1) × n! = a × (n + 1)!
• Hyp. ∀a, (f a n) = a × n!
• Cas de base : ∀a, (f a 0) = a
(* UN CAS PAR *)
(* CONSTRUCTEUR *)
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 38
Propriété plus générale : ∀a, ∀n, (f a n) = a ∗ n!
Exemple : factorielle
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
| Seg x -> · · ·
| Base -> · · ·
match ident with
type tige = Base | Seg of tige
• Construction du suivant
• Cas de base
En général :
Type : description d’un plus petit ensemble clôt par construction
···
inductifs
let f = fun x -> match x with
Noyau fonctionnel
Le constructeur construit. . .
filtrage
Expression donc utilisable partout
Noyau fonctionnel
4
12
24
24
fact_gen
fact_gen
fact_gen
fact_gen
0
1
2
3
4
XU - ensiie - Prog. fonctionnelle 2011/2012
induction
terminal/non terminal
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 41
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 43
Récursion terminale : jamais d’empilement trop gros
24
1
fact_gen
fact 4
Exemple : factorielle
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
Distinction des cas : filtrage
Hypothèse : on sait faire sur un constituant structurel
• Suivant = Constructeur sur hyp. rec.
• Cas de base = constructeurs de base
Noyau fonctionnel
*
*
*
*
4
4
4
4
3
3
3
3
fact 3
*
*
*
*
2
2
2
fact 2
B
XU - ensiie - Prog. fonctionnelle 2011/2012
A
Situation de départ
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
24
*
4
fact 4
Exemple : factorielle
Noyau fonctionnel
*
*
*
*
*
1
fact 0
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 44
C
illustration
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 42
1
1
fact 1
terminal/non terminal
B
B
XU - ensiie - Prog. fonctionnelle 2011/2012
A
Jamais de gros sur un petit : interdit
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
A
C
illustration
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 47
C
illustration
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 45
Situation d’arrivée, un disque à la fois
Noyau fonctionnel
B
B
XU - ensiie - Prog. fonctionnelle 2011/2012
A
Solution pour n disques ?
Noyau fonctionnel
XU - ensiie - Prog. fonctionnelle 2011/2012
A
Jamais de gros sur un petit : OK
Noyau fonctionnel
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 48
C
illustration
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 46
C
illustration
principe de l’inférence
XU - ensiie - Prog. fonctionnelle 2011/2012
- Concaténation linéaire
- Appartenance linéaire
+ Ordre d’entrée conservé (FILO)
+ Ajout en tête en temps constant
Structure dynamique
Listes
XU - ensiie - Prog. fonctionnelle 2011/2012
Type de f ?
else f g (n-1) (g x);
if n = 0 then x
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 51
Mal. . .
Bien !
Mémoire
premiers pas
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 49
let rec f = fun g -> fun n -> fun x ->
Noyau fonctionnel
Retrait
XU - ensiie - Prog. fonctionnelle 2011/2012
Dans ce cours a::b::· · ·::k::[]
[a;b;· · · ;k]
Notation alternative de la valeur :
Utilisation directe dans filtrage
• Constructeur ::
• Base []
Type ’a list natif dans Ocaml :
Listes
XU - ensiie - Prog. fonctionnelle 2011/2012
• Concaténation
• Appartenance
• Ajout (en tête ou pas)
Fonctions
• Construction e en tête de l
• Vide
Structure
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 52
premiers pas
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 50
Le mal
On veut persistante
Mémoire
premiers pas
Soit vide, soit élément et liste qui suit � passage au suivant
Structure dynamique
Listes
XU - ensiie - Prog. fonctionnelle 2011/2012
Non terminal
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 55
Type : (α → β → β) → αlist → β → β
fold_right f a1 ::a2 ::· · ·::an ::[] acc �
f a1 (f a2 (· · · (f an acc) · · · ))
Terminal
fold_left f acc a1 ::a2 ::· · ·::an ::[] �
f (· · · (f (f acc a1 ) a2 ) · · · ) an
Type : (α → β → α) → α → βlist → α
Exception: Division_by_zero
exceptions
#
XU - ensiie - Prog. fonctionnelle 2011/2012
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 56
éventuellement la reprendre sur une autre expression !
. . . pour interrompre une évaluation
Exception: Invalid_argument
. . . en cas de domaine de définition dépassé
1/0;;
Terminal
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 54
fold composition d’applications de fonction par élément
Noyau encore
XU - ensiie - Prog. fonctionnelle 2011/2012
Opérations partielles : valeur exceptionnelle en cas d’erreur
itérateurs
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 53
Parcours de structure, construction de résultat portant sur structure
Listes
XU - ensiie - Prog. fonctionnelle 2011/2012
Type : (α → β → α) → α → βlist → α
fold_left f acc a1 ::a2 ::· · ·::an ::[] �
f (· · · (f (f acc a1 ) a2 ) · · · ) an
map f a1 ::a2 ::· · ·::an ::[] � (f a1 )::(f a2 )::· · ·::(f an )::[]
Type : (α → β) → αlist → βlist
fold composition d’applications de fonction par élément
itérateurs
map liste d’applications de fonction par élément
Listes
Parcours de structure, construction de résultat portant sur structure
itérateurs
Parcours de structure, construction de résultat portant sur structure
Listes
XU - ensiie - Prog. fonctionnelle 2011/2012
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 57
raise (Terrible_erreur "subjonctif après « après que »")
raise Toto
Levée d’une exception :
(mais pas polymorphe)
exception Terrible_erreur of string
XU - ensiie - Prog. fonctionnelle 2011/2012
ni e1 ni e2 évalués
valeur e2
valeur e1
exceptions
U N JEU DE SLIDES N ’ EST PAS UN POLY DE RÉFÉRENCE 58
• Non filtrée : exception propagée
• Filtrée par Motif_exc alors calcul poursuivi
2. Levée dans e1 :
1. Évaluation de e1 , sans exception : calcul terminé
try e1 with Motif_exc -> e2
exception Toto
Noyau encore
Rattrapage: construction try . . . with
exceptions
Définition :
Noyau encore