IFT359 – Programmation fonctionnelle Thème 07 Fermeture, affectation ou monades 1

Rappel : variable et environnement On appelle liaison l’association entre une variable et sa valeur – e.g. la variable x est liée à la valeur 3. On appelle environnement l’ensemble des liaisons accessibles à un moment donné –L’environnement est représenté par des boîtes s’emboitant les unes dans les autres et chaque boîte est aussi appelé environnement. L’environnement global contient des liaisons prédéfinies (+, -, list, map, etc.) define permet d’ajouter des liaisons dans l’environnement courant –On ne peut pas ajouter de define partout dans le code Chaque application ((λ(id …) body …) val …) crée un environnement pointant sur l’environnement dans lequel (λ(id …) body …) a été évalué et contenant les liaisons id  val … –Les val … sont évalués avant la construction de ce nouvel environnement donc dans l’environnement courant au moment de l’évaluation de l’application. 2

Variables libres (free) / liées (bound) (define a 3) (let ([x 5]) (λ (y) (+ x y a))) (let ([z (+ a 2)]) (λ (a) (- z a))) Dans les les 0 sont des variables libres et les _ sont des variables liées. 3

Fermeture (closure) Ce n’est pas un nouveau concept dans ce cours, nous faisons que donner un nom à ce que nous avons expliqué. Fermeture : code + environnement –une fermeture contient le code de la fonction et l’environnement dans lequel la fonction est définie, i.e. les liaisons existantes des variables lors de son évaluation (ne pas confondre avec son application). Toutes les évaluation de λ créent une fermeture mais on réserve en général ce terme pour désigner les λ définies dans un environnement autre que l’environnement global. –Par exemple, les λ définies dans le corps d’un let. 4

Portée statique (static or lexical scope) En gros, comme en C/Java –La portée est définie au moment de la compilation et non de l’exécution (let ([a 5]) (let ([f (λ (x) (+ x a))] [a 0]) (f 10))) –La portée statique donnera 15 tandis que la porté dynamique donnerait 10 5

Visibilité d’une liaison (define a 1) (define f (λ (x) (+ x 1))) (let ([x a] [y 20]) (let* ([u (+ x y)] [v (+ a u)] [a (f 5)]) (list a (f a) x y u v))) La plus récente liaison cache (shadows) les précédentes 6

Affectation Attention, son utilisation dans le cours est permises uniquement au cas par cas ! (set! id exp) –Comme define, set! produit # Modifie la liaison : –Qu’elle soit globale (créé par un define) –ou locale (paramètre d’une λ) n’oubliez pas que les let sont des λ déguisés Le suffixe ! est ajouté aux procédures qui ont des effets de bord 7

Affectation Ce n’est pas un pointeur sur n qui est passé en paramètre mais la valeur de n Ce n’est pas la variable qui porte le type, mais la valeur elle-même (define x 3) (set! x #t) x -> #t DrRacket fait du passage par valeur (define n 5) (define f (λ (n) (set! n (+ n 1)))) (f n) n -> 5 8

Affectation et évaluation par environnement (define i 0) (define inc! (λ () (set! i (+ i 1)))) (inc!) i  1 Env initial i  0 inc var : aucune corps : (set! i (+ i 1))) (set! i(+ i 1)) 9

Affectation et évaluation par environnement ((let ([a 3]) (λ (b) (set! a b) a)) 8) Step 1 : transformer les let en λ Step 2 : réduire les applications a: évaluer tous les termes de l’application b: créer un env. pointant sur celui de la fonction c: associer dans cet env les vars à leurs valeurs d: évaluer par env le corps de la fonction dans environnement. (((λ (a) (λ (b) (set! a b) a)) 3) 8) 10

Affectation et évaluation par environnement 11 (((λ (a) (λ (b) (set! a b) a)) 3) 8) v : a c: (λ (b) (set! a b) a) a  3 8 v : b c: (set! a b) a b  8 Env. global évaluation de 8 évaluation de ((λ (a) …) 3) évaluation de 3 évaluation de (λ (a) …) création de l’env et association var val eval par env du corps de (λ (a) …) eval par env de (λ (b) …) ce dernier résultat est retourné création de l’env et association var val eval par env du corps de (λ (b) …) eval de (set! a b) eval de a ce dernier résultat est retourné FIN

Durée de vie d’une liaison (extent) La durée de vie est illimitée –Comme les variables statiques en C et non les variables auto (par défaut). –le ramasse-miettes (garbage collector) doit prouver qu’une liaison peut être éliminée (define f (let ([a 10]) (λ () (let ([c a]) (set! a (add1 a)) c)))) (f)  10 (f)  11 Toutes les variables nécessaires pour définir la fermeture de f sont conservées tant que f existe 12

compte-appel Définir une procédure qui retourne le nombre le fois où elle a été appelée –Sans utiliser une variable globale (define compte-appel (let ([n 0]) (λ () (set! n (add1 n)) n))) (define compte-appel ((λ (n) (λ () (set! n (add1 n)) n)) 0)) compte-appel v: n c : (λ () (set! n (add1 n)) n)) n  0 v: nil c: (set! n (add1 n)) n 13

GARDER COMME ARGUMENT LE RÉSULTAT PARTIEL DANS UNE FONCTION AUXILIAIRE RÉCURSIVE, Astuce 14

Reverse 15 (define reverse (λ (lst) (let iter ([reste lst] [res '()]) (if (null? reste) res (iter (cdr reste) (cons (car reste) res))))))

Factoriel 16 (define fact (λ (n) (let iter ([res 1] [k n]) (if (> k 0) (iter (* k res) (sub1 k)) res))))

Length 17 (define length (λ (lst) (letrec ([iter (λ (reste res) (cond [(null? reste) res] [else (iter (cdr reste) (add1 res))]))]) (iter lst 0))))

Fibonacci 18 (define (fib n) (letrec ([iter (λ (a b compteur) (if (= compteur 0) b (iter (+ a b) a (- compteur 1))))]) (iter 1 0 n))) (define (fib n) (let iter ([a 1] [b 0] [compteur n]) (if (= compteur 0) b (iter (+ a b) a (- compteur 1)))))

foldl 19 (define foldl (λ (proc init lst) (let iter ([reste lst] [res init]) (if (null? reste) res (iter (cdr reste) (proc (car reste) res)))))) (define foldl (λ (proc init lst) (if (null? lst) init (foldl proc (proc (car lst) init) (cdr lst))))) code donné comme exemple mais ce n’est pas la façon la plus élégante de définir foldl. voir ci-dessous