noyau fonctionnel

MdP
Modèles de Programmation
Emmanuel Chailloux
Master LMFI - Modèles de Programmation - année 2013/2014 - 1 / 45
Informations sur le cours MdP
Site
http://www-apr.lip6.fr/~chaillou/Public/enseignement/
2013-2014/MdP/
Email
[email protected]
Master LMFI - Modèles de Programmation - année 2013/2014 - 2 / 45
Description de l’UE
Comprendre les différents modèles de programmation
séquentielle (impératif, fonctionnel, modulaire, objet)
◮ Maîtriser leur mise en pratique dans le cadre du langage
OCaml,
◮ Apprécier la sûreté et la réutilisation apportéee par le typage
statique
◮ Savoir utiliser un environnement de développement pour Caml
◮ Comprendre les différents modèles de programmation
concurrente en fonction des modèles mémoire utilisés
(mémoire partagée, mémoire répartie).
mots clés :
Panorama des langages de programmation, Types et
déclarations, Mécanismes d’abstraction, Programmation
par objets, Programmation fonctionnelle, Programmation
modulaire, Systèmes de types, Programmation
concurrente
◮
Master LMFI - Modèles de Programmation - année 2013/2014 - 3 / 45
Plan du cours (1)
1. présentation de l’UE
généralités sur les langages et les modèles de programmation,
le noyau fonctionnel Caml : définitions et appels de fonction,
valeurs fonctionnelles
2. le noyau fonctionnel : déclarations de types, filtrage de motifs,
polymorphisme
Exceptions : déclenchement, récupération et style de
programmation
3. Traits impératifs : valeurs physiquement modifiables et
structures de contrôle, variables de type faibles
4. Modules simples et paramétrés : séparation interface et
implantation, compilation séparée, types abstraits de données
5. Objet I : classes, instances, héritage, liaison tardive
Objet II : sous-typage et polymorphisme objet
6. Concurrence et répartition
Master LMFI - Modèles de Programmation - année 2013/2014 - 4 / 45
Logiciels du cours
indépendants des systèmes (Windows, Linux, Macosx, ...) :
◮
langage Objective Caml 4.01
◮
◮
pré-installé sur les machines de l’école doctorale (à véririfer)
à installer à la maison à partir du site de l’Inria :
http://caml.inria.fr/
◮
Environnements de développement
◮
Emacs et mode Tuareg
http://www.gnu.org/software/emacs/
http://tuareg.forge.ocamlcore.org/
◮
Eclipse et plug-in Ocaide
http///www.eclipse.org et
et
http://www.algo-prog.info/ocaide/
Master LMFI - Modèles de Programmation - année 2013/2014 - 5 / 45
Bibliographie
◮
◮
◮
◮
◮
◮
Pascal Manourry. Programmation de droite à gauche et
vice-versa, paracamplus, 2012.
Xavier Leroy et al. The Objective Caml system :
documentation and user’s manual Inria, 2010.
Emmanuel Chailloux, Pascal Manoury et Bruno Pagano.
Développement d’Applications avec Objective Caml. O’Reilly,
2000.
Guy Cousineau et Michel Mauny. Approche fonctionnelle de la
programmation. Dunod, 1995.
Philippe Nardel. Programmation fonctionnelle, générique et
objet : Une introduction avec le langage OCaml. Vuibert, 2005
Yaron Minsky, ANul Madhavapeddy, Jason Hickey. Real World
OCaml, O’Reilly 2013
autres références sur : http://caml.inria.fr/about/books.en.html et
scriptsizehttp://ocaml.org/
Master LMFI - Modèles de Programmation - année 2013/2014 - 6 / 45
Objective Caml
◮
langage fonctionnel,
◮
typé statiquement,
◮
polymorphe paramétrique,
◮
avec inférence de types,
◮
muni d’un mécanisme d’exceptions,
◮
et de traits impératifs
◮
possèdant un système de modules paramétrés
◮
et un modèle objet
◮
exécutant des processus légers
◮
et communiquant sur le réseau Internet,
◮
indépendant de l’architecture machine.
Master LMFI - Modèles de Programmation - année 2013/2014 - 7 / 45
Historique
◮
◮
l’ancêtre : ML (meta-langage) de LCF (80)
machines abstraites (84)
◮
◮
◮
◮
la FAM : Cardelli
la CAM : Curien, Cousineau
spécifications : Standard ML (84 - Milner)
premières implantations
◮
◮
CAML - Suarez - Weis - Mauny (87)
SML/NJ - Mc Queen - Appel (ATT - 88)
◮
nouvelles implantations : Caml-light (90) Leroy - Doligez
◮
modules paramétrés : Caml Special Light (95)
◮
extension objet (96)
◮
labels, options, variants polymorphes, . . .
Master LMFI - Modèles de Programmation - année 2013/2014 - 8 / 45
Mise en œuvre (1)
◮
compilateur natif (commande ocamlopt)
◮
◮
pour Intel, Sparc, HP-pa, PowerPC, . . .
pour Linux, Macosx, Windows, . . .
$ c a t t . ml
let f x = x + 1 ;;
p r i n t _ i n t ( f 18) ; ;
print_newline () ; ;
$ o c a m l o p t −o t n . e x e t . ml
$ . / tn . exe
19
Master LMFI - Modèles de Programmation - année 2013/2014 - 9 / 45
Mise en œuvre (2)
◮
compilateur byte-code (commande ocamlc)
◮
ligne de commande
$ cat t.ml
let f x = x + 1 ;;
print_int (f 18) ;;
print_newline () ;;
$ ocamlc -i -custom -o tb.exe t.ml
val f : int -> int
$ ./tb.exe
19
Master LMFI - Modèles de Programmation - année 2013/2014 - 10 / 45
Mise en œuvre (3)
◮
compilateur byte-code (commande ocaml)
◮
1
2
3
4
5
6
7
8
9
boucle d’interaction
$ ocaml
Objective Caml version 3 . 1 0 . 2
# let f x = x + 1 ;;
v a l f : int −> int = <f un>
# f 18 ; ;
− : int = 19
# #q u i t ; ;
$
◮
◮
◮
$ : invite Unix
# : invite O’Caml
#quit : directive O’Caml
Master LMFI - Modèles de Programmation - année 2013/2014 - 11 / 45
Machine virtuelle
BC
la Zinc
C
C
.o
BC
BC
.o
µ
µ
bibliothèque
d’exécution
C
ocamlrun
C
.o
.o
µ
compilateur
O’CAML
v1 -> v2
OC-v2
OC-v2
BC
BC
OC-v1 OC-v1
BC
BC
BC
ocamlc
BC
µ
bibliothèques
de modules
OC-v2
OC-v2
BC
BC
BC
.cmo
BC
µ
Master LMFI - Modèles de Programmation - année 2013/2014 - 12 / 45
Phrases du langage
Se terminent par ;;
◮
◮
expressions
déclarations
◮
◮
◮
de valeurs
de types
d’exceptions
◮
déclarations de modules
◮
déclarations de classes
Notation qualifiée Module.nom pour accéder à un champs d’un
module.
Master LMFI - Modèles de Programmation - année 2013/2014 - 13 / 45
Noyau fonctionnel
Master LMFI - Modèles de Programmation - année 2013/2014 - 14 / 45
Programmes en Objective Caml
Seuls les programmes correctement typés peuvent être exécutés.
◮
calcul d’une expression
◮
application d’une fonction à ses arguments
◮
évaluation immédiate des arguments
◮
rupture d’évaluation si calcul impossible
Master LMFI - Modèles de Programmation - année 2013/2014 - 15 / 45
Types de base, valeurs et fonctions
◮
nombres
◮
◮
int ([−230 , 230 − 1] (m32)
float (IEEE 754) mantisse 53bits, exposant ∈ [−1022, 1023]
◮
caractères : char
◮
chaînes de caractères : string
◮
booléens : bool
Master LMFI - Modèles de Programmation - année 2013/2014 - 16 / 45
Opérations sur les nombres
entiers
+
*
/
mod
addition
soustraction
multiplication
division entière
modulo
flottants
+. addition
-. soustraction
*. multiplication
/. division
** exponentiation
opérateurs infixes!!!
1
2
3
4
#
−
#
−
1 + 3;;
: int = 4
1.8 ∗. 9 . 1 ; ;
: float = 1 6 . 3 8
Master LMFI - Modèles de Programmation - année 2013/2014 - 17 / 45
Fonctions sur les nombres
entiers
ceil
floor
sqrt
exp
log
log10
racine carrée
exponentielle
log népérien
log en base 10
flottants
cos
cosinus
sin
sinus
tan
tangente
acos arccosinus
asin arcsinus
atan arctangente
angles en radiant!!!
Master LMFI - Modèles de Programmation - année 2013/2014 - 18 / 45
Calculs sur les nombres (1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 1 + 2;;
− : int = 3
# 9/2;;
− : int = 4
# 2147483650;;
− : int = 2
# 9.1 /. 2 . 2 ; ;
− : float = 4 . 1 3 6 3 6 3 6 3 6 3 6
# 1. /. 0 . ; ;
− : float =
Inf
Master LMFI - Modèles de Programmation - année 2013/2014 - 19 / 45
Calculs sur les nombres (2)
1
2
3
# 2 + 2.1;;
This expression has t y p e float but
is here used w i t h t y p e int
Un int ne peut pas remplacer un float!!!
1
2
3
4
5
# sin ; ;
− : float −> float = <f un>
# asin 1 . ; ;
− : float = 1 . 5 7 0 7 9 6 3 2 6 7 9
Master LMFI - Modèles de Programmation - année 2013/2014 - 20 / 45
Calculs sur les chaînes
1
2
3
4
5
6
7
8
9
10
11
# ’B ’ ; ;
− : char = ’ B ’
# i n t _ o f _ c h a r ’B ’ ; ;
− : int = 66
# " est une chaine " ; ;
− : string = " est une chaine "
# ( s t r i n g _ o f _ i n t 1 9 8 7 ) ^" est l ’ annee de CAML " ; ;
− : string = " 1987 est l ’ annee de CAML "
Master LMFI - Modèles de Programmation - année 2013/2014 - 21 / 45
Opérations sur les booléns et relations
not
&&
||
=
==
<>
!=
négation
et séquentiel
ou séquentiel
égalité structurelle
égalité physique
négation de =
négation de ==
&
or
<
>
<=
>=
synonyme pour et
synonyme pour ou
inférieur
supérieur
inférieur ou égal
supérieur ou égal
égalités et inégalités polymorphes!!!
= : ’a -> ’a -> bool
== : ’a -> ’a -> bool
Master LMFI - Modèles de Programmation - année 2013/2014 - 22 / 45
Produits cartésiens, n-uplets
1
2
3
4
5
6
7
8
◮
constructeur de valeurs : ,
◮
constructeur de types : *
◮
accesseurs (couples) : fst et snd
# ( 1 8 , " mars " ) ; ;
− : int ∗ string
# ( 1 8 , " mars " , 1 9 9 9 ) ; ;
− : int ∗ string ∗ int
# f s t ( 1 8 , " mars " ) ; ;
− : int = 18
# s nd ( 1 8 , " mars " , 1 9 9 9 )
erreur de typage
Master LMFI - Modèles de Programmation - année 2013/2014 - 23 / 45
Listes homogènes
1
2
3
4
5
6
7
8
9
10
11
12
◮
liste vide : []
◮
constructeur ::
◮
type list
◮
accesseurs List.hd et List.tl
# [];;
− : ’ a list
# 1::2::3::[];;
− : int list
# [1 ; 2; 3 ; ] ; ;
− : int list
# [ 1 ; " hello " ; 3 ] ; ;
erreur de typage
# L i s t . hd [ 1 . 1 ; 1 . 2 ; 1 . 3 ] ; ;
− : float = 1 . 1
# L i s t . hd [ ] ; ;
e x c e p t i o n non récupérée
Master LMFI - Modèles de Programmation - année 2013/2014 - 24 / 45
Expression conditionnelle
Syntaxe:
if expr1 then expr2 else expr3
1
2
3
4
5
6
7
8
#
−
#
−
#
−
#
−
◮
expr1 de type bool
◮
expr2 et expr3 de même type
i f 3 = 4 then 0 e l s e 4 ; ;
: int = 4
i f 5 = 6 t h e n 1 e l s e " Non " ; ;
: erreur de typage
( i f 3 = 5 then 8 e l s e 10) + 5 ; ;
: int = 15
5 = 6 || 7 = 9;;
: bool = false
Master LMFI - Modèles de Programmation - année 2013/2014 - 25 / 45
Déclarations de valeurs (1)
Déclarations globales:
Syntaxe:
let p = e
1
2
3
4
5
# l e t pi = 3.14159;;
v a l pi : float = 3 . 1 4 1 5 9
# sin ( pi /. 2.0) ; ;
− : float = 0 . 9 9 9 9 9 9 9 9 9 9 9 9
Master LMFI - Modèles de Programmation - année 2013/2014 - 26 / 45
Déclarations de valeurs (2)
Déclatations locales:
Syntaxe:
let p = e1 in e2
1
2
3
4
5
6
7
# le t x = 3 in
l e t b = x < 10 i n
i f b then 0 e l s e
− : int = 0
10;;
# b;;
Unbound v a l u e b
Master LMFI - Modèles de Programmation - année 2013/2014 - 27 / 45
Déclarations combinées
Syntaxe:
let p1 = e1 and p2 = e2 ... and pn = en ;;
1
2
3
4
5
# let x
val x :
val y :
# x+y ; ;
− : int
= 1 and y = 2 ; ;
int = 1
int = 2
= 3
Syntaxe:
let p1 = e1 and p2 = e2 ... and pn = en in expr ;;
1
2
# l e t a = 3 . 0 and b = 4 . 0 i n s q r t ( a ∗ . a +.b ∗ . b ) ; ;
− : float = 5
Master LMFI - Modèles de Programmation - année 2013/2014 - 28 / 45
Valeurs fonctionnelles, fonctions
Syntaxe:
function p -> e
1
2
3
4
5
6
7
8
◮
fonction anonyme : function p -> e
◮
de type : typede(p) -> typede(e)
# f u n c t i o n x −> x + 1 ; ;
− : int −> int
# ( f u n c t i o n x −> x +1) 1 9 9 9 ; ;
− : int = 2000
# f u n c t i o n x −> i f x < 0 t h e n −x e l s e x ; ;
− : int −> int
# f u n c t i o n x −> ( f u n c t i o n y −> 2∗ x+3∗y ) ; ;
− : int −> int −> int
Master LMFI - Modèles de Programmation - année 2013/2014 - 29 / 45
Déclaration de valeurs fonctionnelles
1
2
3
4
# l e t s u c c = f u n c t i o n x −> x + 1 ; ;
succ : int −> int
# succ 420 ;;
− : int = 421
Syntaxe:
let f = function p -> e
ou
let f (p) = e
1
2
3
4
5
6
7
8
9
10
ou
let f p = e
# l e t pred ( x ) = x −1;;
pred : int −> int = <f un>
# l e t f c = 2 ∗ ( f s t c ) + 3 ∗ ( s nd c ) ; ;
f : int ∗ int −> int = <f un>
# f (1 ,2) ; ;
− : int = 8
# l e t g = f u n c t i o n x −> ( f u n c t i o n y −> 2∗ x + 3∗ y ) ; ;
g : int −> int −> int = <f un>
# g 1 2;;
− : int = 8
Master LMFI - Modèles de Programmation - année 2013/2014 - 30 / 45
Portée des déclarations
◮
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
portée lexicale (liaison statique)
# let p = q + 1;;
e r r e u r q inconnue
# let p = p + 1;;
e r r e u r p inconnue
# let p = 10;;
p : i n t = 10
# l e t addp x = x + p ; ; addp : i n t −> i n t = <f un>
# addp 8 ; ;
− : i n t = 18
# let p = 40;;
p : i n t = 40
# addp 8 ; ;
− : i n t = 18
# p;;
− : i n t = 40
Master LMFI - Modèles de Programmation - année 2013/2014 - 31 / 45
Récursivité
Syntaxe:
let rec p = expr
1
2
3
4
5
6
# l e t r e c sigma x = i f x = 0 then 0
e l s e x + sigma ( x −1) ; ;
sigma : int −> int = <f un>
# sigma 1 0 ; ;
− : int = 55
récursion mutuelle:
1
2
3
4
5
6
7
# l e t r e c odd x = i f x = 0 t h e n f a l s e e l s e e v e n ( x −1)
# and e v e n x = i f x = 0 t h e n t r u e e l s e odd ( x −1) ; ;
v a l odd : int −> bool = <f un>
v a l even : int −> bool = <f un>
# odd 2 7 ; ;
− : bool = true
Master LMFI - Modèles de Programmation - année 2013/2014 - 32 / 45
Polymorphisme paramétrique (1)
1
2
3
4
5
6
7
8
9
10
11
◮
même code pour des arguments de types différents
◮
la fonction n’utilise pas la structure de l’argument
# l e t mp a b = a , b ; ;
v a l mp : ’ a −> ’ b −> ’ a ∗ ’ b = <f un>
# l e t x = mp 3 6 . 8 ; ;
v a l x : int ∗ float = 3 , 6 . 8
# l e t y = mp t r u e [ 1 ] ; ;
v a l y : bool ∗ int list = true , [ 1 ]
# fst x ;;
− : int = 3
Master LMFI - Modèles de Programmation - année 2013/2014 - 33 / 45
Polymorphisme paramétrique (2)
1
2
3
4
5
6
7
8
◮
même code pour des arguments de types différents
◮
la fonction n’utilise pas la structure de l’argument
# le t id x = x ; ;
v a l id : ’ a −> ’ a = <f un>
# l e t app x y = x y ; ;
v a l app : ( ’ a −> ’ b ) −> ’ a −> ’ b = <f un>
# app i d 1 ; ;
− : int = 1
Master LMFI - Modèles de Programmation - année 2013/2014 - 34 / 45
Résumé des expressions rencontrées
expr ::=
|
|
|
|
|
|
|
|
|
|
constante
( expr )
ident
Mod.ident
op expr
expr infix-op expr
if expr then expr else expr
function ident -> expr
expr expr
expr , expr | epxr :: epxr
let [rec] ident = expr
{and ident = expr} in expr
Master LMFI - Modèles de Programmation - année 2013/2014 - 35 / 45
Exemples (1)
Comptage des éléments d’une liste:
1
2
3
4
5
6
7
8
9
10
11
12
13
# l e t rec long l =
i f l = [ ] then 0
e l s e 1 + long ( List . tl l ) ; ;
v a l long : ’ a list −> int = <f un>
# long [ 2 ; 4 ; 7 ] ; ;
− : int = 3
# long [ ] ; ;
− : int = 0
# long [ ’A ’ ;
− : int = 2
’G ’ ] ; ;
Master LMFI - Modèles de Programmation - année 2013/2014 - 36 / 45
Exemples (2)
Composition de fonctions:
1
2
3
4
5
6
7
8
9
10
# l e t compose f g x = f ( g x ) ; ;
v a l compose : ( ’ a −> ’ b ) −> ( ’ c −> ’ a ) −>
’ c −> ’ b = <f un>
# l e t add2 x = x + 2 and m ul t5 x = x ∗ 5 ; ;
v a l add2 : int −> int = <f un>
v a l mult5 : int −> int = <f un>
# compose m ul t5 add2 9 ; ;
− : int = 55
Master LMFI - Modèles de Programmation - année 2013/2014 - 37 / 45
Exemples (3)
Application d’une fonction sur les éléments d’une liste:
1
2
3
4
5
6
7
8
9
10
11
12
13
# l e t r e c map f l =
i f l = [ ] then [ ]
else
l e t t = List . hd l
and q = List . tl l i n
( f t ) : : ( map f q ) ; ;
v a l map : ( ’ a −> ’ b ) −> ’ a list −> ’ b list = <f un>
# l e t l 1 = map add2 [ 7 ; 2 ; 9 ] ; ;
v a l l1 : int list = [ 9 ; 4 ; 1 1 ]
# l e t l 2 = map l o n g [ [ ’ z ’ ; ’ a ’ ; ’ m ’ ] ;
v a l l2 : int list = [ 3 ; 4 ]
[ ’. ’; ’n ’; ’e ’; ’ t ’ ] ] ; ;
Master LMFI - Modèles de Programmation - année 2013/2014 - 38 / 45
Filtrage de motif
permet l’accès aux structures de données
◮
en testant une valeur
◮
en nommant une partie de la structure
motif:
◮ assemblage correct (syntaxe et type) d’objets
◮
◮
◮
◮
◮
de types de base (int, bool,. . . )
de paires, listes et constructeurs
d’identificateurs
du motif “sauvage” (_)
ce n’est pas une expression (pas de calcul)
Master LMFI - Modèles de Programmation - année 2013/2014 - 39 / 45
Syntaxe du filtage de motif
Syntaxe:
match e with p1 -> e1 | p2 -> e2 ...| pn -> en
◮
filtrage séquentiel de e par les différents pi .
◮
Si un des motifs correspond à la valeur de e, alors sa branche
ei est évaluée.
◮
tous les ei du même type, idem pout les pi
◮
motif linéaire ( (x,x) interdit)
◮
détection d’un filtrage exhaustif
Master LMFI - Modèles de Programmation - année 2013/2014 - 40 / 45
Exemple : fonction imply
1
2
3
4
5
6
# l e t i m p l y v = match v w i t h
( true , true ) −> true
|
( true , false )−> false
|
( false , true )−> true
|
( false , false )−>true ; ;
v a l imply : bool ∗ bool −> bool = <f un>
Autre version:
1
2
3
4
# l e t i m p l y v = match v w i t h
( true , x ) −> x
|
( false , _ ) −> true ; ;
v a l imply : bool ∗ bool −> bool = <f un>
Master LMFI - Modèles de Programmation - année 2013/2014 - 41 / 45
Warnings
◮
1
2
3
4
5
6
7
◮
1
2
3
4
5
filtrage non exhaustif :
# l e t f x = match x w i t h
( true , x ) −> true
| ( false , false ) −> true ; ;
Warning : this pattern −matching is no t exhaustive .
Here is an example o f a v a l u e that is no t matched :
( false , true )
v a l f : bool ∗ bool −> bool = <f un>
cas inutile :
# l e t f x = match x
( a , b ) −> true
| ( true , false ) −>
Warning : this match
v a l f : bool ∗ bool
with
false ; ;
case is unused .
−> bool = <f un>
Master LMFI - Modèles de Programmation - année 2013/2014 - 42 / 45
Style Caml : définition par cas
en utilisant le filtrage de motifs sur les différents constructeurs
d’uns structure de données :
1
2
3
4
let
r e c long l = match l w i t h
[ ] −> 0
| _ : : q −> 1 + long q ; ;
v a l long : ’ a list −> int = <f un>
1
2
3
4
l e t r e c map f l = match l w i t h
[ ] −> [ ]
| t : : q −> ( f t ) : : map f q ; ;
v a l map : ( ’ a −> ’ b ) −> ’ a list −> ’ b list = <f un>
Master LMFI - Modèles de Programmation - année 2013/2014 - 43 / 45
Filtrage avec gardes
◮
expression conditionnelle après le motif
◮
reprise du filtrage si false
Syntaxe:
match e with p1 when c1 -> e1 | p2 -> e2 ...| pn -> en
1
2
3
4
5
6
# l e t r e c mem_assoc3 x l = match l w i t h
[ ] −> false
| ( y1 , y2 , y3 ) : : t when y1 = x −> true
| _ : : t −> mem_assoc3 x t ; ;
v a l mem_assoc3 :
’ a −> ( ’ a ∗ ’ b ∗ ’ c ) list −> bool = <f un>
Master LMFI - Modèles de Programmation - année 2013/2014 - 44 / 45
Motif dans les déclarations
◮
Formes équivalentes:
Syntaxe:
match e with filtrage
◮
≡
(function filtrage) e
Déclarations déstructurantes:
Syntaxe:
let p = e
1
2
3
p est un motif
# l e t (x , y ) = (3 , true ) ; ;
v a l x : int = 3
v a l y : bool = true
Master LMFI - Modèles de Programmation - année 2013/2014 - 45 / 45