Programmation Fonctionnelle Cours 5 Fonctions d`ordre supérieure

Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Table de matières
Programmation Fonctionnelle
Cours 5
Fonctions d'ordre supérieure
Les fonctions sont des valeurs de première classe
Application partielle
Fonctions polymorphes
October 18, 2012
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Les fonctions sont des valeurs de première classe
Valeurs de première classe
I
Valeurs qui peuvent être utilisées dans un langage de
programmation sans restriction, par exemple :
I
I
I
I
I
I
lier à un identicateur (ou variable)
passer en argument à une fonction (ou procédure)
retourner comme résultat d'une fonction
faire partie des structures de données (par exemple, une liste
de telles valeurs)
avoir une notion d'identité (test d'égalité)
À l'origine appelé rst-class objects (Christopher Strachey),
mais pas à confondre avec les objets dans le sens propre.
Le module List de la bibliothèque standard
Le manuel OCaml
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Les fonctions sont des valeurs de première classe
Valeurs fonctionnelles en OCaml
I
I
I
I
I
function id → exp
C'est une fonction qui prend un argument, dénoté par
l'identicateur id, et qui envoie comme résultat la valeur de
l'expression exp.
La portée de id est exp
Le type de cette valeur est t1 → t2 , où t1 est le type de
l'argument, et t2 est le type du résultat de la fonction.
Le type est déterminé utilisant des informations dans
l'expression exp, et peut être polymorphe (voir un peu plus
tard).
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Les fonctions sont des valeurs de première classe
Les fonctions sont des valeurs de première classe
Exemples (function1.ml)
f u n c t i o n x −> x +1;;
f u n c t i o n y −> [ [ y+2; y +3]; [ y ;
l e t i n c = f u n c t i o n x −> x +1;;
Fonctions à un argument
y∗y ] ] ; ;
inc 5;;
l e t i n c x = x +1;; ( ∗ e q u i v a l e n t au p r e c e d e n t
( f u n c t i o n x −> x+3) 5 ; ;
let f x = e
∗)
est une abréviation pour
let f = function x -> e
( f u n c t i o n x −> x ∗ x ) ( f u n c t i o n x −> x+1) 3 ; ; ( ∗ e r r e u r ∗ )
( f u n c t i o n x −> x ∗ x ) ( ( f u n c t i o n x −> x+1) 3 ) ; ; ( ∗ OK ∗ )
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Les fonctions sont des valeurs de première classe
La forme générale de function
I
I
Plus généralement, on peut avoir après function un ltrage
par motif.
let f = function
| motif_1 -> expression_1
....
| motif_n -> expression_n
La forme function x → exp en
est un cas particulier : un
seul motif, qui est un seul identicateur.
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Les fonctions sont des valeurs de première classe
Exemples (function2.ml)
l e t re c l e n g t h = f u n c t i o n
| [ ] −> 0
| _: : r −> 1+ l e n g t h r
;;
expr =
| I n t of i n t
| Add of expr ∗ expr
| Mult of expr ∗ expr ; ;
type
e v a l = function
| I n t n −> n
| Add( e1 , e2 ) −> ( e v a l e1 ) + ( e v a l e2 )
| Mult ( e1 , e2 ) −> ( e v a l e1 ) ∗ ( e v a l e2 ) ; ;
l e t re c
e v a l (Add ( Mult ( I n t 2 , I n t 5) , Mult ( I n t 3 , I n t 3 )
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Application partielle
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Application partielle
Fonctions à plusieurs arguments
Exemples (function3.ml)
expr =
| Var of s t r i n g
| Add of expr ∗ expr
| Mult of expr ∗ expr ; ;
type
I
I
I
fun x1
. . . xn → t
Utiliser match . . . with pour des distinctions de cas (pas de
ltrage par motif intégré, comme dans le cas de function)
Peut aussi être utilisé pour un seul argument.
e v a l = fun environment expr −> match expr w
| Var x −> L i s t . a s s o c x environment
| Add( e1 , e2 ) −> ( e v a l environment e1 ) + ( e v a l envi
| Mult ( e1 , e2 ) −> ( e v a l environment e1 ) ∗ ( e v a l env
l e t re c
e v a l [ ( "x" , 2 ) ; ( "y" , 5 ) ] (Add( Var "x" , Mult ( Var "x" ,
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Application partielle
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Application partielle
fun et function
Exemples (function4.ml)
expr =
| Var of s t r i n g
| Add of expr ∗ expr
| Mult of expr ∗ expr ; ;
type
fun x1 x2 .. xn -> e
est une abréviation pour
function x1 -> function x2 -> ... function xn -> e
l e t re c e v a l =
f u n c t i o n environment −>
f u n c t i o n expr −> match
expr with
| Var x −> L i s t . a s s o c x environment
| Add( e1 , e2 ) −> ( e v a l environment e1 ) + ( e v a l
| Mult ( e1 , e2 ) −> ( e v a l environment e1 ) ∗ ( e v a l
e v a l [ ( "x" , 2 ) ; ( "y" , 5 ) ] (Add( Var "x" , Mult ( Var "x" ,
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Application partielle
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Application partielle
Exemples (function5.ml)
Application partielle
expr =
| Var of s t r i n g
| Add of expr ∗ expr
| Mult of expr ∗ expr ; ;
type
Une fonction à n ≥ 2 arguments x1 , . . . , xn est en vérité une
fonction qui prend x1 en argument, et qui envoie une fonction
qui prend x2 , . . . , xn en argument.
I L'application f e1 e2 . . . en est en vérité une chaîne
l e t re c e v a l = f u n c t i o n environment −> f u n c t i o n
d'applications (. . . ((f e1 ) e2 ) . . . en )
| Var x −> L i s t . a s s o c x environment
I Application partielle : appliquer une fonction, dénie avec
| Add( e1 , e2 ) −> ( e v a l environment e1 ) + ( e v a l environment e2 )
| Mult ( e1 , e2 ) −> ( e v a l environment e1 ) ∗ ( e v a l environmentn arguments,
e2 ) ; ; à moins que n arguments. Le résultat est encore
une fonction.
e v a l [ ( "x" , 2 ) ; ( "y" , 5 ) ] (Add( Var "x" , Mult ( Var "x" , Var "y" ) ) ) ; ;
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Application partielle
I
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Application partielle
Qu'est-ce qu'il se passe lors d'une application ?
Une application :
Qu'est-ce qu'il se passe lors d'une application ?
On a maintenenant :
ef ea
Le typage nous guarantie :
I ef est d'un type fonctionnel ta → tr
I ea est du type ta
(si on ignore la polymorphie)
Évaluer les deux expressions
I
I
Évaluation de ef donne une valeur fonctionnelle
function x → ec
Évaluation de ea donne
une valeur va
(function
x → ec ) va
Substituer dans le corps de la fonction:
ec [x /va ]
Dans le corps ec on remplace toute occurrence de x par va
Évaluer l'expression obtenue tant que possible
I
On n'évalue pas au dessous de function
x →
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Application partielle
Application partielle
Exemple
Exemple (continu)
let f = function x -> function y -> x+y
I
f
est lié à function
x -> function y -> x+y
g (3+4)
let g = f 1
I
I
I
I
Évaluation de f : function x
1 est déjà évaluée
Substitution : function y ->
I
I
-> function y -> x+y
function y -> 1+y
g est lié à function y -> 1+y
x+y[x/1]
I
I
donne
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Application partielle
Exemples (function6.ml)
Évaluation de g donne function y ->
Évaluation de 3 + 4 donne 7
Substitution : 1+y[y/7] donne 1 + 7
Évaluation donne 8
Application partielle
Exemples (function7.ml)
expr =
| Var of s t r i n g
| Add of expr ∗ expr
| Mult of expr ∗ expr ; ;
type
f x y z = x+2∗ y+3∗ z ; ;
g = f 2;;
h = g 3;;
l e t re c e v a l = f u n c t i o n environment −> f u n c t i o n
h 4;;
| Var x −> L i s t . a s s o c x environment
l e t fe2x) y = x ∗ y ; ;
| Add( e1 , e2 ) −> ( e v a l environment e1 ) + ( e v a l environment
( f 2) e2( ()f; ; 3) 4 ) ; ;
| Mult ( e1 , e2 ) −> ( e v a l environment e1 ) ∗ ( e v a l environment
let
eval_in_myenv = e v a l [ ( "x" , 2 ) ; ( "y" , 5 ) ] ; ;
eval_in_myenv (Add( Var "x" , Mult ( Var "x" , Var "y" ) ) ) ; ;
let
let
let
1+y
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Application partielle
Fonctions polymorphes
Exemples (lambda.ml)
Exemples (function8.ml)
( ∗ pas d ' e v a l u a t i o n au d e s s o u s de f u n c t i o n y −> . . . ∗ )
let
f =
function
x −>
function
y −> (1 / x ) + y ; ;
let
g = f 0 ; ; ( ∗ pas d ' e r r e u r
let
z = g 5 ; ; (∗ E r r e u r : d i v i s i o n par z e r o
h 4;;
∗)
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Fonctions polymorphes
Exemples (lists1.ml)
( ∗ d e f i n e d i n l i b r a r y a s L i s t . map ∗ )
l e t re c map f = f u n c t i o n
| [ ] −> [ ]
| h : : r −> ( f h ) : : ( map f r ) ; ;
map ( f u n c t i o n x −> x ∗ x ) [ 1 ; 2 ; 3 ; 4 ; 5 ] ; ;
f u n c t i o n x −> x ; ;
l e t compose f g = f u n c t i o n x −> f ( g x ) ; ;
l e t h = compose ( f u n c t i o n x −> x ∗ x ) ( f u n c t i o n
i t e r n f x = i f n=0 then x
i t e r 3 ( f u n c t i o n x −> x ∗ x ) 2 ; ;
l e t re c
∗)
else
x −> x
i t e r ( n −1) f
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Fonctions polymorphes
Des valeurs fonctionnelles en OCaml
I
I
Pour tout opérateur inx (opérateur binaire qui est écrit entre
ses deux arguments), la fonction correspondante dénotée par
l'opérateur entre paranthèses. Exemple : (+).
Les constructeurs des types sommes ne sont pas de valeurs
fonctionnelles (comme par exemple ::).
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Fonctions polymorphes
Le module
Exemples (fonctionnelle.ml)
map : ('a -> 'b) -> 'a list -> 'b list
List.map f [a1; ...; an] donne [f a1; ...; f an]
l e t re c expo n f = f u n c t i o n x −>
i f n=1 then x e l s e f ( expo ( n − 1)
expo 5 (+) 1 ; ;
mytype = A | B
of
f x ) ( expo ( n −1) f
fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
List.fold_right f [a1; ...; an] b donne
f a1 (f a2 (... (f an b) ...))
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
List
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
de la bibliothèque standard
Le module
Exemples (lists3.ml)
end ; ;
pr x = p r i n t _ i n t x ; p r i n t _ n e w l i n e ( ) ; ;
i t e r pr [ 1 0 ; 1 1 ; 1 2 ; 1 3 ] ; ;
let
List
de la bibliothèque standard
Exemples (lists2.ml)
(∗ d e f i n e d i n l i b r a r y as L i s t . i t e r ∗)
l e t re c i t e r f = f u n c t i o n
| [ ] −> ( )
| h : : r −> begin f h ; i t e r f r
iter : ('a -> unit) -> 'a list -> unit
f [a1; ...; an] donne
x )List.iter
;;
begin f a1; f a2; ...; f an; () end
fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
List.fold_left f a [b1; ...; bn] donne
f (... (f (f a b1) b2) ...) bn
int ;;
A ; ; ( ∗ OK ∗ )
B ; ; (∗ e r r e u r ∗)
f u n c t i o n x −> B x ; ; ( ∗ OK ∗ )
Le module
de la bibliothèque standard
Quelques fonctions prédénies sur les listes
(+);;
( ∗ );;
type
List
(∗ d e f i n e d i n l i b r a r y as L i s t . f o l d _ r i g h t ∗)
( ∗ L i s t . f o l d _ r i g h t f [ a1 ; . . . ; an ] b i s ∗ )
( ∗ f a1 ( f a2 ( . . . ( f an b ) . . . ) )
∗)
l e t re c f o l d _ r i g h t f l b = match l with
| [ ] −> b
| h : : r −> f h ( f o l d _ r i g h t f r b ) ; ;
f o l d _ r i g h t ( fun x y −> x : : y ) [ 1 ; 2 ; 3 ; 4 ] [ ] ; ;
f o l d _ r i g h t (+) [ 1 ; 2 ; 3 ; 4 ] 0 ; ;
fold_right ( ∗ ) [1;2;3;4] 1;;
l e t c l 1 l 2 = f o l d _ r i g h t ( fun x y −> x : : y ) l 1 l 2 ; ;
c [1;2;3;4] [5;6;7;8];;
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Le module
List
de la bibliothèque standard
Le module
La fonction fold.right
f [a1; a2; ...
an] b
a1
| [ ] −> b
| h : : r −> f o l d _ l e f t f ( f b h ) r ; ;
f o l d _ l e f t (+) 0 [ 1 ; 2 ; 3 ; 4 ] ; ;
f o l d _ l e f t ( fun x y −> y : : x ) [ ] [ 1 ; 2 ; 3 ; 4 ] ; ;
f
a2
f
an
b
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
de la bibliothèque standard
Le module
La fonction fold.left
List
de la bibliothèque standard
Exemples (lists5.ml)
Évaluation de List.fold_left
f a [b1; b2; ... bn]
f
f
bn
b2
b1
:
( ∗ c a l c u l e r l a l i s t e de t o u t e s l e s sous − l i s t e s ∗ )
powers = f u n c t i o n
| [ ] −> [ [ ] ]
| h : : r −>
l e t rp = powers r i n
rp@ ( L i s t . map ( f u n c t i o n l −> h : : l ) rp ) ; ;
l e t re c
f
a
:
(∗ d e f i n e d i n l i b r a r y as L i s t . f o l d _ l e f t ∗)
l e t re c f o l d _ l e f t f b = f u n c t i o n
f
List
de la bibliothèque standard
Exemples (lists4.ml)
Évaluation de List.fold_right
Le module
List
powers [ 1 ; 2 ; 3 ] ; ;
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Le module
List
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
de la bibliothèque standard
Le module
Itérateurs sur 2 listes
I
Lève l'exception invalid_argument quand les deux listes ont
des longueurs diérentes
Voir le manuel pour plus de fonctions
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Le module
List
l e t vsum v1 v2 = L i s t . map2 (+) v1 v2 ; ;
vsum [ 1 ; 2 ; 3 ] [ 1 0 ; 2 0 ; 3 0 ]
( ∗ d e f i n i t i o n p l u s s i m p l e de vsum ? ∗ )
Le module
Exemples (lists7.ml)
List
de la bibliothèque standard
Exemples (lists8.ml)
(∗ p r o d u i t s c a l a i r e ∗)
( ∗ somme de deux m a t r i c e s ∗ )
let
scp [ 2 ; 4 ; 6 ] [ 1 ; 3 ; 5 ] ; ;
( ∗ somme de deux v e c t e u r s ∗ )
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
de la bibliothèque standard
scp v1 v2 =
L i s t . f o l d _ l e f t (+) 0 ( L i s t . map2 (
de la bibliothèque standard
Exemples (lists6.ml)
val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
List.map2 f [a1; ...; an] [b1; ...; bn] donne
[f a1 b1; ...; f an bn]
I
List
∗
) v1 v2 ) ; ;
msum m1 m2 = L i s t . map2 ( L i s t . map2 (+)) m1 m2 ; ;
msum = L i s t . map2 ( L i s t . map2 ( + ) ) ; ;
msum [ [ 1 ; 2 ] ; [ 3 ; 4 ] ] [ [ 1 0 ; 2 0 ] ; [ 3 0 ; 4 0 ] ] ; ;
let
let
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Le manuel OCaml
Les quatre parties du manuel
1. Introduction au langage (assez concis)
2. Manuel de référence
3. Les outils : interpréteur, compilateurs, . . .. Aussi informations
sur l'interfacage avec le langage C.
4. Les librairies
Programmation Fonctionnelle Cours 5 Fonctions d'ordre supérieure
Le manuel OCaml
Les librairies dans le manuel
1. The core library : types, valeurs (incl. fonctions !), et
exceptions disponibles par défaut. Suivre le lien Module:
Pervasives
2. The standard library : Modules pour lesquels il faut utiliser la
notion pointée (List.map). Ces fonctions sont écrites
eux-mêmes en OCaml.
3. Plusieurs autres bibliothèques qui sont écrites en C, et pour
lesquels il y a des instructions particulières à suivre pour les
utiliser dans un interpréteur, ou lors de la compilation.