Approches Fonctionnelles de la Programmation - 48 ...didier/lectures/afp/afp_00_introduction.pdf ·...

Paradigme 1er Ordre Pureté Évaluation Résumé

Approches Fonctionnelles de la Programmationeþ Introduction Eþ

Didier VernaEPITA / LRDE

[email protected]

lrde/~didier @didierverna didier.verna in/didierverna

mailto:[email protected]

http://www.lrde.epita.fr/~didier

http://www.twitter.com/didierverna

http://www.facebook.com/didier.verna

http://www.linkedin.com/in/didierverna


Plan

Un paradigme de Programmation

La Fonction : un Objet de 1re Classe

Programmation Fonctionnelle (Im)Pure

Évaluation Stricte / Paresseuse

Résumé

AFP / Introduction – Didier Verna 2/24


Plan





Résumé



Un Paradigme de Programmation« Quoi faire » plutôt que « Comment faire »I Un paradigme ?

I Affecte l’expressivité d’un langageI Affecte la manière de penser dans un langageI Le concept de paradigme est poreux

I Lequel ?I ExpressionsI Définitions (expressions nommées)I Évaluations (de définitions ou d’expressions)



De l’Impératif au Fonctionnel« La somme des carrés des entiers entre 1 et N »

C (impératif)int ssq (int n){

int i = 1, a = 0;while (i <= n)

{a += i*i;i += 1;

}return a;

}

C (récursif)int ssq (int n){

if (n == 1)return 1;

elsereturn n*n + ssq (n-1);

}

Lisp(defun ssq (n)

(if (= n 1)1(+ (* n n) (ssq (1- n)))))

Haskellssq :: Int -> Intssq 1 = 1ssq n = n*n + ssq (n-1)

I ClartéI Concision



De l’Impératif à l’Envers« La racine carrée de la somme des carrés de a et de b »

C (impératif)float hypo (float a, float b){

float a2 = a*a;float b2 = b*b;float s = a2 + b2;

return sqrt (s);}

C (moins impératif)float hypo (float a, float b){

return sqrt (a*a + b*b);}

Haskellhypo :: Float -> Float -> Floathypo a b = sqrt ((a*a) + (b*b))

Lisp(defun hypo (a b)(sqrt (+ (* a a) (* b b))))

Pour être tout à fait honnête :

Haskell (100% préfixe)hypo :: Float -> Float -> Floathypo a b = sqrt ((+) ((*) a a) ((*) b b))



Plan





Résumé



La Fonction : un Objet de 1re Classe1er ordre, ordre supérieur etc.I Christopher Strachey (1916-1975)

I nommage (variables)I agrégation (structures)I argument de fonctionI retour de fonctionI manipulation anonymeI construction dynamiqueI …

I Plus d’expressivité (clarté, concision etc.)



Nommage, Affectation, AgrégationAussi simple que d’écrire i = j

Haskellbackwards :: [a] -> [a]backwards = reverse

Scheme(define backwards reverse)

Lisp(setf (symbol-function 'backwards) #'reverse)



Arguments FonctionnelsDeux archétypes : mapping et foldingI mapping : traiter individuellement les éléments d’une liste par une

fonctionLisp(mapcar #'sqrt '(1 2 3 4 5))

Haskellmap sqrt [1..5]

I folding : combiner les éléments d’une liste par une fonctionLisp(reduce #'+ '(1 2 3 4 5))

Haskellfoldr1 (+) [1..5]sum [1..5]



Fonctions AnonymesDes littéraux comme les autresI Possibilité de ne pas nommer les fonctions

Lisp(lambda (x) (* 2 x))

Haskell\x -> 2 * x

I Utilisation littérale (comme tout autre type de donnée)Lisp((lambda (x) (* 2 x)) 4)

Haskell(\x -> 2 * x) 4



Retours Fonctionnels (Anonymes)Aussi simple que return 42;

Lisp(defun adder (n)(lambda (x) (+ x n)))

Haskelladder :: Int -> (Int -> Int)adder n = \x -> x + n



Pseudo-1er Ordre en ImpératifOn fait ce qu’on peut…I Les structures de contrôle impératives sont des formes fixes de

fonctions d’ordre supérieur

if (expression){ /* ANONYMOUS PROCEDURE ! */

/* blah blah ... */}else{ /* ANONYMOUS PROCEDURE ! */

/* blah blah ... */}



Plan





Résumé



Programmation Fonctionnelle PureLa fonction au sens mathématique

ssq(x) ={1 si x = 1,x2 + ssq(x − 1) sinon.


I FonctionI Impératif : (procédure) ensemble de calculs à effets de bords avec

éventuellement retour d’une valeurI Fonctionnel Pur : calcul d’une valeur de sortie (retour) en fonction

de valeurs d’entrée (arguments)I Variable

I Impératif : stockage d’information qui varie au cours du temps(mutation)

I Fonctionnel Pur : (constante) valeur inconnue ou arbitraire



Intérêts de la PuretéPureté =⇒ (plus de) suretéI Parallélisme

I Cf. ErlangI Sémantique locale aux fonctions

I Tests locaux / Bugs locauxI Preuve de programme



Preuves FormellesInduction mathématique

« Prouvez-moi (s’il vous plaît) que ∀N, ssq(N) > 0 »

Fonctionnel pur


I C’est vrai au rang 1I Supposons que ce soit vrai

au rang N − 1…

Impératif

Cint ssq (int n){

int i = 1, a = 0;while (i <= n)

{a += i*i;i += 1;

}return a;

}

I Euh…



Limites du Formalisme MathématiqueComment exprimer le concept de « racine carrée » ?

sqrt(x) = y |{

y > 0

y2 = x

Lisp(defun sqrt (x) ???)

Haskellsqrt :: Float -> Floatsqrt x = ???

Lisp(defun sqrtp (s x)

(and (> s 0)(= (* s s) x)))

Haskellsqrtp :: Float -> Float -> Boolsqrtp s x = s > 0 && s*s == x

I Au final, il faut bien expliquer comment faire…I Mais on repousse le problème : déclaratif ou impératif ?



Plan





Résumé



Évaluation Stricte / ParesseuseÀ quel moment calculer la valeur d’une expression ?I Stricte : Lisp

Les arguments (expressions) sont évalués d’abordI Paresseuse (lazy) : Haskell

Les expressions ne sont évaluées que quand le besoin s’en fait sentir(idem pour les agrégats)



Évaluation Stricte / ParesseuseLa paresse : une vertu ?I Intérêt : plus d’abstraction

(ex. manipulation de listes infinies)Lisp(defun intlist (s)(cons s (intlist (1+ s))))

;; KO

Haskellintlist :: Int -> [ Int ]intlist s = s : intlist (s + 1)

-- OK

I Contrainte : pureté fonctionnelle requise(on ne peut pas s’appuyer sur l’ordre d’évaluation)



Pseudo-Paresse en ImpératifOn ne fait toujours que ce qu’on peut…I Les structures de contrôle impératives sont des formes

embryonnaires d’évaluation paresseuse.

if (1){ /* COMPUTED */

/* blah blah ... */}else{ /* NOT COMPUTED ! */

/* blah blah ... */}



Plan





Résumé



Bénéfices de l’Approche FonctionnelleLes 3 caractéristiques des (bons) langages

Procédures / Données

Primitives

Combinaisons Abstractions

I Moins de distinction entre procédures et donnéesI Plus de puissance dans la combinaisonI Plus de puissance dans l’abstraction


Approches Fonctionnelles de la Programmation - 48 ...didier/lectures/afp/afp_00_introduction.pdf ·...

Documents

Transcript of Approches Fonctionnelles de la Programmation - 48 ...didier/lectures/afp/afp_00_introduction.pdf ·...