1. IFT359 – Programmation fonctionnelle Thème #4 Fonctions récursives Thème #3 : évaluation par environnement a été présenté avec thème #2

2. Fonctions récursives et données récursives Plusieurs algorithmes connus ont une forme canonique récursive {e.g. tri fusion, tri rapide} Certains de ces algorithmes sont souvent le fruit d’une réflexion très poussée –Il est intéressant de les implémenter –Mais nous pratiquerons avec des cas plus simples En définissant des types de données relativement simples sous forme récursive, les algorithmes pour les manipuler seront naturellement récursifs

3. Naturels Primitive pour les nat : add1 : constructeur zero? : prédicat sub1 : sélecteur (sub1 0) non défini. Un nat est soit 0 ou le résultat de l’application de add1 à un nat Exemple de fonction récursive (define plusplus (λ (n m) (cond [(zero? m) n] [else (add1 (plus n (sub1 m)))]))) Attention il faut faire les exercices avec les primitives et les fonctions que vous avez définies. add1, sub1 et zero? sont prédéfinis dans racket.

4. naturels (define mult (λ (n m) (cond [(zero? m) 0] [else (plus n (mult n (sub1 m)))]))) (define gt (λ (n m) (cond [(zero? n) #f] [(zero? m) #t] [else (gt (sub1 n) (sub1 m))])))

5. atome (define atom? (λ (x) (or (boolean? x) (number? x) (char? x) (symbol? x)))) Un atome est soit un booléen, un nombre, un caractère ou un symbole. Il aurait été aussi possible d’en ajouter d’autres comme les procédures avec procedure? (atom? 3) -> #t (atom? '()) -> #f (atom? '(1. 2)) -> #f (atom? '(a b c)) -> #f

6. Listes d’atomes Primitive pour les lat : cons : constructeur atom? : prédicat null? : prédicat car : sélecteur cdr : sélecteur (define length (λ (lat) (cond [(null? lat) 0] [else (add1 (length (cdr lat)))])))

7. lat? et contient? (define lat? ;;; ≡ list? (λ (lat) (cond [(null? lat) #t] [(atom? (car lat)) (lat? (cdr lat))] [else #f]))) (define contient? ;;;  member (λ (a lat) (cond [(null? lat) #f] [(equal? a (car lat)) #t] ;; quelle est la différence si on met eq? ou eqv? ? [else (contient? a (cdr lat))])))

8. remove (define remove ; enlève le premier a de lat (λ (a lat) (cond [(null? lat) '()] [(equal? a (car lat)) (cdr lat)] ;; quelle est la différence si on met eq? ou eqv? ? [else (cons (car lat) (remove a (cdr lat)))]))) ;;; modifier la fonction pour qu’elle enlève toutes les occurences ;;; modifier la fonction pour qu’elle enlève la ième occurennce ;;; ajouter le paramètre i à la fonction

9. substitution (define subst ;;;substitue le premier old par new dans la liste lat (λ (new old lat) (cond [(null? lat) '()] [(equal? old (car l)) (cons new (cdr lat))] [else (cons (car lat) (subst new old (cdr lat)))]))) ;;; modifier la fonction pour qu’elle les substitue toutes ;;; modifier la fonction pour qu’elle substitue que la ième occurennce ;;; ajouter le paramètre i à la fonction

10. Les tuples (liste de nombres naturels) (define somme (λ (t) (cond [(null? t) 0] [else (plus (car t) (somme (cdr t)))]))) Primitive pour les tup : ce sont ceux pour les lat et les nat Puisque les tup sont un cas particulier des lat.

11. Arbres ou s-expression (données hiérarchiques) voici des exemples de s-exp : '() 3 '(+ (- 2 1) (* 3 4)) Dans une définition d’un type ou d’un construit syntaxique, la forme xxx … signifie 0 ou plus d’occurrence de données du type xxx si xxx est un type ou de l’objet xxx autrement. exemple : (1 2 char … ) signifie par exemple (1 2 #\a #\=), (1 2). (1 2 … ) signifie par exemple (1 2), (1), (1 2 2 2).

12. Représentation de '(+ (- 2 1) (* 3 4))

13. Opérations sur les arbres (define compte-atomes (λ (s-exp) (cond [(null? s-exp) 0] [(atom? s-exp) 1] [else (plus (compte-atomes (car s-exp)) (compte-atomes (cdr s-exp)))])))

14. évaluation d’un arbre représentant une expression (define eval-exp (λ (exp) (cond [(null? exp) 0] [(atom? exp) exp] [(eq? (car exp) '+) (plus (eval-exp (cadr exp)) (eval-exp (caddr exp)))]... [else 'exp-invalide]))) Le … signifie qu’il faut ajouter des clauses similaires à la précédente pour les autres opérations

15. le nombre d’occurrences d’un elt (define occur (λ (a arbre) (cond [(null? arbre) 0] [(atom? arbre) (cond [(eq? a arbre) 1] [else 0]) [else (plus (occur a (car arbre)) (occur a (cdr arbre)))])))

16. Listes imbriquées Nested lists ou encore List of lists Un peu plus spécifique que les arbres –i.e. une liste imbriquée est un arbre –Les arbres qui se réduisent à un atome ne sont pas des lol

17. éliminer des elts dans une liste imbriquée (define remove* (λ (e lol) (cond [(null? lol) '()] [(atom? (car lol)) (cond [(eq? e (car lol)) (cdr lol)] [else (cons (car lol) (remove* e (cdr lol)))])] [else (cons (remove* e (car lol)) (remove* e (cdr lol)))]))) a)modifier la fonction pour qu’elle élimine que la première occurrence b)modifier la fonction pour qu’elle élimine toutes les occurences

18. En général… Faire un exemple à la main de l’appel récursif souhaité. Identifier la condition de fin, par exemple null? pour les lat et zero? pour les nat. Choisir judicieusement la valeur associé aux cas de base avant de traiter les cas généraux {qui font les appels récursifs}. À chaque appel récursif, la valeur d’au moins un argument doit changer et cette nouvelle valeur doit tendre vers la condition de fin. Certaines procédures agissent comme des constructeurs, par exemple cons pour les lat et add1 pour les nat. Quand on construit une nouvelle liste, cons combine généralement le résultat d’une opération sur le car de la liste originale à l’appel récursif qui est fait avec le cdr de cette dernière. Pour les listes imbriquées, on combine généralement le résultat de l’appel récursif fait sur le car à celui fait sur le cdr.